rx-player 3.33.0 → 3.33.2

package/src/parsers/manifest/utils/clear_timeline_from_position.ts

@@ -1,74 +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 "./index_helpers";
-
-/**
- * Remove segments which starts before the given `firstAvailablePosition` from
- * the timeline. `firstAvailablePosition` has to be time scaled.
- * @param {Array.<Object>}
- * @returns {number} - Returns the number of removed segments. This includes
- * potential implicit segment from decremented `repeatCount` attributes.
- */
-export default function clearTimelineFromPosition(
-  timeline : IIndexSegment[],
-  firstAvailablePosition : number
-) : number {
-  let nbEltsRemoved = 0;
-  while (timeline.length > 0) {
-    const firstElt = timeline[0];
-    if (firstElt.start >= firstAvailablePosition) {
-      return nbEltsRemoved; // all clear
-    }
-
-    if (firstElt.repeatCount === -1) {
-      return nbEltsRemoved;
-    } else if (firstElt.repeatCount === 0) {
-      timeline.shift();
-      nbEltsRemoved += 1;
-    } else { // we have a segment repetition
-      const nextElt = timeline[1];
-      if (nextElt !== undefined && nextElt.start <= firstAvailablePosition) {
-        timeline.shift();
-        nbEltsRemoved += 1;
-      } else { // no next segment or next segment is available
-        if (firstElt.duration <= 0) {
-          return nbEltsRemoved;
-        }
-
-        let nextStart = firstElt.start + firstElt.duration;
-        let nextRepeat = 1;
-        while (nextStart < firstAvailablePosition &&
-               nextRepeat <= firstElt.repeatCount)
-        {
-          nextStart += firstElt.duration;
-          nextRepeat++;
-        }
-        if (nextRepeat > firstElt.repeatCount) { // every start is before
-          timeline.shift();
-          nbEltsRemoved = firstElt.repeatCount + 1;
-        } else { // some repetitions start after and some before
-          const newRepeat = firstElt.repeatCount - nextRepeat;
-          firstElt.start = nextStart;
-          firstElt.repeatCount = newRepeat;
-          nbEltsRemoved += nextRepeat;
-          return nbEltsRemoved;
-        }
-      }
-    }
-  }
-  return nbEltsRemoved;
-}

package/src/parsers/manifest/utils/get_first_time_from_adaptation.ts

@@ -1,48 +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 { IParsedAdaptation } from "../types";
-
-/**
- * Returns "first time of reference" from the adaptation given, considering a
- * dynamic content.
- * Undefined if a time could not be found.
- *
- * We consider the latest first time from every representations in the given
- * adaptation.
- * @param {Object} adaptation
- * @returns {Number|undefined}
- */
-export default function getFirstPositionFromAdaptation(
-  adaptation: IParsedAdaptation
-) : number | undefined | null {
-  const { representations } = adaptation;
-  let max : null | number = null;
-  for (let i = 0; i < representations.length; i++) {
-    const firstPosition = representations[i].index.getFirstAvailablePosition();
-    if (firstPosition === undefined) { // we cannot tell
-      return undefined;
-    }
-    if (firstPosition !== null) {
-      max = max == null ? firstPosition :
-                          Math.max(max, firstPosition);
-    }
-  }
-  if (max === null) { // It means that all positions were null === no segments (yet?)
-    return null;
-  }
-  return max;
-}

package/src/parsers/manifest/utils/get_last_time_from_adaptation.ts

@@ -1,50 +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 { IParsedAdaptation } from "../types";
-
-/**
- * Returns "last time of reference" from the adaptation given, considering a
- * dynamic content.
- * Undefined if a time could not be found.
- * Null if the Adaptation has no segments (it could be that it didn't started or
- * that it already finished for example).
- *
- * We consider the earliest last time from every representations in the given
- * adaptation.
- * @param {Object} adaptation
- * @returns {Number|undefined|null}
- */
-export default function getLastPositionFromAdaptation(
-  adaptation: IParsedAdaptation
-) : number | undefined | null {
-  const { representations } = adaptation;
-  let min : null | number = null;
-  for (let i = 0; i < representations.length; i++) {
-    const lastPosition = representations[i].index.getLastAvailablePosition();
-    if (lastPosition === undefined) { // we cannot tell
-      return undefined;
-    }
-    if (lastPosition !== null) {
-      min = min == null ? lastPosition :
-                          Math.min(min, lastPosition);
-    }
-  }
-  if (min === null) { // It means that all positions were null === no segments (yet?)
-    return null;
-  }
-  return min;
-}

