rx-player 3.33.0 → 3.33.2

package/src/parsers/manifest/local/representation_index.ts

@@ -1,246 +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 {
-  IRepresentationIndex,
-  ISegment,
-} from "../../../manifest";
-import {
-  ILocalIndex,
-  ILocalIndexSegment,
-} from "./types";
-
-export default class LocalRepresentationIndex implements IRepresentationIndex {
-  private _index : ILocalIndex;
-  private _representationId : string;
-  constructor(index : ILocalIndex, representationId : string) {
-    this._index = index;
-    this._representationId = representationId;
-  }
-
-  /**
-   * @returns {Object}
-   */
-  getInitSegment() : ISegment|null {
-    return {
-      id: `${this._representationId}_init`,
-      isInit: true,
-      time: 0,
-      end: 0,
-      duration: 0,
-      timescale: 1,
-      url: null,
-      complete: true,
-      privateInfos: {
-        localManifestInitSegment: { load: this._index.loadInitSegment } },
-    };
-  }
-
-  /**
-   * @param {Number} up
-   * @param {Number} duration
-   * @returns {Array.<Object>}
-   */
-  getSegments(up : number, duration : number) : ISegment[] {
-    const startTime = up;
-    const endTime = up + duration;
-    const wantedSegments : ILocalIndexSegment[] = [];
-    for (let i = 0; i < this._index.segments.length; i++) {
-      const segment = this._index.segments[i];
-      const segmentStart = segment.time;
-      if (endTime <= segmentStart) {
-        break;
-      }
-      const segmentEnd = segment.time + segment.duration;
-      if (segmentEnd > startTime) {
-        wantedSegments.push(segment);
-      }
-    }
-
-    return wantedSegments
-      .map(wantedSegment => {
-        return {
-          id: `${this._representationId}_${wantedSegment.time}`,
-          isInit: false,
-          time: wantedSegment.time,
-          end: wantedSegment.time + wantedSegment.duration,
-          duration: wantedSegment.duration,
-          timescale: 1,
-          timestampOffset: wantedSegment.timestampOffset,
-          url: null,
-          complete: true,
-          privateInfos: {
-            localManifestSegment: { load: this._index.loadSegment,
-                                    segment: wantedSegment },
-          },
-        };
-      });
-  }
-
-  /**
-   * @returns {Number|undefined}
-   */
-  getFirstAvailablePosition() : number|undefined {
-    if (this._index.segments.length === 0) {
-      return undefined;
-    }
-    const firstSegment = this._index.segments[0];
-    return firstSegment.time;
-  }
-
-  /**
-   * @returns {Number|undefined}
-   */
-  getLastAvailablePosition() : number|undefined {
-    if (this._index.segments.length === 0) {
-      return undefined;
-    }
-    const lastSegment = this._index.segments[this._index.segments.length - 1];
-    return lastSegment.time + lastSegment.duration;
-  }
-
-  /**
-   * Returns the expected ending position of this RepresentationIndex.
-   * `undefined` if unknown.
-   * @returns {number|undefined}
-   */
-  getEnd() : number | undefined {
-    if (this._index.isFinished) {
-      return this.getLastAvailablePosition();
-    }
-
-    const { incomingRanges, segments } = this._index;
-    if (incomingRanges === undefined || incomingRanges.length === 0) {
-      // If incomingRanges is empty but not finished... It's ambiguous.
-      return undefined;
-    }
-    const lastIncomingRange = incomingRanges[incomingRanges.length - 1];
-    const futureEnd = lastIncomingRange.end;
-    if (segments.length === 0) {
-      return futureEnd;
-    }
-    const lastSegment = this._index.segments[this._index.segments.length - 1];
-    return Math.max(lastSegment.time + lastSegment.duration, futureEnd);
-  }
-
-  /**
-   * Returns:
-   *   - `true` if in the given time interval, at least one new segment is
-   *     expected to be available in the future.
-   *   - `false` either if all segments in that time interval are already
-   *     available for download or if none will ever be available for it.
-   *   - `undefined` when it is not possible to tell.
-   * @param {number} start
-   * @param {number} end
-   * @returns {boolean|undefined}
-   */
-  awaitSegmentBetween(start: number, end: number): boolean | undefined {
-    if (this.isStillAwaitingFutureSegments()) {
-      return false;
-    }
-    if (this._index.incomingRanges === undefined) {
-      return undefined;
-    }
-    return this._index.incomingRanges.some((range) =>
-      range.start < end && range.end > start);
-  }
-
-  /**
-   * @returns {Boolean}
-   */
-  shouldRefresh() : false {
-    return false;
-  }
-
-  /**
-   * @returns {Boolean}
-   */
-  isSegmentStillAvailable() : true {
-    return true;
-  }
-
-  isStillAwaitingFutureSegments() : boolean {
-    return !this._index.isFinished;
-  }
-
-  /**
-   * @returns {Boolean}
-   */
-  canBeOutOfSyncError() : false {
-    return false;
-  }
-
-  /**
-   * @returns {null}
-   */
-  checkDiscontinuity() : null {
-    return null;
-  }
-
-  /**
-   * @returns {Boolean}
-   */
-  isInitialized() : true {
-    return true;
-  }
-
-  _replace(newIndex : LocalRepresentationIndex) : void {
-    this._index.segments = newIndex._index.segments;
-    this._index.loadSegment = newIndex._index.loadSegment;
-    this._index.loadInitSegment = newIndex._index.loadInitSegment;
-  }
-
-  _update(newIndex : LocalRepresentationIndex) : void {
-    const newSegments = newIndex._index.segments;
-    if (newSegments.length <= 0) {
-      return;
-    }
-    const insertNewIndexAtPosition = (pos : number) : void => {
-      this._index.segments.splice(pos, oldIndexLength - pos, ...newSegments);
-      this._index.loadSegment = newIndex._index.loadSegment;
-      this._index.loadInitSegment = newIndex._index.loadInitSegment;
-    };
-    const oldIndexLength = this._index.segments.length;
-    const newIndexStart = newSegments[0].time;
-    for (let i = oldIndexLength - 1; i >= 0; i--) {
-      const currSegment = this._index.segments[i];
-      if (currSegment.time === newIndexStart) {
-        return insertNewIndexAtPosition(i);
-      } else if (currSegment.time < newIndexStart) {
-        if (currSegment.time + currSegment.duration > newIndexStart) {
-          // the new Manifest overlaps a previous segment (weird). Remove the latter.
-          log.warn("Local RepresentationIndex: Manifest update removed" +
-            " previous segments");
-          return insertNewIndexAtPosition(i);
-        }
-        return insertNewIndexAtPosition(i + 1);
-      }
-    }
-
-    // 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 oldIndexEnd = this._index.segments[oldIndexLength - 1].time +
-                        this._index.segments[oldIndexLength - 1].duration;
-    const newIndexEnd = newSegments[newSegments.length - 1].time +
-                          newSegments[newSegments.length - 1].duration;
-    if (oldIndexEnd >= newIndexEnd) {
-      return;
-    }
-    return this._replace(newIndex);
-  }
-}

