rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/src/parsers/manifest/dash/common/indexes/tokens.ts

@@ -1,127 +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 isNonEmptyString from "../../../../../utils/is_non_empty_string";
-
-/**
- * Pad with 0 in the left of the given n argument to reach l length
- * @param {Number|string} n
- * @param {Number} l
- * @returns {string}
- */
-function padLeftWithZeros(n : number|string, l : number) : string {
-  const nToString = n.toString();
-  if (nToString.length >= l) {
-    return nToString;
-  }
-  const arr = new Array(l + 1).join("0") + nToString;
-  return arr.slice(-l);
-}
-
-/**
- * @param {string|number} replacer
- * @returns {Function}
- */
-function processFormatedToken(
-  replacer : string | number
-) : (x: unknown, y: unknown, widthStr: string) => string {
-  return (_match, _format, widthStr : string) => {
-    const width = isNonEmptyString(widthStr) ? parseInt(widthStr, 10) :
-                                               1;
-    return padLeftWithZeros(String(replacer), width);
-  };
-}
-
-/**
- * @param {string} urlTemplate
- * @param {string|undefined} representationId
- * @param {number|undefined} bitrate
- * @returns {string}
- */
-export function constructRepresentationUrl(
-  urlTemplate : string,
-  representationId?: string,
-  bitrate?: number
-): string {
-  return replaceRepresentationDASHTokens(urlTemplate, representationId, bitrate);
-}
-
-/**
- * Replace "tokens" written in a given path (e.g. $RepresentationID$) by the corresponding
- * infos, taken from the given segment.
- * @param {string} path
- * @param {string|undefined} id
- * @param {number|undefined} bitrate
- * @returns {string}
- */
-export function replaceRepresentationDASHTokens(
-  path: string,
-  id?: string,
-  bitrate?: number
-): string {
-  if (path.indexOf("$") === -1) {
-    return path;
-  } else {
-    return path
-      .replace(/\$\$/g, "$")
-      .replace(/\$RepresentationID\$/g, String(id))
-      .replace(/\$Bandwidth(\%0(\d+)d)?\$/g,
-               processFormatedToken(bitrate === undefined ? 0 :
-                                                            bitrate));
-  }
-}
-
-/**
- * Create function allowing to replace "tokens" in a given DASH segment URL
- * (e.g. $Time$, which has to be replaced by the segment's start time) by the
- * right information.
- * @param {number|undefined} time
- * @param {number|undefined} nb
- * @returns {Function}
- */
-export function createDashUrlDetokenizer(
-  time : number | undefined,
-  nb : number | undefined
-) : (url : string) => string {
-  /**
-   * Replace the tokens in the given `url` by the segment information defined
-   * by the outer function.
-   * @param {string} url
-   * @returns {string}
-   *
-   * @throws Error - Throws if we do not have enough data to construct the URL
-   */
-  return function replaceTokensInUrl(url : string) : string {
-    if (url.indexOf("$") === -1) {
-      return url;
-    } else {
-      return url
-        .replace(/\$\$/g, "$")
-        .replace(/\$Number(\%0(\d+)d)?\$/g, (_x, _y, widthStr : string) => {
-          if (nb === undefined) {
-            throw new Error("Segment number not defined in a $Number$ scheme");
-          }
-          return processFormatedToken(nb)(_x, _y, widthStr);
-        })
-        .replace(/\$Time(\%0(\d+)d)?\$/g, (_x, _y, widthStr : string) => {
-          if (time === undefined) {
-            throw new Error("Segment time not defined in a $Time$ scheme");
-          }
-          return processFormatedToken(time)(_x, _y, widthStr);
-        });
-    }
-  };
-}

package/src/parsers/manifest/dash/common/indexes/utils.ts

@@ -1,32 +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 config from "../../../../../config";
-
-
-/**
- * In Javascript, numbers are encoded in a way that a floating number may be
- * represented internally with a rounding error.
- *
- * This function returns a small number allowing to accound for rounding many
- * rounding errors.
- * @param {number} timescale
- * @returns {boolean}
- */
-export function getSegmentTimeRoundingError(timescale: number): number {
-  return config.getCurrent().DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
-}
-

package/src/parsers/manifest/dash/common/infer_adaptation_type.ts