package/src/parsers/manifest/utils/get_maximum_positions.ts

@@ -1,87 +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 { IParsedPeriod } from "../types";
-import getLastPositionFromAdaptation from "./get_last_time_from_adaptation";
-
-/**
- * @param {Object} manifest
- * @returns {number | undefined}
- */
-export default function getMaximumPosition(
-  periods : IParsedPeriod[]
-) : { safe : number | undefined;
-      unsafe : number | undefined; }
-{
-  for (let i = periods.length - 1; i >= 0; i--) {
-    const periodAdaptations = periods[i].adaptations;
-    const firstAudioAdaptationFromPeriod = periodAdaptations.audio === undefined ?
-      undefined :
-      periodAdaptations.audio[0];
-    const firstVideoAdaptationFromPeriod =  periodAdaptations.video === undefined ?
-      undefined :
-      periodAdaptations.video[0];
-
-    if (firstAudioAdaptationFromPeriod !== undefined ||
-        firstVideoAdaptationFromPeriod !== undefined
-    ) {
-      // null == no segment
-      let maximumAudioPosition : number | null = null;
-      let maximumVideoPosition : number | null = null;
-      if (firstAudioAdaptationFromPeriod !== undefined) {
-        const lastPosition =
-          getLastPositionFromAdaptation(firstAudioAdaptationFromPeriod);
-        if (lastPosition === undefined) {
-          return { safe: undefined, unsafe: undefined };
-        }
-        maximumAudioPosition = lastPosition;
-      }
-      if (firstVideoAdaptationFromPeriod !== undefined) {
-        const lastPosition =
-          getLastPositionFromAdaptation(firstVideoAdaptationFromPeriod);
-        if (lastPosition === undefined) {
-          return { safe: undefined, unsafe: undefined };
-        }
-        maximumVideoPosition = lastPosition;
-      }
-
-      if ((firstAudioAdaptationFromPeriod !== undefined &&
-           maximumAudioPosition === null) ||
-          (firstVideoAdaptationFromPeriod !== undefined &&
-            maximumVideoPosition === null)
-      ) {
-        log.info("Parser utils: found Period with no segment. ",
-                 "Going to previous one to calculate last position");
-        return { safe: undefined, unsafe: undefined };
-      }
-
-      if (maximumVideoPosition !== null) {
-        if (maximumAudioPosition !== null) {
-          return { safe: Math.min(maximumAudioPosition, maximumVideoPosition),
-                   unsafe: Math.max(maximumAudioPosition, maximumVideoPosition) };
-        }
-        return { safe: maximumVideoPosition,
-                 unsafe: maximumVideoPosition };
-      }
-      if (maximumAudioPosition !== null) {
-        return { safe: maximumAudioPosition,
-                 unsafe: maximumAudioPosition };
-      }
-    }
-  }
-  return { safe: undefined, unsafe: undefined };
-}

package/src/parsers/manifest/utils/get_minimum_position.ts

