rx-player 3.33.0 → 3.33.1

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

@@ -1,35 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import byteRange from "../byte_range";
-
-describe("transports utils - byteRange", () => {
-  it("should construct a ByteRange string", () => {
-    expect(byteRange([0, 35])).toEqual("bytes=0-35");
-    expect(byteRange([8, 40])).toEqual("bytes=8-40");
-    expect(byteRange([888, 40])).toEqual("bytes=888-40");
-    expect(byteRange([-Infinity, 40])).toEqual("bytes=-Infinity-40");
-    expect(byteRange([-Infinity, -Infinity])).toEqual("bytes=-Infinity--Infinity");
-    expect(byteRange([Infinity, -Infinity])).toEqual("bytes=Infinity--Infinity");
-  });
-  it("should not add ending byte if end is equal to +Infinity ", () => {
-    expect(byteRange([0, Infinity])).toEqual("bytes=0-");
-    expect(byteRange([54, Infinity])).toEqual("bytes=54-");
-    expect(byteRange([0, +Infinity])).toEqual("bytes=0-");
-    expect(byteRange([54, +Infinity])).toEqual("bytes=54-");
-    expect(byteRange([Infinity, +Infinity])).toEqual("bytes=Infinity-");
-  });
-});

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

@@ -1,148 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-
-describe("transports utils - checkISOBMFFIntegrity", () => {
-  beforeEach(() => {
-    jest.resetModules();
-  });
-
-  it("should check just ftyp and and moov integrity for init segments", () => {
-    const mockFindCompleteBox = jest.fn(() => 45);
-    jest.mock("../find_complete_box", () => ({ __esModule: true as const,
-                                               default: mockFindCompleteBox }));
-    const checkISOBMFFIntegrity =
-      jest.requireActual("../check_isobmff_integrity").default;
-    const myUint8Array = new Uint8Array([0, 1, 2]);
-    expect(() => checkISOBMFFIntegrity(myUint8Array, true)).not.toThrow();
-    expect(mockFindCompleteBox).toHaveBeenCalledTimes(2);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x66747970);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6D6F6F76);
-  });
-
-  it("should check just moof and and mdat integrity for regular segments", () => {
-    const mockFindCompleteBox = jest.fn(() => 45);
-    jest.mock("../find_complete_box", () => ({ __esModule: true as const,
-                                               default: mockFindCompleteBox }));
-    const checkISOBMFFIntegrity =
-      jest.requireActual("../check_isobmff_integrity").default;
-    const myUint8Array = new Uint8Array([0, 1, 2]);
-    expect(() => checkISOBMFFIntegrity(myUint8Array, false)).not.toThrow();
-    expect(mockFindCompleteBox).toHaveBeenCalledTimes(2);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6D6F6F66);
-    expect(mockFindCompleteBox).toHaveBeenCalledWith(myUint8Array, 0x6D646174);
-  });
-
-  it("should throw an other error if an init segment is missing a complete ftyp", () => {
-    const mockFindCompleteBox = jest.fn((_, box) => box === 0x66747970 ? -1 : 45);
-    jest.mock("../find_complete_box", () => ({ __esModule: true as const,
-                                               default: mockFindCompleteBox }));
-    const OtherError =
-      jest.requireActual("../../../errors").OtherError;
-    const checkISOBMFFIntegrity =
-      jest.requireActual("../check_isobmff_integrity").default;
-    const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : unknown = null;
-    try {
-      checkISOBMFFIntegrity(myUint8Array, true);
-    } catch (e : unknown) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message)
-      .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `ftyp` box");
-  });
-
-  it("should throw an other error if an init segment is missing a complete moov", () => {
-    const mockFindCompleteBox = jest.fn((_, box) => box === 0x6D6F6F76 ? -1 : 45);
-    jest.mock("../find_complete_box", () => ({ __esModule: true as const,
-                                               default: mockFindCompleteBox }));
-    const OtherError =
-      jest.requireActual("../../../errors").OtherError;
-    const checkISOBMFFIntegrity =
-      jest.requireActual("../check_isobmff_integrity").default;
-    const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : unknown = null;
-    try {
-      checkISOBMFFIntegrity(myUint8Array, true);
-    } catch (e : unknown) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message)
-      .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `moov` box");
-  });
-
-  /* eslint-disable max-len */
-  it("should throw an other error if a regular segment is missing a complete moof", () => {
-  /* eslint-enable max-len */
-    const mockFindCompleteBox = jest.fn((_, box) => box === 0x6D6F6F66 ? -1 : 45);
-    jest.mock("../find_complete_box", () => ({ __esModule: true as const,
-                                               default: mockFindCompleteBox }));
-    const OtherError = jest.requireActual("../../../errors").OtherError;
-    const checkISOBMFFIntegrity =
-      jest.requireActual("../check_isobmff_integrity").default;
-    const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : unknown = null;
-    try {
-      checkISOBMFFIntegrity(myUint8Array, false);
-    } catch (e : unknown) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message)
-      .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `moof` box");
-  });
-
-  /* eslint-disable max-len */
-  it("should throw an other error if a regular segment is missing a complete mdat", () => {
-  /* eslint-enable max-len */
-    const mockFindCompleteBox = jest.fn((_, box) => box === 0x6D646174 ? -1 : 45);
-    jest.mock("../find_complete_box", () => ({ __esModule: true as const,
-                                               default: mockFindCompleteBox }));
-    const OtherError = jest.requireActual("../../../errors").OtherError;
-    const checkISOBMFFIntegrity =
-      jest.requireActual("../check_isobmff_integrity").default;
-    const myUint8Array = new Uint8Array([0, 1, 2]);
-    let error : unknown = null;
-    try {
-      checkISOBMFFIntegrity(myUint8Array, false);
-    } catch (e : unknown) {
-      error = e;
-    }
-    expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message)
-      .toEqual("OtherError (INTEGRITY_ERROR) Incomplete `mdat` box");
-  });
-});

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