@@ -1,136 +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 { SUPPORTED_ADAPTATIONS_TYPE } from "../../../../manifest";
-import arrayFind from "../../../../utils/array_find";
-import arrayIncludes from "../../../../utils/array_includes";
-import { IRepresentationIntermediateRepresentation } from "../node_parser_types";
-
-/** Different "type" a parsed Adaptation can be. */
-type IAdaptationType = "audio" |
-                       "video" |
-                       "text";
-
-/** Different `role`s a text Adaptation can be. */
-const SUPPORTED_TEXT_TYPES = ["subtitle", "caption"];
-
-/** Structure of a parsed "scheme-like" element in the MPD. */
-interface IScheme {
-  schemeIdUri? : string | undefined;
-  value? : string | undefined;
-}
-
-/**
- * Infers the type of adaptation from codec and mimetypes found in it.
- *
- * This follows the guidelines defined by the DASH-IF IOP:
- *   - one adaptation set contains a single media type
- *   - The order of verifications are:
- *       1. mimeType
- *       2. Role
- *       3. codec
- *
- * Note: This is based on DASH-IF-IOP-v4.0 with some more freedom.
- * @param {Array.<Object>} representations
- * @param {string|null} adaptationMimeType
- * @param {string|null} adaptationCodecs
- * @param {Array.<Object>|null} adaptationRoles
- * @returns {string} - "audio"|"video"|"text"|"metadata"|"unknown"
- */
-export default function inferAdaptationType(
-  representations: IRepresentationIntermediateRepresentation[],
-  adaptationMimeType : string | null,
-  adaptationCodecs : string | null,
-  adaptationRoles : IScheme[] | null
-) : IAdaptationType | undefined {
-  function fromMimeType(
-    mimeType : string,
-    roles : IScheme[]|null
-  ) : IAdaptationType | undefined {
-    const topLevel = mimeType.split("/")[0];
-    if (arrayIncludes<IAdaptationType>(SUPPORTED_ADAPTATIONS_TYPE,
-                                       topLevel as IAdaptationType)) {
-      return topLevel as IAdaptationType;
-    }
-    if (mimeType === "application/ttml+xml") {
-      return "text";
-    }
-    // manage DASH-IF mp4-embedded subtitles and metadata
-    if (mimeType === "application/mp4") {
-      if (roles != null) {
-        if (
-          arrayFind(roles, (role) =>
-            role.schemeIdUri === "urn:mpeg:dash:role:2011" &&
-            arrayIncludes(SUPPORTED_TEXT_TYPES, role.value)
-          ) != null
-        ) {
-          return "text";
-        }
-      }
-      return undefined;
-    }
-  }
-  function fromCodecs(codecs : string) : IAdaptationType | undefined {
-    switch (codecs.substring(0, 3)) {
-      case "avc":
-      case "hev":
-      case "hvc":
-      case "vp8":
-      case "vp9":
-      case "av1":
-        return "video";
-      case "vtt":
-        return "text";
-    }
-    switch (codecs.substring(0, 4)) {
-      case "mp4a":
-        return "audio";
-      case "wvtt":
-      case "stpp":
-        return "text";
-    }
-  }
-  if (adaptationMimeType !== null) {
-    const typeFromMimeType = fromMimeType(adaptationMimeType, adaptationRoles);
-    if (typeFromMimeType !== undefined) {
-      return typeFromMimeType;
-    }
-  }
-  if (adaptationCodecs !== null) {
-    const typeFromCodecs = fromCodecs(adaptationCodecs);
-    if (typeFromCodecs !== undefined) {
-      return typeFromCodecs;
-    }
-  }
-
-  for (let i = 0; i < representations.length; i++) {
-    const representation = representations[i];
-    const { mimeType, codecs } = representation.attributes;
-    if (mimeType !== undefined) {
-      const typeFromMimeType = fromMimeType(mimeType, adaptationRoles);
-      if (typeFromMimeType !== undefined) {
-        return typeFromMimeType;
-      }
-    }
-    if (codecs !== undefined) {
-      const typeFromCodecs = fromCodecs(codecs);
-      if (typeFromCodecs !== undefined) {
-        return typeFromCodecs;
-      }
-    }
-  }
-  return undefined;
-}

package/src/parsers/manifest/dash/common/manifest_bounds_calculator.ts