@@ -1,80 +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 { IParsedPeriod } from "../types";
-import getFirstPositionFromAdaptation from "./get_first_time_from_adaptation";
-
-/**
- * @param {Object} manifest
- * @returns {number | undefined}
- */
-export default function getMinimumPosition(
-  periods : IParsedPeriod[]
-) : number | undefined {
-  for (let i = 0; i <= periods.length - 1; i++) {
-    const periodAdaptations = periods[i].adaptations;
-    const firstAudioAdaptationFromPeriod = periodAdaptations.audio === undefined ?
-      undefined :
-      periodAdaptations.audio[0];
-    const firstVideoAdaptationFromPeriod =  periodAdaptations.video === undefined ?
-      undefined :
-      periodAdaptations.video[0];
-
-    if (firstAudioAdaptationFromPeriod !== undefined ||
-        firstVideoAdaptationFromPeriod !== undefined)
-    {
-      // null == no segment
-      let minimumAudioPosition : number | null = null;
-      let minimumVideoPosition : number | null = null;
-      if (firstAudioAdaptationFromPeriod !== undefined) {
-        const firstPosition =
-          getFirstPositionFromAdaptation(firstAudioAdaptationFromPeriod);
-        if (firstPosition === undefined) {
-          return undefined;
-        }
-        minimumAudioPosition = firstPosition;
-      }
-      if (firstVideoAdaptationFromPeriod !== undefined) {
-        const firstPosition =
-          getFirstPositionFromAdaptation(firstVideoAdaptationFromPeriod);
-        if (firstPosition === undefined) {
-          return undefined;
-        }
-        minimumVideoPosition = firstPosition;
-      }
-
-      if ((firstAudioAdaptationFromPeriod !== undefined &&
-           minimumAudioPosition === null) ||
-          (firstVideoAdaptationFromPeriod !== undefined &&
-           minimumVideoPosition === null)) {
-        log.info("Parser utils: found Period with no segment. ",
-                 "Going to next one to calculate first position");
-        return undefined;
-      }
-
-      if (minimumVideoPosition !== null) {
-        if (minimumAudioPosition !== null) {
-          return Math.max(minimumAudioPosition, minimumVideoPosition);
-        }
-        return minimumVideoPosition;
-      }
-      if (minimumAudioPosition !== null) {
-        return minimumAudioPosition;
-      }
-    }
-  }
-}

package/src/parsers/manifest/utils/index_helpers.ts

