rx-player 3.33.0 → 3.33.1

package/src/parsers/containers/matroska/utils.ts

@@ -1,313 +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 log from "../../../log";
-
-const SEGMENT_ID = 0x18538067;
-const INFO_ID = 0x1549A966;
-const TIMECODESCALE_ID = 0x2AD7B1;
-const DURATION_ID = 0x4489;
-const CUES_ID = 0x1C53BB6B;
-const CUE_POINT_ID = 0xBB;
-const CUE_TIME_ID = 0xB3;
-const CUE_TRACK_POSITIONS_ID = 0xB7;
-const CUE_CLUSTER_POSITIONS_ID = 0xF1;
-
-export interface ICuesSegment { time : number;
-                                duration : number;
-                                timescale : number;
-                                range : [number, number]; }
-
-/**
- * Find the offsets of the value linked to the given element ID.
- * @param {number} elementID - ID for the searched element.
- * @param {Array.<number>} parents - eventual IDs of the parent elements. From
- * top level to lower level (from the furthest to the closest).
- * @param {Uint8Array} buffer - buffer where the ID will be searched
- * @param {Array.<number>} range - start and end offsets in the buffer where the
- * ID will be searched.
- * @returns {Array.<number>|null}
- */
-function findNextElement(
-  elementID : number,
-  parents : number[],
-  buffer : Uint8Array,
-  [ initialOffset, maxOffset ] : [ number, number ]
-) : [number, number]|null {
-  let currentOffset = initialOffset;
-  while (currentOffset < maxOffset) {
-    const parsedID = getEBMLID(buffer, currentOffset);
-    if (parsedID == null) {
-      return null;
-    }
-
-    const { value: ebmlTagID, length: ebmlTagLength } = parsedID;
-    const sizeOffset = currentOffset + ebmlTagLength;
-    const parsedValue = getEBMLValue(buffer, sizeOffset);
-    if (parsedValue == null) {
-      return null;
-    }
-
-    const { length: valueLengthLength, value: valueLength } = parsedValue;
-    const valueOffset = sizeOffset + valueLengthLength;
-    const valueEndOffset = valueOffset + valueLength;
-    if (ebmlTagID === elementID) {
-      return [valueOffset, valueEndOffset];
-    } else if (parents.length > 0) {
-      for (let i = 0; i < parents.length; i++) {
-        if (ebmlTagID === parents[i]) {
-          const newParents = parents.slice(i + 1, parents.length);
-          return findNextElement(
-            elementID, newParents, buffer, [valueOffset, valueEndOffset]);
-        }
-      }
-    }
-    currentOffset = valueEndOffset;
-  }
-  return null;
-}
-
-/**
- * Return the timecode scale (basically timescale) of the whole file.
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {number|null}
- */
-export function getTimeCodeScale(
-  buffer : Uint8Array,
-  initialOffset : number
-) : number|null {
-  const timeCodeScaleOffsets = findNextElement(
-    TIMECODESCALE_ID, [SEGMENT_ID, INFO_ID], buffer, [initialOffset, buffer.length]);
-  if (timeCodeScaleOffsets == null) {
-    return null;
-  }
-  const length = timeCodeScaleOffsets[1] - timeCodeScaleOffsets[0];
-  return 1e9 / bytesToNumber(buffer, timeCodeScaleOffsets[0], length);
-}
-
-/**
- * Return the duration of the concerned media.
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {number|null}
- */
-function getDuration(
-  buffer : Uint8Array,
-  initialOffset : number
-) : number|null {
-  const timeCodeScaleOffsets = findNextElement(
-    DURATION_ID, [SEGMENT_ID, INFO_ID], buffer, [initialOffset, buffer.length]);
-  if (timeCodeScaleOffsets == null) {
-    return null;
-  }
-
-  const length = timeCodeScaleOffsets[1] - timeCodeScaleOffsets[0];
-  if (length === 4) {
-    return get_IEEE754_32Bits(buffer, timeCodeScaleOffsets[0]);
-  } else if (length === 8) {
-    return get_IEEE754_64Bits(buffer, timeCodeScaleOffsets[0]);
-  }
-  return null;
-}
-
-/**
- * @param {Uint8Array} buffer
- * @param {number} initialOffset
- * @returns {Array.<Object>|null}
- */
-export function getSegmentsFromCues(
-  buffer : Uint8Array,
-  initialOffset : number
-) : ICuesSegment[]|null {
-  const segmentRange = findNextElement(
-    SEGMENT_ID, [], buffer, [initialOffset, buffer.length]);
-  if (segmentRange == null) {
-    return null;
-  }
-
-  const [ segmentRangeStart, segmentRangeEnd ] = segmentRange;
-
-  const timescale = getTimeCodeScale(buffer, segmentRangeStart);
-  if (timescale == null) {
-    return null;
-  }
-
-  const duration = getDuration(buffer, segmentRangeStart);
-  if (duration == null) {
-    return null;
-  }
-
-  const cuesRange = findNextElement(
-    CUES_ID, [], buffer, [segmentRangeStart, segmentRangeEnd]);
-  if (cuesRange == null) {
-    return null;
-  }
-
-  const rawInfos : Array<{
-    time : number;
-    duration? : number;
-    rangeStart : number;
-  }> = [];
-
-  let currentOffset = cuesRange[0];
-  while (currentOffset < cuesRange[1]) {
-    const cuePointRange = findNextElement(
-      CUE_POINT_ID, [], buffer, [currentOffset, cuesRange[1]]);
-
-    if (cuePointRange == null) {
-      break;
-    }
-
-    const cueTimeRange = findNextElement(
-      CUE_TIME_ID, [], buffer, [cuePointRange[0], cuePointRange[1]]);
-    if (cueTimeRange == null) {
-      return null;
-    }
-    const time = bytesToNumber(
-      buffer, cueTimeRange[0], cueTimeRange[1] - cueTimeRange[0]);
-
-    const cueOffsetRange = findNextElement(
-      CUE_CLUSTER_POSITIONS_ID, [CUE_TRACK_POSITIONS_ID],
-      buffer, [cuePointRange[0], cuePointRange[1]]);
-    if (cueOffsetRange == null) {
-      return null;
-    }
-
-    const rangeStart = bytesToNumber(
-      buffer, cueOffsetRange[0], cueOffsetRange[1] - cueOffsetRange[0]) +
-      segmentRangeStart;
-    rawInfos.push({ time, rangeStart });
-
-    currentOffset = cuePointRange[1];
-  }
-
-  const segments : ICuesSegment[] = [];
-
-  for (let i = 0; i < rawInfos.length; i++) {
-    const currentSegment = rawInfos[i];
-    if (i === rawInfos.length - 1) {
-      segments.push({
-        time: currentSegment.time,
-        timescale,
-        duration: i === 0 ? duration :
-                            duration - currentSegment.time,
-        range: [currentSegment.rangeStart, Infinity],
-      });
-    } else {
-      segments.push({
-        time: currentSegment.time,
-        timescale,
-        duration: rawInfos[i + 1].time - currentSegment.time,
-        range: [currentSegment.rangeStart, rawInfos[i + 1].rangeStart - 1],
-      });
-    }
-  }
-
-  return segments;
-}
-
-function getLength(buffer : Uint8Array, offset : number) : number|undefined {
-  for (let length = 1; length <= 8; length++) {
-    if (buffer[offset] >= Math.pow(2, 8 - length)) {
-      return length;
-    }
-  }
-  return undefined;
-}
-
-function getEBMLID(
-  buffer : Uint8Array,
-  offset : number
-) : { length : number; value : number }|null {
-  const length = getLength(buffer, offset);
-  if (length == null) {
-    log.warn("webm: unrepresentable length");
-    return null;
-  }
-  if (offset + length > buffer.length) {
-    log.warn("webm: impossible length");
-    return null;
-  }
-
-  let value = 0;
-  for (let i = 0; i < length; i++) {
-    value = buffer[offset + i] * Math.pow(2, (length - i - 1) * 8) + value;
-  }
-  return { length, value };
-}
-
-function getEBMLValue(
-  buffer : Uint8Array,
-  offset : number
-) : { length : number; value : number }|null {
-  const length = getLength(buffer, offset);
-  if (length == null) {
-    log.warn("webm: unrepresentable length");
-    return null;
-  }
-  if (offset + length > buffer.length) {
-    log.warn("webm: impossible length");
-    return null;
-  }
-
-  let value = (buffer[offset] & (1 << (8 - length)) - 1) *
-    Math.pow(2, (length - 1) * 8);
-  for (let i = 1; i < length; i++) {
-    value = buffer[offset + i] * Math.pow(2, (length - i - 1) * 8) + value;
-  }
-  return { length, value };
-}
-
-/**
- * Convert a IEEE754 32 bits floating number as an Uint8Array into its
- * corresponding Number.
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @returns {number}
- */
-function get_IEEE754_32Bits(
-  buffer : Uint8Array,
-  offset : number
-) : number {
-  return new DataView(buffer.buffer).getFloat32(offset);
-}
-
-/**
- * Convert a IEEE754 64 bits floating number as an Uint8Array into its
- * corresponding Number.
- * @param {Uint8Array} buffer
- * @param {number} offset
- * @returns {number}
- */
-function get_IEEE754_64Bits(
-  buffer : Uint8Array,
-  offset : number
-) : number {
-  return new DataView(buffer.buffer).getFloat64(offset);
-}
-
-function bytesToNumber(
-  buffer : Uint8Array,
-  offset : number,
-  length : number
-) : number {
-  let value = 0;
-  for (let i = 0; i < length; i++) {
-    value = buffer[offset + i] * Math.pow(2, (length - i - 1) * 8) + value;
-  }
-  return value;
-}

