rx-player 3.33.0 → 3.33.1

package/src/parsers/manifest/dash/common/indexes/timeline/__tests__/parse_s_element.test.ts

@@ -1,115 +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 parseS from "../parse_s_element";
-
-function testNumberAttribute(attributeName : string, variableName? : string) : void {
-  const _variableName = variableName == null ? attributeName : variableName;
-
-  /* eslint-disable max-len */
-  it(`should correctly parse an S element with a correct ${attributeName} attribute`, () => {
-  /* eslint-enable max-len */
-    const spyLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-    const element1 = new DOMParser()
-      .parseFromString(`<S ${attributeName}="012" />`, "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element1))
-      .toEqual({ [_variableName]: 12 });
-
-    const element2 = new DOMParser()
-      .parseFromString(`<S ${attributeName}="0" />`, "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element2))
-      .toEqual({ [_variableName]: 0 });
-
-    const element3 = new DOMParser()
-      .parseFromString(`<S ${attributeName}="-50" />`, "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element3))
-      .toEqual({ [_variableName]: -50 });
-
-    expect(spyLog).not.toHaveBeenCalled();
-    spyLog.mockRestore();
-  });
-
-  /* eslint-disable max-len */
-  it(`should correctly parse an S element with an incorrect ${attributeName} attribute`, () => {
-  /* eslint-enable max-len */
-    const spyLog = jest.spyOn(log, "warn").mockImplementation(jest.fn());
-    const element1 = new DOMParser()
-      .parseFromString(`<S ${attributeName}="toto" />`, "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element1))
-      .toEqual({});
-    expect(spyLog).toHaveBeenCalledTimes(1);
-    expect(spyLog).toHaveBeenCalledWith(`DASH: invalid ${attributeName} ("toto")`);
-
-    const element2 = new DOMParser()
-      .parseFromString(`<S ${attributeName}="PT5M" />`, "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element2))
-      .toEqual({});
-    expect(spyLog).toHaveBeenCalledTimes(2);
-    expect(spyLog).toHaveBeenCalledWith(`DASH: invalid ${attributeName} ("PT5M")`);
-
-    const element3 = new DOMParser()
-      .parseFromString(`<S ${attributeName}="" />`, "text/xml")
-      .childNodes[0] as Element;
-
-    expect(parseS(element3))
-      .toEqual({});
-    expect(spyLog).toHaveBeenCalledTimes(3);
-    expect(spyLog).toHaveBeenCalledWith(`DASH: invalid ${attributeName} ("")`);
-    spyLog.mockRestore();
-  });
-}
-
-describe("DASH Node Parsers - S", () => {
-  it("should correctly parse an S element without attributes", () => {
-    const element = new DOMParser().parseFromString("<S />", "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element)).toEqual({});
-  });
-
-  testNumberAttribute("t", "start");
-  testNumberAttribute("r", "repeatCount");
-  testNumberAttribute("d", "duration");
-
-  it("should correctly parse an S element with every attributes", () => {
-    const element1 = new DOMParser()
-      .parseFromString("<S t=\"0\" d=\"4\" r=\"12\" />", "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element1)).toEqual({ start: 0, repeatCount: 12, duration: 4 });
-
-    const element2 = new DOMParser()
-      .parseFromString("<S t=\"99\" d=\"4\" r=\"0\" />", "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element2)).toEqual({ start: 99, repeatCount: 0, duration: 4 });
-  });
-
-  it("should correctly parse an S element with unknown attributes", () => {
-    const element1 = new DOMParser()
-      .parseFromString("<S t=\"0\" d=\"4\" r=\"12\" f=\"9\" />", "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element1)).toEqual({ start: 0, repeatCount: 12, duration: 4 });
-
-    const element2 = new DOMParser()
-      .parseFromString("<S b=\"7000\" />", "text/xml")
-      .childNodes[0] as Element;
-    expect(parseS(element2)).toEqual({});
-  });
-});

package/src/parsers/manifest/dash/common/indexes/timeline/construct_timeline_from_elements.ts

@@ -1,54 +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 { IIndexSegment } from "../../../../utils/index_helpers";
-import convertElementsToIndexSegment from "./convert_element_to_index_segment";
-import parseSElement, {
-  IParsedS,
-} from "./parse_s_element";
-
-/**
- * Allows to generate the "timeline" for the "Timeline" RepresentationIndex.
- * Call this function when the timeline is unknown.
- * This function was added to only perform that task lazily, i.e. only when
- * first needed.
- * @param {HTMLCollection} elements - All S nodes constituting the corresponding
- * SegmentTimeline node.
- * @returns {Array.<Object>}
- */
-export default function constructTimelineFromElements(
-  elements : HTMLCollection
-) : IIndexSegment[] {
-  const initialTimeline : IParsedS[] = [];
-  for (let i = 0; i < elements.length; i++) {
-    initialTimeline.push(parseSElement(elements[i]));
-  }
-  const timeline : IIndexSegment[] = [];
-  for (let i = 0; i < initialTimeline.length; i++) {
-    const item = initialTimeline[i];
-    const previousItem = timeline[timeline.length - 1] === undefined ?
-      null :
-      timeline[timeline.length - 1];
-    const nextItem = initialTimeline[i + 1] === undefined ?
-      null :
-      initialTimeline[i + 1];
-    const timelineElement = convertElementsToIndexSegment(item, previousItem, nextItem);
-    if (timelineElement !== null) {
-      timeline.push(timelineElement);
-    }
-  }
-  return timeline;
-}

package/src/parsers/manifest/dash/common/indexes/timeline/construct_timeline_from_previous_timeline.ts

@@ -1,102 +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 { IIndexSegment } from "../../../../utils/index_helpers";
-import constructTimelineFromElements from "./construct_timeline_from_elements";
-import convertElementToIndexSegment from "./convert_element_to_index_segment";
-import findFirstCommonStartTime from "./find_first_common_start_time";
-import parseSElement, {
-  IParsedS,
-} from "./parse_s_element";
-
-export default function constructTimelineFromPreviousTimeline(
-  newElements : HTMLCollection,
-  prevTimeline : IIndexSegment[]
-) : IIndexSegment[] {
-
-  // Find first index in both timeline where a common segment is found.
-  const commonStartInfo = findFirstCommonStartTime(prevTimeline, newElements);
-  if (commonStartInfo === null) {
-    log.warn("DASH: Cannot perform \"based\" update. Common segment not found.");
-    return constructTimelineFromElements(newElements);
-  }
-  const { prevSegmentsIdx,
-          newElementsIdx,
-          repeatNumberInPrevSegments,
-          repeatNumberInNewElements } = commonStartInfo;
-
-  /** Guess of the number of elements in common. */
-  const numberCommonEltGuess = prevTimeline.length - prevSegmentsIdx;
-  const lastCommonEltNewEltsIdx = numberCommonEltGuess + newElementsIdx - 1;
-  if (lastCommonEltNewEltsIdx >= newElements.length) {
-    log.info("DASH: Cannot perform \"based\" update. New timeline too short");
-    return constructTimelineFromElements(newElements);
-  }
-
-  // Remove elements which are not available anymore
-  const newTimeline = prevTimeline.slice(prevSegmentsIdx);
-  if (repeatNumberInPrevSegments > 0) {
-    const commonEltInOldTimeline = newTimeline[0];
-    commonEltInOldTimeline.start += commonEltInOldTimeline.duration *
-                                    repeatNumberInPrevSegments;
-    newTimeline[0].repeatCount -= repeatNumberInPrevSegments;
-  }
-
-  if (repeatNumberInNewElements > 0 && newElementsIdx !== 0) {
-    log.info("DASH: Cannot perform \"based\" update. " +
-             "The new timeline has a different form.");
-    return constructTimelineFromElements(newElements);
-  }
-
-  const prevLastElement = newTimeline[newTimeline.length - 1];
-  const newCommonElt = parseSElement(newElements[lastCommonEltNewEltsIdx]);
-  const newRepeatCountOffseted = (newCommonElt.repeatCount ?? 0) -
-    repeatNumberInNewElements;
-  if (newCommonElt.duration !== prevLastElement.duration ||
-      prevLastElement.repeatCount > newRepeatCountOffseted)
-  {
-    log.info("DASH: Cannot perform \"based\" update. " +
-             "The new timeline has a different form at the beginning.");
-    return constructTimelineFromElements(newElements);
-  }
-
-  if (newCommonElt.repeatCount !== undefined &&
-      newCommonElt.repeatCount > prevLastElement.repeatCount)
-  {
-    prevLastElement.repeatCount = newCommonElt.repeatCount;
-  }
-
-  const newEltsToPush : IIndexSegment[] = [];
-  const items : IParsedS[] = [];
-  for (let i = lastCommonEltNewEltsIdx + 1; i < newElements.length; i++) {
-    items.push(parseSElement(newElements[i]));
-  }
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i];
-    const previousItem = newEltsToPush[newEltsToPush.length - 1] === undefined ?
-      prevLastElement :
-      newEltsToPush[newEltsToPush.length - 1];
-    const nextItem = items[i + 1] === undefined ?
-      null :
-      items[i + 1];
-    const timelineElement = convertElementToIndexSegment(item, previousItem, nextItem);
-    if (timelineElement !== null) {
-      newEltsToPush.push(timelineElement);
-    }
-  }
-  return newTimeline.concat(newEltsToPush);
-}

package/src/parsers/manifest/dash/common/indexes/timeline/convert_element_to_index_segment.ts

@@ -1,66 +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 isNullOrUndefined from "../../../../../../utils/is_null_or_undefined";
-import { IIndexSegment } from "../../../../utils/index_helpers";
-
-/**
- * Translate parsed `S` node into Segment compatible with this index:
- * Find out the start, repeatCount and duration of each of these.
- *
- * @param {Object} item - parsed `S` node
- * @param {Object|null} previousItem - the previously parsed Segment (related
- * to the `S` node coming just before). If `null`, we're talking about the first
- * segment.
- * @param {Object|null} nextItem - the `S` node coming next. If `null`, we're
- * talking about the last segment.
- * @returns {Object|null}
- */
-export default function convertElementsToIndexSegment(
-  item : { start? : number; repeatCount? : number; duration? : number },
-  previousItem : IIndexSegment|null,
-  nextItem : { start? : number; repeatCount? : number; duration? : number }|null
-) : IIndexSegment|null {
-  let start = item.start;
-  let duration = item.duration;
-  const repeatCount = item.repeatCount;
-  if (start === undefined) {
-    if (previousItem === null) {
-      start = 0;
-    } else if (!isNullOrUndefined(previousItem.duration)) {
-      start = previousItem.start +
-              (previousItem.duration * (previousItem.repeatCount + 1));
-    }
-  }
-  if ((duration === undefined || isNaN(duration)) &&
-      nextItem !== null && nextItem.start !== undefined && !isNaN(nextItem.start) &&
-      start !== undefined && !isNaN(start)
-  ) {
-    duration = nextItem.start - start;
-  }
-  if ((start !== undefined && !isNaN(start)) &&
-      (duration !== undefined && !isNaN(duration)) &&
-      (repeatCount === undefined || !isNaN(repeatCount))
-  ) {
-    return { start,
-             duration,
-             repeatCount: repeatCount === undefined ? 0 :
-                                                      repeatCount };
-  }
-  log.warn("DASH: A \"S\" Element could not have been parsed.");
-  return null;
-}

package/src/parsers/manifest/dash/common/indexes/timeline/find_first_common_start_time.ts

@@ -1,153 +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 { IIndexSegment } from "../../../../utils/index_helpers";
-
-/**
- * By comparing two timelines for the same content at different points in time,
- * retrieve the index in both timelines of the first segment having the same
- * starting time.
- * Returns `null` if not found.
- * @param {Array.<Object>} prevTimeline
- * @param {HTMLCollection} newElements
- * @returns {Object|null}
- */
-export default function findFirstCommonStartTime(
-  prevTimeline : IIndexSegment[],
-  newElements : HTMLCollection
-) : {
-  /** Index in `prevSegments` where the first common segment start is found. */
-  prevSegmentsIdx : number;
-  /** Index in `newElements` where the first common segment start is found. */
-  newElementsIdx : number;
-  /**
-   * Value to set `repeatCount` to at `prevSegments[prevSegmentsIdx]` to
-   * retrieve the segment with the first common start time
-   */
-  repeatNumberInPrevSegments : number;
-  /**
-   * Value to set `repeatCount` to at `newElements[newElementsIdx]` to
-   * retrieve the segment with the first common start time
-   */
-  repeatNumberInNewElements : number;
-} | null {
-  if (prevTimeline.length === 0 || newElements.length === 0) {
-    return null;
-  }
-  const prevInitialStart = prevTimeline[0].start;
-  const newFirstTAttr = newElements[0].getAttribute("t");
-  const newInitialStart = newFirstTAttr === null ? null :
-                                                   parseInt(newFirstTAttr, 10);
-  if (newInitialStart === null || Number.isNaN(newInitialStart)) {
-    return null;
-  }
-
-  if (prevInitialStart === newInitialStart) {
-    return { prevSegmentsIdx: 0,
-             newElementsIdx: 0,
-             repeatNumberInPrevSegments: 0,
-             repeatNumberInNewElements: 0 };
-
-  } else if (prevInitialStart < newInitialStart) {
-    let prevElt = prevTimeline[0];
-    let prevElementIndex = 0;
-    while (true) {
-      if (prevElt.repeatCount > 0) {
-        const diff = newInitialStart - prevElt.start;
-        if (diff % prevElt.duration === 0 &&
-            diff / prevElt.duration <= prevElt.repeatCount)
-        {
-          const repeatNumberInPrevSegments = diff / prevElt.duration;
-          return { repeatNumberInPrevSegments,
-                   prevSegmentsIdx: prevElementIndex,
-                   newElementsIdx: 0,
-                   repeatNumberInNewElements: 0 };
-        }
-      }
-      prevElementIndex++;
-      if (prevElementIndex >= prevTimeline.length) {
-        return null;
-      }
-      prevElt = prevTimeline[prevElementIndex];
-      if (prevElt.start === newInitialStart) {
-        return { prevSegmentsIdx: prevElementIndex,
-                 newElementsIdx: 0,
-                 repeatNumberInPrevSegments: 0,
-                 repeatNumberInNewElements: 0 };
-      } else if (prevElt.start > newInitialStart) {
-        return null;
-      }
-    }
-  } else {
-    let newElementsIdx = 0;
-    let newElt = newElements[0];
-    let currentTimeOffset = newInitialStart;
-    while (true) {
-      const dAttr = newElt.getAttribute("d");
-      const duration = dAttr === null ? null :
-                                        parseInt(dAttr, 10);
-      if (duration === null || Number.isNaN(duration)) {
-        return null;
-      }
-      const rAttr = newElt.getAttribute("r");
-      const repeatCount = rAttr === null ? null :
-                                           parseInt(rAttr, 10);
-
-      if (repeatCount !== null) {
-        if (Number.isNaN(repeatCount) || repeatCount < 0) {
-          return null;
-        }
-        if (repeatCount > 0) {
-          const diff = prevInitialStart - currentTimeOffset;
-          if (diff % duration === 0 &&
-              diff / duration <= repeatCount)
-          {
-            const repeatNumberInNewElements = diff / duration;
-            return { repeatNumberInPrevSegments: 0,
-                     repeatNumberInNewElements,
-                     prevSegmentsIdx: 0,
-                     newElementsIdx };
-          }
-        }
-        currentTimeOffset += duration * (repeatCount + 1);
-      } else {
-        currentTimeOffset += duration;
-      }
-      newElementsIdx++;
-      if (newElementsIdx >= newElements.length) {
-        return null;
-      }
-      newElt = newElements[newElementsIdx];
-      const tAttr = newElt.getAttribute("t");
-      const time = tAttr === null ? null :
-                                    parseInt(tAttr, 10);
-      if (time !== null) {
-        if (Number.isNaN(time)) {
-          return null;
-        }
-        currentTimeOffset = time;
-      }
-      if (currentTimeOffset === prevInitialStart) {
-        return { newElementsIdx,
-                 prevSegmentsIdx: 0,
-                 repeatNumberInPrevSegments: 0,
-                 repeatNumberInNewElements: 0 };
-      } else if (currentTimeOffset > newInitialStart) {
-        return null;
-      }
-    }
-  }
-}

package/src/parsers/manifest/dash/common/indexes/timeline/index.ts

@@ -1,21 +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 TimelineRepresentationIndex, {
-  ITimelineIndexContextArgument,
-} from "./timeline_representation_index";
-export default TimelineRepresentationIndex;
-export { ITimelineIndexContextArgument };

package/src/parsers/manifest/dash/common/indexes/timeline/parse_s_element.ts

@@ -1,72 +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";
-
-/** SegmentTimeline `S` element once parsed. */
-export interface IParsedS {
-  /** Start time in a previously-given timescaled unit. */
-  start? : number;
-  /**
-   * Amount of repetition(s).
-   * 0 = no repeat.
-   * negative number = max possible repeat.
-   */
-  repeatCount? : number;
-  /** Duration of the content in a previously-given timescaled unit. */
-  duration? : number;
-}
-
-/**
- * Parse a given <S> element in the MPD into a JS Object.
- * @param {Element} root
- * @returns {Object}
- */
-export default function parseSElement(root : Element) : IParsedS {
-  const parsedS : IParsedS = {};
-
-  for (let j = 0; j < root.attributes.length; j++) {
-    const attribute = root.attributes[j];
-
-    switch (attribute.name) {
-      case "t":
-        const start = parseInt(attribute.value, 10);
-        if (isNaN(start)) {
-          log.warn(`DASH: invalid t ("${attribute.value}")`);
-        } else {
-          parsedS.start = start;
-        }
-        break;
-      case "d":
-        const duration = parseInt(attribute.value, 10);
-        if (isNaN(duration)) {
-          log.warn(`DASH: invalid d ("${attribute.value}")`);
-        } else {
-          parsedS.duration = duration;
-        }
-        break;
-      case "r":
-        const repeatCount = parseInt(attribute.value, 10);
-        if (isNaN(repeatCount)) {
-          log.warn(`DASH: invalid r ("${attribute.value}")`);
-        } else {
-          parsedS.repeatCount = repeatCount;
-        }
-        break;
-    }
-  }
-  return parsedS;
-}