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

package/src/parsers/texttracks/webvtt/html/__tests__/to_html.test.ts

@@ -1,20 +1,30 @@
-import { describe, beforeEach, it, expect, vi } from "vitest";
+import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
 import type { IStyleElements } from "../../parse_style_block";
-import type IToHtml from "../to_html";
+import toHTML from "../to_html";
+
+const mocks = vi.hoisted(() => {
+  return {
+    convertPayloadToHTML: vi.fn(),
+  };
+});
+vi.mock("../convert_payload_to_html", () => ({
+  default: mocks.convertPayloadToHTML,
+}));
 
 describe("parsers - webvtt - toHTML", () => {
   beforeEach(() => {
     vi.resetModules();
   });
+  afterEach(() => {
+    mocks.convertPayloadToHTML.mockReset();
+  });
 
-  it("should include payload HTML", async () => {
-    vi.doMock("../convert_payload_to_html", () => ({
-      default: () => {
-        return [document.createElement("b"), document.createTextNode("Hello")];
-      },
-    }));
+  it("should include payload HTML", () => {
+    mocks.convertPayloadToHTML.mockImplementation(() => [
+      document.createElement("b"),
+      document.createTextNode("Hello"),
+    ]);
 
-    const toHTML = (await vi.importActual("../to_html")).default as typeof IToHtml;
     const cueObject = {
       start: 0,
       end: 100,
@@ -46,14 +56,12 @@ describe("parsers - webvtt - toHTML", () => {
     );
   });
 
-  it("should include payload HTML and apply correclty style class element", async () => {
-    vi.doMock("../convert_payload_to_html", () => ({
-      default: () => {
-        return [document.createElement("b"), document.createTextNode("Hello")];
-      },
-    }));
+  it("should include payload HTML and apply correclty style class element", () => {
+    mocks.convertPayloadToHTML.mockImplementation(() => [
+      document.createElement("b"),
+      document.createTextNode("Hello"),
+    ]);
 
-    const toHTML = (await vi.importActual("../to_html")).default as typeof IToHtml;
     const cueObject = {
       start: 0,
       end: 100,
@@ -87,14 +95,12 @@ describe("parsers - webvtt - toHTML", () => {
     );
   });
 
-  it("should include payload HTML and apply correctly global style element", async () => {
-    vi.doMock("../convert_payload_to_html", () => ({
-      default: () => {
-        return [document.createElement("b"), document.createTextNode("Hello")];
-      },
-    }));
+  it("should include payload HTML and apply correctly global style element", () => {
+    mocks.convertPayloadToHTML.mockImplementation(() => [
+      document.createElement("b"),
+      document.createTextNode("Hello"),
+    ]);
 
-    const toHTML = (await vi.importActual("../to_html")).default as typeof IToHtml;
     const cueObject = {
       start: 0,
       end: 100,
@@ -127,14 +133,12 @@ describe("parsers - webvtt - toHTML", () => {
     );
   });
 
-  it("should apply both the global style element and a given class", async () => {
-    vi.doMock("../convert_payload_to_html", () => ({
-      default: () => {
-        return [document.createElement("b"), document.createTextNode("Hello")];
-      },
-    }));
+  it("should apply both the global style element and a given class", () => {
+    mocks.convertPayloadToHTML.mockImplementation(() => [
+      document.createElement("b"),
+      document.createTextNode("Hello"),
+    ]);
 
-    const toHTML = (await vi.importActual("../to_html")).default as typeof IToHtml;
     const cueObject = {
       start: 0,
       end: 100,
@@ -168,14 +172,9 @@ describe("parsers - webvtt - toHTML", () => {
     );
   });
 
-  it("should return default element if no payload", async () => {
-    vi.doMock("../convert_payload_to_html", () => ({
-      default: () => {
-        return [];
-      },
-    }));
+  it("should return default element if no payload", () => {
+    mocks.convertPayloadToHTML.mockImplementation(() => []);
 
-    const toHTML = (await vi.importActual("../to_html")).default as typeof IToHtml;
     const cueObject = {
       start: 0,
       end: 100,

package/src/transports/dash/segment_parser.ts

@@ -14,10 +14,13 @@
  * limitations under the License.
  */
 
+import shouldPatchOutDolbyVisionConfigDataFromMp4 from "../../compat/should_patch_out_dolby_vision_config_data_from_mp4";
+import logger from "../../log";
 import {
   getMDHDTimescale,
   getSegmentsFromSidx,
   takePSSHOut,
+  removeDolbyVisionConfigData,
 } from "../../parsers/containers/isobmff";
 import {
   getKeyIdFromInitSegment,
@@ -163,6 +166,16 @@ export default function generateAudioVideoSegmentParser({
     if (containerType === "webm") {
       segmentList = getSegmentsFromCues(chunkData, 0);
     } else if (seemsToBeMP4) {
+      if (
+        shouldPatchOutDolbyVisionConfigDataFromMp4(
+          context.baseCodecs,
+          context.chosenCodec,
+        )
+      ) {
+        logger.debug("dash", "patching out Dolby Vision metadata from segment");
+        removeDolbyVisionConfigData(chunkData);
+      }
+
       segmentList = getSegmentsFromSidx(
         chunkData,
         Array.isArray(indexRange) ? indexRange[0] : 0,

package/src/transports/dash/text_parser.ts

@@ -106,7 +106,11 @@ function parseISOBMFFEmbeddedTextTrack(
   }
   const chunkInfos = getISOBMFFTimingInfos(chunkBytes, isChunked, segment, initTimescale);
   const chunkData = getISOBMFFEmbeddedTextTrackData(
-    context,
+    {
+      segment: context.segment,
+      codecs: context.chosenCodec,
+      language: context.language,
+    },
     chunkBytes,
     initTimescale,
     chunkInfos,

package/src/transports/local/text_parser.ts

@@ -76,7 +76,11 @@ function parseISOBMFFEmbeddedTextTrack(
   }
   const chunkInfos = getISOBMFFTimingInfos(chunkBytes, isChunked, segment, initTimescale);
   const chunkData = getISOBMFFEmbeddedTextTrackData(
-    context,
+    {
+      segment: context.segment,
+      codecs: context.chosenCodec,
+      language: context.language,
+    },
     chunkBytes,
     initTimescale,
     chunkInfos,

package/src/transports/metaplaylist/pipelines.ts

@@ -64,7 +64,8 @@ function getOriginalContext(mplContext: ISegmentContext): ISegmentContext {
     type: mplContext.type,
     language: mplContext.language,
     mimeType: mplContext.mimeType,
-    codecs: mplContext.codecs,
+    baseCodecs: mplContext.baseCodecs,
+    chosenCodec: mplContext.chosenCodec,
     isLive,
     periodStart,
     periodEnd,

package/src/transports/smooth/isobmff/__tests__/create_boxes.test.ts

@@ -1,60 +1,129 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-import type {
-  createFRMABox as ICreateFRMABox,
-  createFreeBox as ICreateFreeBox,
-  createHDLRBox as ICreateHDLRBox,
-  createMDHDBox as ICreateMDHDBox,
-  createSMHDBox as ICreateSMHDBox,
-  createVMHDBox as ICreateVMHDBox,
+import {
+  createFRMABox,
+  createFreeBox,
+  createHDLRBox,
+  createMDHDBox,
+  createSMHDBox,
+  createVMHDBox,
 } from "../create_boxes";
 
+const mocks = vi.hoisted(() => {
+  return {
+    isobmff: {
+      createBox: vi.fn(),
+    },
+    byteParsing: {
+      itobe2: vi.fn(),
+      itobe4: vi.fn(),
+      itobe8: vi.fn(),
+      le2toi: vi.fn(),
+      be2toi: vi.fn(),
+      be3toi: vi.fn(),
+      be4toi: vi.fn(),
+      be8toi: vi.fn(),
+      concat: vi.fn(),
+      be4toiSigned: vi.fn(),
+    },
+    stringParsing: {
+      strToUtf8: vi.fn(),
+      bytesToHex: vi.fn(),
+      guidToUuid: vi.fn(),
+      utf16LEToStr: vi.fn(),
+      hexToBytes: vi.fn(),
+      readNullTerminatedString: vi.fn(),
+    },
+  };
+});
+vi.mock("../../../../parsers/containers/isobmff", () => ({
+  createBox: mocks.isobmff.createBox,
+}));
+vi.mock("../../../../utils/byte_parsing", () => ({
+  itobe2: mocks.byteParsing.itobe2,
+  itobe4: mocks.byteParsing.itobe4,
+  itobe8: mocks.byteParsing.itobe8,
+  le2toi: mocks.byteParsing.le2toi,
+  be2toi: mocks.byteParsing.be2toi,
+  be3toi: mocks.byteParsing.be3toi,
+  be4toi: mocks.byteParsing.be4toi,
+  be8toi: mocks.byteParsing.be8toi,
+  concat: mocks.byteParsing.concat,
+  be4toiSigned: mocks.byteParsing.be4toiSigned,
+}));
+vi.mock("../../../../utils/string_parsing", () => ({
+  strToUtf8: mocks.stringParsing.strToUtf8,
+  bytesToHex: mocks.stringParsing.bytesToHex,
+  guidToUuid: mocks.stringParsing.guidToUuid,
+  utf16LEToStr: mocks.stringParsing.utf16LEToStr,
+  hexToBytes: mocks.stringParsing.hexToBytes,
+  readNullTerminatedString: mocks.stringParsing.readNullTerminatedString,
+}));
+
 describe("Smooth - ISOBMFF - boxes creation", () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.resetModules();
+
+    const actualIsobmff = await vi.importActual("../../../../parsers/containers/isobmff");
+    const actualByteParsing = await vi.importActual("../../../../utils/byte_parsing");
+    const actualStringParsing = await vi.importActual("../../../../utils/string_parsing");
+
+    const isobmffKeys = Object.keys(mocks.isobmff) as Array<keyof typeof mocks.isobmff>;
+    isobmffKeys.forEach((key: keyof typeof mocks.isobmff) => {
+      mocks.isobmff[key].mockReset();
+      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      mocks.isobmff[key].mockImplementation(actualIsobmff[key] as (...args: any) => any);
+    });
+
+    const byteParsingKeys = Object.keys(mocks.byteParsing) as Array<
+      keyof typeof mocks.byteParsing
+    >;
+    byteParsingKeys.forEach((key: keyof typeof mocks.byteParsing) => {
+      mocks.byteParsing[key].mockReset();
+      mocks.byteParsing[key].mockImplementation(
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        actualByteParsing[key] as (...args: any) => any,
+      );
+    });
+
+    const stringParsingKeys = Object.keys(mocks.stringParsing) as Array<
+      keyof typeof mocks.stringParsing
+    >;
+    stringParsingKeys.forEach((key: keyof typeof mocks.stringParsing) => {
+      mocks.stringParsing[key].mockReset();
+      mocks.stringParsing[key].mockImplementation(
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        actualStringParsing[key] as (...args: any) => any,
+      );
+    });
   });
 
   describe("createVMHDBox", () => {
-    it("should create always the same vmhd box", async () => {
+    it("should create always the same vmhd box", () => {
       const vmhdContent = new Uint8Array([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]);
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createVMHDBox = (await vi.importActual("../create_boxes"))
-        .createVMHDBox as typeof ICreateVMHDBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createVMHDBox()).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith("vmhd", vmhdContent);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("vmhd", vmhdContent);
     });
   });
 
   describe("createFreeBox", () => {
-    it("should create box full of 0s", async () => {
+    it("should create box full of 0s", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createFreeBox = (await vi.importActual("../create_boxes"))
-        .createFreeBox as typeof ICreateFreeBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createFreeBox(8)).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith("free", new Uint8Array([]));
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("free", new Uint8Array([]));
 
       expect(createFreeBox(15)).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(2);
-      expect(mockCreateBox).toHaveBeenCalledWith("free", new Uint8Array(7));
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(2);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("free", new Uint8Array(7));
     });
 
-    it("should throw when given a length below 8", async () => {
+    it("should throw when given a length below 8", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createFreeBox = (await vi.importActual("../create_boxes"))
-        .createFreeBox as typeof ICreateFreeBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(() => createFreeBox(7)).toThrow();
       expect(() => createFreeBox(6)).toThrow();
       expect(() => createFreeBox(5)).toThrow();
@@ -63,47 +132,32 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       expect(() => createFreeBox(2)).toThrow();
       expect(() => createFreeBox(1)).toThrow();
       expect(() => createFreeBox(0)).toThrow();
-      expect(mockCreateBox).not.toHaveBeenCalled();
+      expect(mocks.isobmff.createBox).not.toHaveBeenCalled();
     });
 
-    it("should throw when given a negative length", async () => {
+    it("should throw when given a negative length", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createFreeBox = (await vi.importActual("../create_boxes"))
-        .createFreeBox as typeof ICreateFreeBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(() => createFreeBox(-1)).toThrow();
-      expect(mockCreateBox).not.toHaveBeenCalled();
+      expect(mocks.isobmff.createBox).not.toHaveBeenCalled();
     });
 
-    it("should throw when given a non-finite length", async () => {
+    it("should throw when given a non-finite length", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createFreeBox = (await vi.importActual("../create_boxes"))
-        .createFreeBox as typeof ICreateFreeBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(() => createFreeBox(-Infinity)).toThrow();
       expect(() => createFreeBox(+Infinity)).toThrow();
-      expect(mockCreateBox).not.toHaveBeenCalled();
+      expect(mocks.isobmff.createBox).not.toHaveBeenCalled();
     });
   });
 
   describe("createHDLRBox", () => {
-    it("should always create the same audio box", async () => {
+    it("should always create the same audio box", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createHDLRBox = (await vi.importActual("../create_boxes"))
-        .createHDLRBox as typeof ICreateHDLRBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createHDLRBox("audio")).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith(
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith(
         "hdlr",
         new Uint8Array([
           0,
@@ -147,17 +201,12 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       );
     });
 
-    it("should always create the same video box", async () => {
+    it("should always create the same video box", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createHDLRBox = (await vi.importActual("../create_boxes"))
-        .createHDLRBox as typeof ICreateHDLRBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createHDLRBox("video")).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith(
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith(
         "hdlr",
         new Uint8Array([
           0,
@@ -201,17 +250,12 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       );
     });
 
-    it("should always create the same hint box", async () => {
+    it("should always create the same hint box", () => {
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createHDLRBox = (await vi.importActual("../create_boxes"))
-        .createHDLRBox as typeof ICreateHDLRBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createHDLRBox("hint")).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith(
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith(
         "hdlr",
         new Uint8Array([
           0,
@@ -245,81 +289,60 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
   });
 
   describe("createMDHDBox", () => {
-    it("should just integrate the timescale given", async () => {
+    it("should just integrate the timescale given", () => {
       const translatedTimeScale = new Uint8Array([4, 3, 2, 1]);
       const concatenated = new Uint8Array([9, 10, 11, 12]);
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockItobe4 = vi.fn().mockImplementation(() => translatedTimeScale);
-      const mockConcat = vi.fn().mockImplementation(() => concatenated);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../utils/byte_parsing", () => {
-        return { itobe4: mockItobe4, concat: mockConcat };
-      });
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createMDHDBox = (await vi.importActual("../create_boxes"))
-        .createMDHDBox as typeof ICreateMDHDBox;
+      mocks.byteParsing.itobe4.mockImplementation(() => translatedTimeScale);
+      mocks.byteParsing.concat.mockImplementation(() => concatenated);
+      mocks.isobmff.createBox.mockImplementation(() => box);
 
       expect(createMDHDBox(8)).toBe(box);
 
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith("mdhd", concatenated);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("mdhd", concatenated);
 
-      expect(mockItobe4).toHaveBeenCalledTimes(1);
-      expect(mockItobe4).toHaveBeenCalledWith(8);
+      expect(mocks.byteParsing.itobe4).toHaveBeenCalledTimes(1);
+      expect(mocks.byteParsing.itobe4).toHaveBeenCalledWith(8);
 
-      expect(mockConcat).toHaveBeenCalledTimes(1);
-      expect(mockConcat).toHaveBeenCalledWith(12, translatedTimeScale, 8);
+      expect(mocks.byteParsing.concat).toHaveBeenCalledTimes(1);
+      expect(mocks.byteParsing.concat).toHaveBeenCalledWith(12, translatedTimeScale, 8);
 
       expect(createMDHDBox(99)).toBe(box);
 
-      expect(mockCreateBox).toHaveBeenCalledTimes(2);
-      expect(mockCreateBox).toHaveBeenCalledWith("mdhd", concatenated);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(2);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("mdhd", concatenated);
 
-      expect(mockItobe4).toHaveBeenCalledTimes(2);
-      expect(mockItobe4).toHaveBeenCalledWith(99);
+      expect(mocks.byteParsing.itobe4).toHaveBeenCalledTimes(2);
+      expect(mocks.byteParsing.itobe4).toHaveBeenCalledWith(99);
 
-      expect(mockConcat).toHaveBeenCalledTimes(2);
-      expect(mockConcat).toHaveBeenCalledWith(12, translatedTimeScale, 8);
+      expect(mocks.byteParsing.concat).toHaveBeenCalledTimes(2);
+      expect(mocks.byteParsing.concat).toHaveBeenCalledWith(12, translatedTimeScale, 8);
     });
   });
 
   describe("createSMHDBox", () => {
-    it("should create always the same smhd box", async () => {
+    it("should create always the same smhd box", () => {
       const smhdContent = new Uint8Array(8);
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createSMHDBox = (await vi.importActual("../create_boxes"))
-        .createSMHDBox as typeof ICreateSMHDBox;
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createSMHDBox()).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith("smhd", smhdContent);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("smhd", smhdContent);
     });
   });
 
   describe("createFRMABox", () => {
-    it("should just integrate the data format", async () => {
+    it("should just integrate the data format", () => {
       const dataFormatToBytes = new Uint8Array([4, 3, 2, 1]);
       const box = new Uint8Array([1, 2, 3, 4]);
-      const mockStrToUtf8 = vi.fn().mockImplementation(() => dataFormatToBytes);
-      const mockCreateBox = vi.fn().mockImplementation(() => box);
-      vi.doMock("../../../../utils/string_parsing", () => {
-        return { strToUtf8: mockStrToUtf8 };
-      });
-      vi.doMock("../../../../parsers/containers/isobmff", () => {
-        return { createBox: mockCreateBox };
-      });
-      const createFRMABox = (await vi.importActual("../create_boxes"))
-        .createFRMABox as typeof ICreateFRMABox;
+      mocks.stringParsing.strToUtf8.mockImplementation(() => dataFormatToBytes);
+      mocks.isobmff.createBox.mockImplementation(() => box);
       expect(createFRMABox("foo")).toBe(box);
-      expect(mockCreateBox).toHaveBeenCalledTimes(1);
-      expect(mockCreateBox).toHaveBeenCalledWith("frma", dataFormatToBytes);
-      expect(mockStrToUtf8).toHaveBeenCalledTimes(1);
-      expect(mockStrToUtf8).toHaveBeenCalledWith("foo");
+      expect(mocks.isobmff.createBox).toHaveBeenCalledTimes(1);
+      expect(mocks.isobmff.createBox).toHaveBeenCalledWith("frma", dataFormatToBytes);
+      expect(mocks.stringParsing.strToUtf8).toHaveBeenCalledTimes(1);
+      expect(mocks.stringParsing.strToUtf8).toHaveBeenCalledWith("foo");
     });
   });
 });

package/src/transports/smooth/pipelines.ts

@@ -269,7 +269,7 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
     ):
       | ISegmentParserParsedInitChunk<null>
       | ISegmentParserParsedMediaChunk<ITextTrackSegmentData | null> {
-      const { segment, language, mimeType = "", codecs = "" } = context;
+      const { segment, language, mimeType = "", chosenCodec = "" } = context;
       const isMP4 = isMP4EmbeddedTrack(context.mimeType);
       const { data, isChunked } = loadedSegment;
       let chunkSize: number | undefined;
@@ -339,7 +339,7 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
               : segment.end;
         }
 
-        const lcCodec = codecs.toLowerCase();
+        const lcCodec = chosenCodec.toLowerCase();
         if (
           mimeType === "application/ttml+xml+mp4" ||
           lcCodec === "stpp" ||
@@ -382,7 +382,7 @@ export default function (transportOptions: ITransportOptions): ITransportPipelin
         }
 
         if (_sdType === undefined) {
-          const lcCodec = codecs.toLowerCase();
+          const lcCodec = chosenCodec.toLowerCase();
           if (lcCodec === "srt") {
             _sdType = "srt";
           } else {

package/src/transports/types.ts

@@ -556,8 +556,34 @@ export interface ISegmentContext {
   periodEnd: number | undefined;
   /** Mimetype of the corresponding Representation. */
   mimeType?: string | undefined;
-  /** Codec(s) of the corresponding Representation. */
-  codecs?: string | undefined;
+  /**
+   * An array of strings describing codecs that Representation relies on.
+   *
+   * If multiple elements are in this array, each element is a codec (or groups
+   * of codecs, e.g. for both audio and video) enhancing and backward compatible
+   * to the next element of that array.
+   *
+   * For example, a Dolby Vision video Representation could be retro-compatible
+   * with HDR10 decoders not handling Dolby Vision-specific metadata.
+   * In that scenario, we could have an array with two elements:
+   *   1. The Dolby Vision codec
+   *   2. The base HDR10 codec, hopefully with higher device compatibility.
+   */
+  baseCodecs: string[];
+  /**
+   * `baseCodecs` can define multiple codecs linked to this `Representation`,
+   * e.g. Dolby Vision retro-compatible to a non-Dolby Vision HEVC-based
+   * codec).
+   *
+   * But on the current device, we'll generally want to announce a unique
+   * codec, after checking the one that is supported.
+   *
+   * This is what `chosenCodecs` is for: the actual codec to rely on.
+   *
+   * Set to `undefined` initially until we know which codec from `baseCodecs`
+   * is supported.
+   */
+  chosenCodec: string | undefined;
   /**
    * Last published time for the Manifest file in which this segment has been
    * defined.