package/src/parsers/images/bif.ts

@@ -1,128 +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.
- */
-
-/**
- * /!\ This file is feature-switchable.
- * It always should be imported through the `features` object.
- */
-
-import {
-  le2toi,
-  le4toi,
-} from "../../utils/byte_parsing";
-import { utf8ToStr } from "../../utils/string_parsing";
-
-export interface IBifThumbnail { index : number;
-                                 duration : number;
-                                 ts : number;
-                                 data : Uint8Array; }
-
-export interface IBifObject { fileFormat : string;
-                              version : string;
-                              imageCount : number;
-                              timescale : number;
-                              format : string;
-                              width : number;
-                              height : number;
-                              aspectRatio : string;
-                              isVod : boolean;
-                              thumbs : IBifThumbnail[];
-}
-
-/**
- * @param {UInt8Array} buf
- * @returns {Object}
- */
-function parseBif(buf : Uint8Array) : IBifObject {
-  let pos = 0;
-
-  const length = buf.length;
-
-  const fileFormat = utf8ToStr(buf.subarray(pos + 1, pos + 8)); pos += 8;
-  if (buf[0] !== 0x89 || fileFormat !== "BIF\r\n\u001a\n") {
-    throw new Error("Invalid BIF file");
-  }
-
-  const minorVersion = buf[pos]; pos += 1;
-  const majorVersion = buf[pos]; pos += 1;
-  const patchVersion = buf[pos]; pos += 1;
-  const increVersion = buf[pos]; pos += 1;
-
-  const version = [minorVersion, majorVersion, patchVersion, increVersion].join(".");
-
-  if (majorVersion > 0) {
-    throw new Error(`Unhandled version: ${majorVersion}`);
-  }
-
-  const imageCount = le4toi(buf, pos); pos += 4;
-  const framewiseSeparation = le4toi(buf, pos); pos += 4;
-
-  const format = utf8ToStr(buf.subarray(pos, pos + 4)); pos += 4;
-
-  const width = le2toi(buf, pos); pos += 2;
-  const height = le2toi(buf, pos); pos += 2;
-
-  const aspectRatio = [buf[pos], buf[pos + 1]].join(":"); pos += 2;
-
-  const isVod = buf[pos] === 1;
-
-  // bytes 0x1F to 0x40 is unused data for now
-  pos = 0x40;
-
-  const thumbs : IBifThumbnail[] = [];
-
-  if (imageCount === 0) {
-    throw new Error("bif: no images to parse");
-  }
-
-  let index = 0;
-  let previousImageInfo = null;
-  while (pos < length) {
-    const currentImageTimestamp = le4toi(buf, pos); pos += 4;
-    const currentImageOffset = le4toi(buf, pos); pos += 4;
-
-    if (previousImageInfo !== null) {
-      // calculate for index-1
-      const ts = previousImageInfo.timestamp * framewiseSeparation;
-      const duration = framewiseSeparation;
-      const data = buf.slice(previousImageInfo.offset, currentImageOffset);
-
-      thumbs.push({ index, duration, ts, data });
-
-      index++;
-    }
-
-    if (currentImageTimestamp === 0xFFFFFFFF) {
-      break;
-    }
-
-    previousImageInfo = { timestamp: currentImageTimestamp,
-                          offset: currentImageOffset };
-  }
-
-  return { fileFormat: "BIF",
-           version,
-           imageCount,
-           timescale: 1000,
-           format,
-           width,
-           height,
-           aspectRatio,
-           isVod,
-           thumbs };
-}
-
-export default parseBif;