package/src/parsers/manifest/local/types.ts

@@ -1,291 +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.
- */
-
-/**
- * Callback allowing to retrieve an initialization segment. Each
- * `ILocalManifestInitSegmentLoader` will be associated to a single
- * `ILocalRepresentation`, so to only one possible initialization segment
- * (or to the absence of one).
- *
- * It will be called when the RxPlayer wants to download the corresponding
- * `ILocalRepresentation`'s initialization segment.
- * When called, it will have a single argument containing two properties:
- *   - `resolve`: function to call when the data has been loaded, with the
- *                data itself.
- *                If the corresponding `ILocalRepresentation` has no
- *                initialization segment, this data can be set to `null`.
- *   - `reject`: function to call when an error happened which made the
- *               retrieval of the data impossible. The error should be given
- *               to this function.
- *
- * Optionally, this callack can return a function. This function will be called
- * in the case where the RxPlayer wants to cancel this request.
- * You can thus abort every steps taken to retrieve the segment in that callback.
- * Calls to `resolve` and to `reject` won't be considered after the returned
- * callback is called.
- */
-export type ILocalManifestInitSegmentLoader = (
-  callbacks : { resolve : (args: { data : ArrayBuffer | null }) => void;
-
-                reject : (err? : Error) => void; }
-) => (() => void) | void;
-
-/**
- * Callback allowing to retrieve a media segment. Each `ILocalManifestSegmentLoader`
- * will be associated to a single `ILocalRepresentation`.
- *
- * It will be called when the RxPlayer wants to download a specific media
- * segment for that `ILocalRepresentation` with two arguments.
- *
- * The first of those arguments is the segment the player wants to fetch.
- * This coresponds to the same object than the one defined in the corresponding
- * `ILocalIndex`.
- *
- * The second argument is an object containing two callbacks, that you can call
- * either when the segment has been loaded or when an error happened while doing
- * so:
- *   - `resolve`: function to call when the data has been loaded, with the
- *                data itself.
- *   - `reject`: function to call when an error happened which made the
- *               retrieval of the data impossible. The error should be given
- *               to this function.
- *
- * Optionally, this callack can return a function. This function will be called
- * in the case where the RxPlayer wants to cancel this request.
- * You can thus abort every steps taken to retrieve the segment in that callback.
- * Calls to `resolve` and to `reject` won't be considered after the returned
- * callback is called.
- */
-export type ILocalManifestSegmentLoader = (
-  segment : ILocalIndexSegment, // Same than the segment from `segments`
-  callbacks : { resolve : (args: { data : ArrayBuffer }) => void;
-
-                reject : (err? : Error) => void; }
-) => (() => void) | void;
-
-/**
- * DRM information describing a "keyId" identifying a key with which a given
- * `ILocalRepresentation` is encrypted.
- */
-export interface IContentProtectionKID {
-  /** The corresponding "keyId", encoded as an array of bytes. */
-  keyId : Uint8Array;
-  /**
-   * Optional "systemId" (identifying a given key system) to which the keyId
-   * apply.
-   * This systemId should be defined as an hexadecimal string, with optional
-   * dashes in between. An example of possible systemId can be found here:
-   * https://dashif.org/identifiers/content_protection/
-   */
-  systemId?: string;
-}
-
-/**
- * DRM information describing initialization data necessary to initialize a
- * given CDM's instance.
- * For the moment, this is limited to PSSH information.
- */
-export interface IContentProtectionInitData {
-  /**
-   * The initialization data itself. For data coming from a pssh ISOBMFF box,
-   * this includes the size and name of the box.
-   */
-  data : Uint8Array;
-  /**
-   * Id defining what key system the initialization data applies to.
-   *
-   * This systemId should be defined as an hexadecimal string, with optional
-   * dashes in between. An example of possible systemId can be found here:
-   * https://dashif.org/identifiers/content_protection/
-   */
-  systemId : string;
-}
-
-/**
- * Object describing DRM information for a given `ILocalRepresentation`.
- * Note that any information here is optional. A content can be encrypted
- * without these being properly defined.
- * Those information are only used for supplementary features and optimizations
- * in the RxPlayer.
- */
-export interface IContentProtections {
-  /** All "keyId" that applies to the `ILocalRepresentation`. */
-  keyIds : IContentProtectionKID[];
-  /**
-   * DRM information describing initialization data necessary to initialize a
-   * given CDM's instance.
-   * This is an Object grouping such initialization data by "types" of data.
-   * Examples of possible initialization data type can be found here:
-   * https://www.w3.org/TR/eme-initdata-registry/
-   */
-  initData : Partial<Record<string, IContentProtectionInitData[]>>;
-}
-
-/** Object defining a single available media segment in a `ILocalIndex`. */
-export interface ILocalIndexSegment {
-  /** Earliest presentation time available for this segment, in seconds. */
-  time : number;
-  /**
-   * Time difference between the maximum available presentation time in this
-   * segment and the first (defined by `time`), in seconds.
-   */
-  duration : number;
-  /**
-   * If set, this is the amount of time in seconds we have to add to the
-   * segment once loaded so it can be decoded at the time indicated by the
-   * `time` property.
-   */
-  timestampOffset? : number;
-}
-
-/** "Index" of a `ILocalRepresentation`. Allow to declare available segments. */
-export interface ILocalIndex {
-  /** Every segments in that `ILocalIndex` has been downloaded. */
-  isFinished : boolean;
-  /** Callback used to retrieve the initialization segment of a `ILocalRepresentation`. */
-  loadInitSegment : ILocalManifestInitSegmentLoader;
-  /** Callback used to retrieve a media segment of a `ILocalRepresentation`. */
-  loadSegment : ILocalManifestSegmentLoader;
-  /**
-   * List of available media segments, in chronological order.
-   * Doesn't include the initialization segment.
-   */
-  segments : ILocalIndexSegment[];
-  /**
-   * List of not yet available time ranges, that should become available once
-   * the content is fully loaded.
-   */
-  incomingRanges?: Array<{ start : number; end : number }>;
-}
-
-/** A quality for a given "local" Manifest track (`ILocalAdaptation`). */
-export interface ILocalRepresentation {
-  /** Maximum number of bytes per second for the segments contained in this quality. */
-  bitrate : number;
-  /** DRM information. */
-  contentProtections? : IContentProtections;
-  /** Mime-type of the corresponding quality's segment. */
-  mimeType : string;
-  /** Codec(s) necessary to decode this quality's segment. */
-  codecs : string;
-  /**
-   * Width in pixels for this quality.
-   * This should only be set if the corresponding "track" contains video.
-   */
-  width? : number;
-  /**
-   * Height in pixels for this quality.
-   * This should only be set if the corresponding "track" contains video.
-   */
-  height? : number;
-  /** Interface allowing to retrieve media segments for this quality. */
-  index : ILocalIndex;
-  /** `true` if audio has Dolby Atmos. */
-  isSpatialAudio? : boolean;
-}
-
-/** A "track"" of a "local" Manifest. */
-export interface ILocalAdaptation {
-  /** The "type" of that track ("text" == subtitles, closed captions...). */
-  type : "audio" | "video" | "text";
-  /**
-   * If `true`, this track contains an audio description of what is happening
-   * visually on the screen.
-   */
-  audioDescription? : boolean;
-  /** If `true`, this track contains closed captions. */
-  closedCaption? : boolean;
-  /** The ISO 639-3, ISO 639-2 or ISO 639-1 language code for that track. */
-  language? : string;
-  /** The different qualities this track is available in. */
-  representations: ILocalRepresentation[];
-}
-
-/** Sub-part of a "local" Manifest, with specific tracks and qualities.  */
-export interface ILocalPeriod {
-  /** Start time at which the Period begins, in seconds. */
-  start: number;
-  /** End time at which the Period ends, in seconds. */
-  end: number;
-  /** The different "tracks" available for this Period. */
-  adaptations: ILocalAdaptation[];
-}
-
-/**
- * Format of a "local" Manifest, which allows to play locally-stored contents.
- *
- * Special properties also allow to play content that are still being
- * downloaded.
- */
-export interface ILocalManifest {
-  /** Required. Confirms that the current object is a "local" Manifest */
-  type : "local";
-  /**
-   * Version of the object, under a `MAJOR.MINOR` format.
-   * MAJOR: A parser compatible to a different major version should not try to
-   *        parse it
-   * MINOR: Retro-compatible format change.
-   *
-   * The exception is the `0` MAJOR version (i.e. experimental versions).
-   * A parser for a version in that major (let's say `0.1`) might be unable to
-   * parse local Manifests of another version (e.g. `0.2`).
-   *
-   * There are two versions defined for now and we are compatible to both:
-   *
-   *   - "0.1": initial version
-   *
-   *   - "0.2": `minimumPosition` and `maximumPosition` are now defined.
-   *            `duration` has been removed.
-   *
-   *            `start` and `duration` from a ILocalPeriod and `time` and
-   *            `duration` from a `ILocalIndexSegment` are now in seconds
-   *            instead of milliseconds.
-   *
-   *   - "0.3": optional `futureSegments` has been added to `ILocalIndex`
-   *            `duration` has been removed.
-   *
-   *            A mandatory `isFinished` boolean should now be set on a
-   *            `ILocalIndex`.
-   */
-  version : string;
-  /**
-   * Minimum position reachable in this content once fully downloaded, in
-   * seconds.
-   *
-   * Set to `0` by default.
-   */
-  minimumPosition? : number;
-  /**
-   * Maximum position reachable in this content once fully downloaded, in
-   * seconds.
-   */
-  maximumPosition : number;
-  /**
-   * Optional Promise used to trigger a Manifest refresh.
-   *
-   * When this Promise resolves, it means that the Local Manifest needs to be
-   * updated.
-   */
-  expired? : Promise<void>;
-  /** Sub-parts of the content, each with specific tracks and qualities.  */
-  periods : ILocalPeriod[];
-  /**
-   * Whether the "local" Manifest generation is finished.
-   * `true` if it is already fully-loaded.
-   * `false` if it is still being downloaded.
-   */
-  isFinished : boolean;
-}

package/src/parsers/manifest/metaplaylist/index.ts

@@ -1,28 +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 parseMetaPlaylist, {
-  IMetaPlaylist,
-  IMetaPlaylistTextTrack,
-  IParserResponse,
-} from "./metaplaylist_parser";
-
-export default parseMetaPlaylist;
-export {
-  IMetaPlaylist,
-  IMetaPlaylistTextTrack,
-  IParserResponse,
-};