@@ -1,204 +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 isNullOrUndefined from "../../../utils/is_null_or_undefined";
-
-/** Generic way to represent segments in an index of segments. */
-export interface IIndexSegment {
-  /** The segment starting presentation time. */
-  start: number;
-  /** Difference between the last and first presentation time. */
-  duration: number;
-  /**
-   * Repeat counter.
-   * 1 === Repeat 1 time == 2 consecutive segments of this same duration.
-   */
-  repeatCount: number;
-  /** Optional byte-range the segment is available at when requested. */
-  range?: [number, number] | undefined;
-}
-
-/**
- * Calculate the number of times a timeline element repeats based on the next
- * element.
- * @param {Object} element
- * @param {Object|null|undefined} nextElement
- * @param {number|undefined} maxPosition
- * @returns {Number}
- */
-export function calculateRepeat(
-  element : IIndexSegment,
-  nextElement? : IIndexSegment | null | undefined,
-  maxPosition? : number | undefined
-) : number {
-  const { repeatCount } = element;
-
-  if (repeatCount >= 0) {
-    return repeatCount;
-  }
-
-  // A negative value of the @r attribute of the S element indicates
-  // that the duration indicated in @d attribute repeats until the
-  // start of the next S element, the end of the Period or until the
-  // next MPD update.
-  let segmentEnd : number;
-  if (!isNullOrUndefined(nextElement)) {
-    segmentEnd = nextElement.start;
-  } else if (maxPosition !== undefined) {
-    segmentEnd = maxPosition;
-  } else {
-    segmentEnd = Number.MAX_VALUE;
-  }
-  return Math.ceil((segmentEnd - element.start) / element.duration) - 1;
-}
-
-/**
- * Returns end of the segment given, in index time.
- * @param {Object} segment
- * @param {Object|null} [nextSegment]
- * @param {number} maxPosition
- * @returns {Number}
- */
-export function getIndexSegmentEnd(
-  segment : IIndexSegment,
-  nextSegment : IIndexSegment|null,
-  maxPosition? : number
-) : number {
-  const { start, duration } = segment;
-  if (duration <= 0) {
-    return start;
-  }
-
-  const repeat = calculateRepeat(segment, nextSegment, maxPosition);
-  return start + (repeat + 1) * duration;
-}
-
-/**
- * Convert from `presentationTime`, the time of the segment at the moment it
- * is decoded to `mediaTime`, the original time the segments point at.
- * @param {number} time
- * @param {Object} indexOptions
- * @returns {number}
- */
-export function toIndexTime(
-  time : number,
-  indexOptions : { timescale : number; indexTimeOffset? : number }
-) : number {
-  return time * indexOptions.timescale + (indexOptions.indexTimeOffset ?? 0);
-}
-
-/**
- * Convert from `mediaTime`, the original time the segments point at to
- * `presentationTime`, the time of the segment at the moment it is decoded.
- * @param {number} time
- * @param {Object} indexOptions
- * @returns {number}
- */
-export function fromIndexTime(
-  time : number,
-  indexOptions : { timescale : number; indexTimeOffset? : number }
-) : number {
-  return (time - (indexOptions.indexTimeOffset ?? 0)) / indexOptions.timescale;
-}
-
-/**
- * @param {Number} start
- * @param {Number} duration
- * @param {Number} timescale
- * @returns {Object} - Object with two properties:
- *   - up {Number}: timescaled timestamp of the beginning time
- *   - to {Number}: timescaled timestamp of the end time (start time + duration)
- */
-export function getTimescaledRange(
-  start: number,
-  duration: number,
-  timescale : number
-) : [number, number] {
-  return [ start * timescale,
-           (start + duration) * timescale ];
-}
-
-/**
- * Get index of the last segment in the timeline starting before/at the given
- * timescaled time.
- * Returns -1 if the given time is lower than the start of the first available
- * segment.
- * @param {Object} timeline
- * @param {Number} timeTScaled
- * @returns {Number}
- */
-function getIndexOfLastObjectBefore(
-  timeline : IIndexSegment[],
-  timeTScaled : number
-) : number {
-  let low = 0;
-  let high = timeline.length;
-
-  while (low < high) {
-    const mid = (low + high) >>> 1; // Divide by two + floor
-    if (timeline[mid].start <= timeTScaled) {
-      low = mid + 1;
-    } else {
-      high = mid;
-    }
-  }
-
-  return low - 1;
-}
-
-/**
- * @param {Object} index
- * @param {number} timeSec
- * @param {number} [maxPosition]
- * @returns {number|null}
- */
-export function checkDiscontinuity(
-  index : { timeline : IIndexSegment[];
-            timescale : number;
-            indexTimeOffset? : number; },
-  timeSec : number,
-  maxPosition? : number
-) : number | null {
-  const { timeline } = index;
-  const scaledTime = toIndexTime(timeSec, index);
-
-  if (scaledTime < 0) {
-    return null;
-  }
-
-  const segmentIndex = getIndexOfLastObjectBefore(timeline, scaledTime);
-  if (segmentIndex < 0 || segmentIndex >= timeline.length - 1) {
-    return null;
-  }
-
-  const timelineItem = timeline[segmentIndex];
-  if (timelineItem.duration <= 0) {
-    return null;
-  }
-
-  const nextTimelineItem = timeline[segmentIndex + 1];
-  if (nextTimelineItem === undefined) {
-    return null;
-  }
-
-  const nextStart = nextTimelineItem.start;
-  const segmentEnd = getIndexSegmentEnd(timelineItem,
-                                        nextTimelineItem,
-                                        maxPosition);
-  return scaledTime >= segmentEnd &&
-         scaledTime < nextStart ? fromIndexTime(nextStart, index) :
-                                  null;
-}

package/src/parsers/manifest/utils/update_segment_timeline.ts