@@ -1,138 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import findCompleteBox from "../find_complete_box";
-
-describe("transports utils - findCompleteBox", () => {
-  it("should return -1 if the box is not found", () => {
-    const byteArr = new Uint8Array([
-      0,
-      0,
-      0,
-      9,
-      0x64,
-      0x67,
-      0x32,
-      0x55,
-      4,
-      0,
-      0,
-      0,
-      10,
-      0x88,
-      0x68,
-      0x47,
-      0x53,
-      12,
-      88,
-    ]);
-
-    expect(findCompleteBox(byteArr, 0x75757575)).toEqual(-1);
-    expect(findCompleteBox(byteArr, 0x99999999)).toEqual(-1);
-    expect(findCompleteBox(byteArr, 0x99999)).toEqual(-1);
-  });
-
-  it("should return its index if the box is found", () => {
-    const byteArr = new Uint8Array([
-      0,
-      0,
-      0,
-      9,
-      0x64,
-      0x67,
-      0x32,
-      0x55,
-      4,
-      0,
-      0,
-      0,
-      10,
-      0x88,
-      0x68,
-      0x47,
-      0x53,
-      12,
-      88,
-    ]);
-
-    expect(findCompleteBox(byteArr, 0x64673255)).toEqual(0);
-    expect(findCompleteBox(byteArr, 0x88684753)).toEqual(9);
-  });
-
-  it("should not return a box if it is incomplete", () => {
-    const byteArr = new Uint8Array([
-      0,
-      0,
-      0,
-      9,
-      0x64,
-      0x67,
-      0x32,
-      0x55,
-      4,
-      0,
-      0,
-      0,
-      10,
-      0x88,
-      0x68,
-      0x47,
-      0x53,
-      12,
-    ]);
-
-    expect(findCompleteBox(byteArr, 0x88684753)).toEqual(-1);
-  });
-
-  it("should return a box if a later one is incomplete", () => {
-    const byteArr = new Uint8Array([
-      0,
-      0,
-      0,
-      9,
-      0x64,
-      0x67,
-      0x32,
-      0x55,
-      4,
-      0,
-      0,
-      0,
-      12,
-      0x58,
-      0x58,
-      0x57,
-      0x53,
-      15,
-      99,
-      87,
-      77,
-      0,
-      0,
-      0,
-      10,
-      0x88,
-      0x68,
-      0x47,
-      0x53,
-      12,
-    ]);
-
-    expect(findCompleteBox(byteArr, 0x64673255)).toEqual(0);
-    expect(findCompleteBox(byteArr, 0x58585753)).toEqual(9);
-    expect(findCompleteBox(byteArr, 0x88684753)).toEqual(-1);
-  });
-});

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

@@ -1,227 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import type { Representation } from "../../../manifest";
-import inferSegmentContainer from "../infer_segment_container";
-
-describe("Transport utils - inferSegmentContainer", () => {
-  it("should return \"mp4\" for audio and video tracks with a specific mime-type", () => {
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/mp4" } as Representation))
-      .toEqual("mp4");
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/mp4" } as Representation))
-      .toEqual("mp4");
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/mp4" } as Representation))
-      .toEqual("mp4");
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/mp4" } as Representation))
-      .toEqual("mp4");
-  });
-
-  /* eslint-disable max-len */
-  it("should return undefined for non-audio nor video tracks with a mime-type indicating mp4 audio or video", () => {
-  /* eslint-enable max-len */
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/mp4" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/mp4" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("image",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/mp4" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("image",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/mp4" } as Representation))
-      .toEqual(undefined);
-  });
-
-  /* eslint-disable max-len */
-  it("should return \"webm\" for audio and video tracks with a specific mime-type", () => {
-  /* eslint-enable max-len */
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/webm" } as Representation))
-      .toEqual("webm");
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/webm" } as Representation))
-      .toEqual("webm");
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/webm" } as Representation))
-      .toEqual("webm");
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/webm" } as Representation))
-      .toEqual("webm");
-  });
-
-  /* eslint-disable max-len */
-  it("should return undefined for non-audio nor video tracks with a mime-type indicating webm audio or video", () => {
-  /* eslint-enable max-len */
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/webm" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/webm" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("image",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "video/webm" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("image",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "audio/webm" } as Representation))
-      .toEqual(undefined);
-  });
-
-  /* eslint-disable max-len */
-  it("should return undefined for audio and video tracks with any other mime-type", () => {
-  /* eslint-enable max-len */
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "application/mp4" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "application/mp4" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "foo" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "bar" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("audio",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {} } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("video",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {} } as Representation))
-      .toEqual(undefined);
-  });
-
-  it("should return \"mp4\" for a text track with a specific mime-type", () => {
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "application/mp4" } as Representation))
-      .toEqual("mp4");
-  });
-
-
-  it("should return undefined for text tracks with any other mime-type", () => {
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "text/mp4" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "text/plain" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {},
-                                   mimeType: "foo" } as Representation))
-      .toEqual(undefined);
-    expect(inferSegmentContainer("text",
-                                 { bitrate: 0,
-                                   id: "1",
-                                   index: {} } as Representation))
-      .toEqual(undefined);
-  });
-});

package/src/transports/utils/byte_range.ts

@@ -1,25 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Returns text-formatted byteRange (`bytes=$start-$end?)`
- * @param {Array.<string|Number>} arr
- * @returns {string}
- */
-export default function byteRange([start, end] : [number, number]) : string {
-  return end === Infinity ?  `bytes=${start}-` :
-                             `bytes=${start}-${end}`;
-}