package/src/parsers/manifest/dash/common/__tests__/attach_trickmode_track.test.ts

@@ -1,65 +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 {
-  IParsedAdaptations,
-  IParsedAdaptation,
-} from "../../../types";
-import attachTrickModeTrack from "../attach_trickmode_track";
-
-describe("attachTrickModeTrack", () => {
-  it("should correclty attach trickmode tracks", () => {
-    const trickModeTracks = [
-      { adaptation: { type: "video" }, trickModeAttachedAdaptationIds: ["1", "3"] },
-      { adaptation: { type: "audio" }, trickModeAttachedAdaptationIds: ["1"] },
-    ] as Array<{ adaptation : IParsedAdaptation;
-                 trickModeAttachedAdaptationIds : string[]; }>;
-
-    const adaptations = {
-      video: [
-        { id: "1", trickModeTracks: undefined },
-        { id: "2", trickModeTracks: undefined },
-        { id: "3", trickModeTracks: undefined },
-        { id: "4", trickModeTracks: undefined },
-      ],
-      audio: [
-        { id: "1", trickModeTracks: undefined },
-        { id: "2", trickModeTracks: undefined },
-        { id: "3", trickModeTracks: undefined },
-      ],
-    } as unknown as IParsedAdaptations;
-
-    attachTrickModeTrack(adaptations, trickModeTracks);
-
-    expect(adaptations).toEqual({
-      video: [
-        { id: "1",
-          trickModeTracks: [{ type: "video" },
-                            { type: "audio" }] },
-        { id: "2", trickModeTracks: undefined },
-        { id: "3", trickModeTracks: [{ type: "video" }] },
-        { id: "4", trickModeTracks: undefined },
-      ],
-      audio: [
-        { id: "1",
-          trickModeTracks: [{ type: "video" },
-                            { type: "audio" }] },
-        { id: "2", trickModeTracks: undefined },
-        { id: "3", trickModeTracks: [{ type: "video" }] },
-      ],
-    });
-  });
-});