@@ -1,141 +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 { MediaError } from "../../../errors";
-import log from "../../../log";
-import {
-  getIndexSegmentEnd,
-  IIndexSegment,
-} from "./index_helpers";
-
-/**
- * Update a complete array of segments in a given timeline with a [generally]
- * smaller but [generally] newer set of segments.
- *
- * Returns a boolean:
- *   - If set to `true`, the old timeline was emptied and completely replaced by
- *     the content of the newer timeline.
- *     This could happen either if a problem happened while trying to update or
- *     when the update is actually bigger than what it is updating.
- *   - If set to `false`, the older timeline was either updated to add the newer
- *     segments, or untouched.
- *
- * @param {Array.<Object>} oldTimeline
- * @param {Array.<Object>} newTimeline
- * @returns {boolean}
- */
-export default function updateSegmentTimeline(
-  oldTimeline : IIndexSegment[],
-  newTimeline : IIndexSegment[]
-) : boolean {
-  if (oldTimeline.length === 0) {
-    oldTimeline.push(...newTimeline);
-    return true;
-  } else if (newTimeline.length === 0) {
-    return false;
-  }
-
-  const prevTimelineLength = oldTimeline.length;
-  const newIndexStart = newTimeline[0].start;
-
-  const oldLastElt = oldTimeline[prevTimelineLength - 1];
-  const oldIndexEnd = getIndexSegmentEnd(oldLastElt, newTimeline[0]);
-  if (oldIndexEnd < newIndexStart) {
-    throw new MediaError("MANIFEST_UPDATE_ERROR",
-                         "Cannot perform partial update: not enough data");
-  }
-
-  for (let i = prevTimelineLength - 1; i >= 0; i--) {
-    const currStart = oldTimeline[i].start;
-    if (currStart === newIndexStart) {
-      // replace that one and those after it
-      const nbEltsToRemove = prevTimelineLength - i;
-      oldTimeline.splice(i, nbEltsToRemove, ...newTimeline);
-      return false;
-    } else if (currStart < newIndexStart) { // first to be before
-      const currElt = oldTimeline[i];
-      if (currElt.start + currElt.duration > newIndexStart) {
-        // The new Manifest overlaps a previous segment (weird)
-        // In that improbable case, we'll just completely replace segments
-        log.warn("RepresentationIndex: Manifest update removed all previous segments");
-        oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-        return true;
-      } else if (currElt.repeatCount === undefined || currElt.repeatCount <= 0) {
-        if (currElt.repeatCount < 0) {
-          currElt.repeatCount = Math.floor((newIndexStart - currElt.start) /
-                                              currElt.duration) - 1;
-        }
-        oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-        return false;
-      }
-      // else, there is a positive repeat we might want to update
-      const eltLastTime = currElt.start + currElt.duration * (currElt.repeatCount + 1);
-      if (eltLastTime <= newIndexStart) { // our new index comes directly after
-        // put it after this one
-        oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-        return false;
-      }
-
-      const newCurrRepeat = ((newIndexStart - currElt.start) / currElt.duration) - 1;
-      if (newCurrRepeat % 1 === 0 && currElt.duration === newTimeline[0].duration) {
-        const newRepeatCount = newTimeline[0].repeatCount < 0 ?
-          -1 : // === maximum possible repeat
-          newTimeline[0].repeatCount + newCurrRepeat + 1;
-
-        // replace that one and those after it
-        oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
-        oldTimeline[i].start = currElt.start;
-        oldTimeline[i].repeatCount = newRepeatCount;
-        return false;
-      }
-      log.warn("RepresentationIndex: Manifest update removed previous segments");
-      oldTimeline[i].repeatCount = Math.floor(newCurrRepeat);
-
-      // put it after this one
-      oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-      return false;
-    }
-  }
-
-  // if we got here, it means that every segments in the previous manifest are
-  // after the new one. This is unusual.
-  // Either the new one has more depth or it's an older one.
-  const prevLastElt = oldTimeline[oldTimeline.length - 1];
-  const newLastElt = newTimeline[newTimeline.length - 1];
-  if (prevLastElt.repeatCount !== undefined && prevLastElt.repeatCount < 0) {
-    if (prevLastElt.start > newLastElt.start) {
-      log.warn("RepresentationIndex: The new index is older than the previous one");
-      return false;
-    } else { // the new has more depth
-      log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
-      oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-      return true;
-    }
-  }
-  const prevLastTime = prevLastElt.start + prevLastElt.duration *
-                       (prevLastElt.repeatCount + 1);
-  const newLastTime = newLastElt.start + newLastElt.duration *
-                      (newLastElt.repeatCount + 1);
-  if (prevLastTime >= newLastTime) {
-    log.warn("RepresentationIndex: The new index is older than the previous one");
-    return false;
-  }
-
-  // the new one has more depth. full update
-  log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
-  oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-  return true;
-}