@@ -1,171 +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 getMonotonicTimeStamp from "../../../../utils/monotonic_timestamp";
-
-/**
- * This class allows to easily calculate the first and last available positions
- * in a content at any time.
- *
- * By centralizing the manifest bounds calculation in this class and by giving
- * an instance of it to each parsed elements which might depend on it, we
- * ensure that we can provide it once it is known to every one of those
- * elements without needing to parse a second time the MPD.
- * @class ManifestBoundsCalculator
- */
-export default class ManifestBoundsCalculator {
-  /**
-   * Value of MPD@timeShiftBufferDepth.
-   * `null` if not defined.
-   */
-  private _timeShiftBufferDepth : number | null;
-  /**
-   * Value of MPD@availabilityStartTime as an unix timestamp in seconds.
-   * `0` if it wasn't defined.
-   */
-  private _availabilityStartTime : number;
-  /** `true` if MPD@type is equal to "dynamic". */
-  private _isDynamic : boolean;
-  /**
-   * Monotonically-raising timestamp (the one used by the RxPlayer) when
-   * `lastPosition` was calculated.
-   */
-  private _positionTime : number | undefined;
-  /** Last position calculated at a given moment (itself indicated by `_positionTime`. */
-  private _lastPosition : number | undefined;
-  /**
-   * Offset to add to `performance.now` to obtain a good estimation of the
-   * server-side unix timestamp.
-   *
-   * `undefined` if unknown.
-   */
-  private _serverTimestampOffset : number | undefined;
-
-  /**
-   * @param {Object} args
-   */
-  constructor(args : {
-    availabilityStartTime : number;
-    timeShiftBufferDepth : number | undefined;
-    isDynamic : boolean;
-    serverTimestampOffset: number | undefined;
-  }) {
-    this._isDynamic = args.isDynamic;
-    this._timeShiftBufferDepth = !args.isDynamic ||
-                                 args.timeShiftBufferDepth === undefined ?
-                                   null :
-                                   args.timeShiftBufferDepth;
-    this._serverTimestampOffset = args.serverTimestampOffset;
-    this._availabilityStartTime = args.availabilityStartTime;
-  }
-
-  /**
-   * Set the last position and the position time (the value of the RxPlayer's
-   * monotonically-raising timestamp at the time that position was true
-   * converted into seconds).
-   *
-   * @example
-   * Example if you trust `Date.now()` to give you a reliable offset:
-   * ```js
-   * const lastPosition = Date.now();
-   * const positionTime = getMonotonicTimeStamp() / 1000;
-   * manifestBoundsCalculator.setLastPosition(lastPosition, positionTime);
-   * ```
-   *
-   * @param {number} lastPosition
-   * @param {number|undefined} positionTime
-   */
-  setLastPosition(lastPosition : number, positionTime?: number) : void {
-    this._lastPosition = lastPosition;
-    this._positionTime = positionTime;
-  }
-
-  /**
-   * Returns `true` if the last position and the position time
-   * (for dynamic content only) have been comunicated.
-   * `false` otherwise.
-   * @returns {boolean}
-   */
-  lastPositionIsKnown() : boolean {
-    if (this._isDynamic) {
-      return this._positionTime != null && this._lastPosition != null;
-    }
-    return this._lastPosition != null;
-  }
-
-  /**
-   * Estimate a minimum bound for the content from the last set segment time
-   * and buffer depth.
-   * Consider that it is only an estimation, not the real value.
-   * @return {number|undefined}
-   */
-  getEstimatedMinimumSegmentTime(): number | undefined {
-    if (!this._isDynamic || this._timeShiftBufferDepth === null) {
-      return 0;
-    }
-    const maximumBound = this.getEstimatedLiveEdge() ??
-                         this.getEstimatedMaximumPosition(0);
-    if (maximumBound === undefined) {
-      return undefined;
-    }
-    const minimumBound = maximumBound - this._timeShiftBufferDepth;
-    return minimumBound;
-  }
-
-  /**
-   * Estimate the segment time in seconds that corresponds to what could be
-   * considered the live edge (or `undefined` for non-live contents).
-   *
-   * Note that for some contents which just anounce segments in advance, this
-   * value might be very different than the maximum position that is
-   * requestable.
-   * @return {number|undefined}
-   */
-  getEstimatedLiveEdge() : number | undefined {
-    if (!this._isDynamic || this._serverTimestampOffset === undefined) {
-      return undefined;
-    }
-    return (getMonotonicTimeStamp() + this._serverTimestampOffset) / 1000 -
-      this._availabilityStartTime;
-  }
-
-  /**
-   * Produce a rough estimate of the ending time of the last requestable segment
-   * in that content.
-   *
-   * This value is only an estimate and may be far from reality.
-   *
-   * The `availabilityTimeOffset` in argument is the corresponding
-   * `availabilityTimeOffset` that applies to the current wanted segment, or `0`
-   * if none exist. It will be applied on live content to deduce the maximum
-   * segment time available.
-   */
-  getEstimatedMaximumPosition(availabilityTimeOffset: number) : number | undefined {
-    if (!this._isDynamic) {
-      return this._lastPosition;
-    }
-
-    const liveEdge = this.getEstimatedLiveEdge();
-    if (liveEdge !== undefined && availabilityTimeOffset !== Infinity) {
-      return liveEdge + availabilityTimeOffset;
-    } else if (this._positionTime !== undefined && this._lastPosition !== undefined) {
-      return Math.max((this._lastPosition - this._positionTime) +
-                        (getMonotonicTimeStamp() / 1000),
-                      0);
-    }
-    return this._lastPosition;
-  }
-}