package/src/parsers/manifest/dash/common/__tests__/convert_supplemental_codecs.test.ts

@@ -1,37 +0,0 @@
-import { convertSupplementalCodecsToRFC6381 } from "../convert_supplemental_codecs";
-
-describe("parseSupplementalCodec", () => {
-  it("should return the codec unchanged if there is only one codec", () => {
-    expect(convertSupplementalCodecsToRFC6381("avc1.4d400d"))
-      .toEqual("avc1.4d400d");
-  });
-  it("should trim starting and ending whitespace", () => {
-    expect(
-      convertSupplementalCodecsToRFC6381("  avc1.4d400d  "))
-      .toEqual("avc1.4d400d");
-  });
-  it("should return comma-separated list if input is whitespace-separated", () => {
-    expect(
-      convertSupplementalCodecsToRFC6381("avc1.4d400d avc1.4d4015"))
-      .toEqual("avc1.4d400d, avc1.4d4015");
-  });
-  it("should return comma-separated value if input is already comma-separated", () => {
-    expect(
-      convertSupplementalCodecsToRFC6381("avc1.4d400d, avc1.4d4015"))
-      .toEqual("avc1.4d400d, avc1.4d4015");
-  });
-
-  it("should return comma-separated value if input as missplaced whitespace", () => {
-    expect(
-      convertSupplementalCodecsToRFC6381("avc1.4d400d  ,  avc1.4d4015 "))
-      .toEqual("avc1.4d400d, avc1.4d4015");
-  });
-
-  it(`should return comma-separated value if input is mix of comma and 
-    whitespace separated list`
-  , () => {
-    expect(
-      convertSupplementalCodecsToRFC6381("avc1.4d400d avc1.4d4015, avc1.4d401f"))
-      .toEqual("avc1.4d400d, avc1.4d4015, avc1.4d401f");
-  });
-});

package/src/parsers/manifest/dash/common/__tests__/flatten_overlapping_period.test.ts

@@ -1,162 +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 log from "../../../../../log";
-import flattenOverlappingPeriods from "../flatten_overlapping_periods";
-
-describe("flattenOverlappingPeriods", function() {
-
-  it("should do nothing when no period is given", () => {
-    const mockLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-
-    expect(flattenOverlappingPeriods([])).toEqual([]);
-    expect(mockLog).not.toHaveBeenCalled();
-    mockLog.mockRestore();
-  });
-
-  // [ Period 1 ][ Period 2 ]       ------>  [ Period 1 ][ Period 3 ]
-  //             [ Period 3 ]
-  it("should replace a period with an other if same start and duration", function() {
-    const mockLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-
-    const periods = [
-      { id: "1", start: 0, duration: 60, adaptations: {} },
-      { id: "2", start: 60, duration: 60, adaptations: {} },
-      { id: "3", start: 60, duration: 60, adaptations: {} },
-    ];
-
-    const flattenPeriods = flattenOverlappingPeriods(periods);
-    expect(flattenPeriods.length).toBe(2);
-    expect(flattenPeriods[0].start).toBe(0);
-    expect(flattenPeriods[0].duration).toBe(60);
-    expect(flattenPeriods[0].id).toBe("1");
-    expect(flattenPeriods[1].start).toBe(60);
-    expect(flattenPeriods[1].duration).toBe(60);
-    expect(flattenPeriods[1].id).toBe("3");
-
-    expect(mockLog).toHaveBeenCalledTimes(1);
-    expect(mockLog).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", 60, 60);
-    mockLog.mockRestore();
-  });
-
-  // [ Period 1 ][ Period 2 ]       ------>  [ Period 1 ][  2  ][ Period 3 ]
-  //                  [ Period 3 ]
-  it("should replace part of period if part of next one is overlapping it", function() {
-    const mockLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-
-    const periods = [
-      { id: "1", start: 0, duration: 60, adaptations: {} },
-      { id: "2", start: 60, duration: 60, adaptations: {} },
-      { id: "3", start: 90, duration: 60, adaptations: {} },
-    ];
-
-    const flattenPeriods = flattenOverlappingPeriods(periods);
-    expect(flattenPeriods.length).toBe(3);
-    expect(flattenPeriods[0].start).toBe(0);
-    expect(flattenPeriods[0].duration).toBe(60);
-    expect(flattenPeriods[0].id).toBe("1");
-    expect(flattenPeriods[1].start).toBe(60);
-    expect(flattenPeriods[1].duration).toBe(30);
-    expect(flattenPeriods[1].id).toBe("2");
-    expect(flattenPeriods[2].start).toBe(90);
-    expect(flattenPeriods[2].duration).toBe(60);
-    expect(flattenPeriods[2].id).toBe("3");
-
-    expect(mockLog).toHaveBeenCalledTimes(1);
-    expect(mockLog).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", 60, 90);
-    mockLog.mockRestore();
-  });
-
-  // [ Period 1 ][ Period 2 ]       ------>  [  1  ][      Period 3     ]
-  //        [      Period 3     ]
-  it("should erase period if a next period starts before and ends after it", function() {
-    const mockLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-
-    const periods = [
-      { id: "1", start: 0, duration: 60, adaptations: {} },
-      { id: "2", start: 60, duration: 60, adaptations: {} },
-      { id: "3", start: 50, duration: 120, adaptations: {} },
-    ];
-
-    const flattenPeriods = flattenOverlappingPeriods(periods);
-    expect(flattenPeriods.length).toBe(2);
-    expect(flattenPeriods[0].start).toBe(0);
-    expect(flattenPeriods[0].duration).toBe(50);
-    expect(flattenPeriods[0].id).toBe("1");
-    expect(flattenPeriods[1].start).toBe(50);
-    expect(flattenPeriods[1].duration).toBe(120);
-    expect(flattenPeriods[1].id).toBe("3");
-
-    expect(mockLog).toHaveBeenCalledTimes(2);
-    expect(mockLog).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", 60, 50);
-    expect(mockLog).toHaveBeenCalledWith(
-      "DASH: Updating overlapping Periods.", 0, 50);
-    mockLog.mockRestore();
-  });
-
-  // [ Period 1 ][ Period 2 ]       ------>  [  1  ][  100   ]
-  //             [ Period 3 ]
-  //                  ...
-  //             [   100    ]
-  /* eslint-disable max-len */
-  it("should keep last announced period from multiple periods with same start and end", function() {
-  /* eslint-enable max-len */
-    const mockLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-
-    const periods = [
-      { id: "1", start: 0, duration: 60, adaptations: {} },
-    ];
-
-    for (let i = 1; i <= 100; i++) {
-      periods.push({ id: i.toString(), start: 60, duration: 60, adaptations: {} });
-    }
-
-    const flattenPeriods = flattenOverlappingPeriods(periods);
-    expect(flattenPeriods.length).toBe(2);
-    expect(flattenPeriods[0].start).toBe(0);
-    expect(flattenPeriods[0].duration).toBe(60);
-    expect(flattenPeriods[0].id).toBe("1");
-    expect(flattenPeriods[1].start).toBe(60);
-    expect(flattenPeriods[1].duration).toBe(60);
-    expect(flattenPeriods[1].id).toBe("100");
-
-    expect(mockLog).toHaveBeenCalledTimes(99);
-    mockLog.mockRestore();
-  });
-
-  //      [ Period 1 ][ Period 2 ]       ------>  [  Period 3  ]
-  //  [            Period 3           ]
-  it("should handle when a Period overlaps all previous periods", () => {
-    const mockLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-
-    const periods = [
-      { id: "1", start: 40, duration: 20, adaptations: {} },
-      { id: "2", start: 60, duration: 20, adaptations: {} },
-      { id: "3", start: 20, duration: 100, adaptations: {} },
-    ];
-
-    const flattenPeriods = flattenOverlappingPeriods(periods);
-    expect(flattenPeriods.length).toBe(1);
-    expect(flattenPeriods[0].start).toBe(20);
-    expect(flattenPeriods[0].duration).toBe(100);
-    expect(flattenPeriods[0].id).toBe("3");
-    expect(mockLog).toHaveBeenCalledTimes(2);
-    mockLog.mockRestore();
-  });
-});