rx-player 3.33.0 → 3.33.2

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

@@ -1,335 +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 Manifest, {
-  IAdaptationType,
-  StaticRepresentationIndex,
-  SUPPORTED_ADAPTATIONS_TYPE,
-} from "../../../manifest";
-import idGenerator from "../../../utils/id_generator";
-import { getFilenameIndexInUrl } from "../../../utils/resolve_url";
-import {
-  IParsedAdaptation,
-  IParsedAdaptations,
-  IParsedManifest,
-  IParsedPeriod,
-  IParsedRepresentation,
-} from "../types";
-import MetaRepresentationIndex from "./representation_index";
-
-export type IParserResponse<T> =
-  { type : "needs-manifest-loader";
-    value : {
-      ressources : Array<{ url : string; transportType : string }>;
-      continue : (loadedRessources : Manifest[]) => IParserResponse<T>;
-    }; } |
-  { type : "done"; value : T };
-
-export interface IMetaPlaylistTextTrack {
-  url : string;
-  language : string;
-  closedCaption : boolean;
-  mimeType : string;
-  codecs? : string;
-}
-
-export interface IMetaPlaylist {
-  type : "MPL"; // Obligatory token
-  version : string; // MAJOR.MINOR
-  dynamic? : boolean; // The MetaPlaylist could need to be updated
-  pollInterval? : number; // Refresh interval in seconds
-  contents: Array<{ // Sub-Manifests
-    url: string; // URL of the Manifest
-    startTime: number; // start timestamp in seconds
-    endTime: number; // end timestamp in seconds
-    transport: string; // "dash" | "smooth" | "metaplaylist"
-    textTracks?: IMetaPlaylistTextTrack[];
-  }>;
-}
-
-/**
- * Parse playlist string to JSON.
- * Returns an array of contents.
- * @param {string} data
- * @param {string} url
- * @returns {Object}
- */
-export default function parseMetaPlaylist(
-  data : unknown,
-  parserOptions : {
-    url?: string | undefined;
-    serverSyncInfos?: {
-      serverTimestamp: number;
-      clientTime: number;
-    } | undefined;
-  }
-): IParserResponse<IParsedManifest> {
-  let parsedData;
-  if (typeof data === "object" && data != null) {
-    parsedData = data;
-  } else if (typeof data === "string") {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      parsedData = JSON.parse(data);
-    } catch (error) {
-      throw new Error("MPL Parser: Bad MetaPlaylist file. Expected JSON.");
-    }
-  } else {
-    throw new Error("MPL Parser: Parser input must be either a string " +
-                    "or the MetaPlaylist data directly.");
-  }
-
-  const { contents, version, type } = parsedData as IMetaPlaylist;
-
-  if (type !== "MPL") {
-    throw new Error("MPL Parser: Bad MetaPlaylist. " +
-                    "The `type` property is not set to `MPL`");
-  }
-
-  if (version !== "0.1") {
-    throw new Error("MPL Parser: Bad MetaPlaylist version");
-  }
-
-  // quick checks
-  if (contents == null || contents.length === 0) {
-    throw new Error("MPL Parser: No content found.");
-  }
-  const ressources : Array<{ url : string; transportType : string }> = [];
-  for (let i = 0; i < contents.length; i++) {
-    const content = contents[i];
-    if (
-      content.url == null ||
-      content.startTime == null ||
-      content.endTime == null ||
-      content.transport == null
-    ) {
-      throw new Error("MPL Parser: Malformed content.");
-    }
-    ressources.push({ url: content.url, transportType: content.transport });
-  }
-
-  const metaPlaylist : IMetaPlaylist = parsedData as IMetaPlaylist;
-  return {
-    type : "needs-manifest-loader",
-    value : {
-      ressources,
-      continue : function parseWholeMPL(loadedRessources : Manifest[]) {
-        const parsedManifest = createManifest(metaPlaylist,
-                                              loadedRessources,
-                                              parserOptions);
-        return { type: "done", value: parsedManifest };
-      },
-    },
-  };
-}
-
-/**
- * From several parsed manifests, generate a single bigger manifest.
- * Each content presents a start and end time, so that periods
- * boudaries could be adapted.
- * @param {Object} mplData
- * @param {Array<Object>} manifest
- * @param {string} url
- * @returns {Object}
- */
-function createManifest(
-  mplData : IMetaPlaylist,
-  manifests : Manifest[],
-  parserOptions:  { url?: string | undefined;
-                    serverSyncInfos?: { serverTimestamp: number;
-                                        clientTime: number; } | undefined; }
-): IParsedManifest {
-  const { url, serverSyncInfos } = parserOptions;
-  const clockOffset = serverSyncInfos !== undefined ?
-    serverSyncInfos.serverTimestamp - serverSyncInfos.clientTime :
-    undefined;
-  const generateAdaptationID = idGenerator();
-  const generateRepresentationID = idGenerator();
-  const { contents } = mplData;
-  const minimumTime = contents.length > 0 ? contents[0].startTime :
-                                            0;
-  const maximumTime = contents.length > 0 ? contents[contents.length - 1].endTime :
-                                            0;
-  const isDynamic = mplData.dynamic === true;
-
-  let firstStart: number|null = null;
-  let lastEnd: number|null = null;
-
-  const periods : IParsedPeriod[] = [];
-  for (let iMan = 0; iMan < contents.length; iMan++) {
-    const content = contents[iMan];
-    firstStart = firstStart !== null ? Math.min(firstStart, content.startTime) :
-                                       content.startTime;
-    lastEnd = lastEnd !== null ? Math.max(lastEnd, content.endTime) :
-                                 content.endTime;
-    const currentManifest = manifests[iMan];
-    if (currentManifest.periods.length <= 0) {
-      continue;
-    }
-    const contentOffset = content.startTime - currentManifest.periods[0].start;
-    const contentEnd = content.endTime;
-
-    const manifestPeriods = [];
-    for (let iPer = 0; iPer < currentManifest.periods.length; iPer++) {
-      const currentPeriod = currentManifest.periods[iPer];
-      const adaptations = SUPPORTED_ADAPTATIONS_TYPE
-        .reduce<IParsedAdaptations>((acc, type : IAdaptationType) => {
-          const currentAdaptations = currentPeriod.adaptations[type];
-          if (currentAdaptations == null) {
-            return acc;
-          }
-
-          const adaptationsForCurrentType : IParsedAdaptation[] = [];
-          for (let iAda = 0; iAda < currentAdaptations.length; iAda++) {
-            const currentAdaptation = currentAdaptations[iAda];
-
-            const representations : IParsedRepresentation[] = [];
-            for (let iRep = 0; iRep < currentAdaptation.representations.length; iRep++) {
-              const currentRepresentation = currentAdaptation.representations[iRep];
-
-              const contentInfos = {
-                manifest: currentManifest,
-                period: currentPeriod,
-                adaptation: currentAdaptation,
-                representation: currentRepresentation,
-              };
-
-              const newIndex = new MetaRepresentationIndex(currentRepresentation.index,
-                                                           [contentOffset, contentEnd],
-                                                           content.transport,
-                                                           contentInfos);
-              representations.push({
-                bitrate: currentRepresentation.bitrate,
-                index: newIndex,
-                cdnMetadata: currentRepresentation.cdnMetadata,
-                id: currentRepresentation.id,
-                height: currentRepresentation.height,
-                width: currentRepresentation.width,
-                mimeType: currentRepresentation.mimeType,
-                frameRate: currentRepresentation.frameRate,
-                codecs: currentRepresentation.codec,
-                isSpatialAudio: currentRepresentation.isSpatialAudio,
-                contentProtections: currentRepresentation.contentProtections,
-              });
-            }
-            adaptationsForCurrentType.push({
-              id: currentAdaptation.id,
-              representations,
-              type: currentAdaptation.type,
-              audioDescription: currentAdaptation.isAudioDescription,
-              closedCaption: currentAdaptation.isClosedCaption,
-              isDub: currentAdaptation.isDub,
-              language: currentAdaptation.language,
-              isSignInterpreted: currentAdaptation.isSignInterpreted,
-            });
-            acc[type] = adaptationsForCurrentType;
-          }
-          return acc;
-        }, {});
-
-      // TODO only first period?
-      const textTracks : IMetaPlaylistTextTrack[] =
-        content.textTracks === undefined ? [] :
-                                           content.textTracks;
-      const newTextAdaptations : IParsedAdaptation[] = textTracks.map((track) => {
-        const adaptationID = "gen-text-ada-" + generateAdaptationID();
-        const representationID = "gen-text-rep-" + generateRepresentationID();
-        const indexOfFilename = getFilenameIndexInUrl(track.url);
-        const cdnUrl = track.url.substring(0, indexOfFilename);
-        const filename = track.url.substring(indexOfFilename);
-        return {
-          id: adaptationID,
-          type: "text",
-          language: track.language,
-          closedCaption: track.closedCaption,
-          manuallyAdded: true,
-          representations: [
-            { bitrate: 0,
-              cdnMetadata: [{ baseUrl: cdnUrl }],
-              id: representationID,
-              mimeType: track.mimeType,
-              codecs: track.codecs,
-              index: new StaticRepresentationIndex({ media: filename }),
-            },
-          ],
-        };
-      }, []);
-
-      if (newTextAdaptations.length > 0) {
-        if (adaptations.text == null) {
-          adaptations.text = newTextAdaptations;
-        } else {
-          adaptations.text.push(...newTextAdaptations);
-        }
-      }
-
-      const newPeriod : IParsedPeriod = {
-        id: formatId(currentManifest.id) + "_" + formatId(currentPeriod.id),
-        adaptations,
-        duration: currentPeriod.duration,
-        start: contentOffset + currentPeriod.start,
-      };
-      manifestPeriods.push(newPeriod);
-    }
-
-    for (let i = manifestPeriods.length - 1; i >= 0; i--) {
-      const period = manifestPeriods[i];
-      if (period.start >= content.endTime) {
-        manifestPeriods.splice(i, 1);
-      } else if (period.duration != null) {
-        if (period.start + period.duration > content.endTime) {
-          period.duration = content.endTime - period.start;
-        }
-      } else if (i === manifestPeriods.length - 1) {
-        period.duration = content.endTime - period.start;
-      }
-    }
-    periods.push(...manifestPeriods);
-  }
-
-  const time = performance.now();
-  const isLastPeriodKnown = !isDynamic ||
-                            mplData.pollInterval === undefined &&
-                            (manifests.length <= 0 ||
-                             manifests[manifests.length - 1].isLastPeriodKnown);
-  const manifest = { availabilityStartTime: 0,
-                     clockOffset,
-                     suggestedPresentationDelay: 10,
-                     periods,
-                     transportType: "metaplaylist",
-                     isLive: isDynamic,
-                     isDynamic,
-                     isLastPeriodKnown,
-                     uris: url == null ? [] :
-                                         [url],
-
-                     // TODO more precize time bounds?
-                     timeBounds: { minimumSafePosition: minimumTime,
-                                   timeshiftDepth: null,
-                                   maximumTimeData: {
-                                     isLinear: false,
-                                     maximumSafePosition: maximumTime,
-                                     livePosition: undefined,
-                                     time,
-                                   } },
-                     lifetime: mplData.pollInterval };
-
-  return manifest;
-}
-
-function formatId(str : string) {
-  return str.replace(/_/g, "\_");
-}

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

@@ -1,251 +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 {
-  IBaseContentInfos,
-  IRepresentationIndex,
-  ISegment,
-} from "../../../manifest";
-import { IPlayerError } from "../../../public_types";
-import objectAssign from "../../../utils/object_assign";
-
-/**
- * The MetaRepresentationIndex is wrapper for all kind of RepresentationIndex (from
- * dash, smooth, etc)
- *
- * It wraps methods from original RepresentationIndex, while taking into account
- * the time offset introduced by the MetaPlaylist content.
- *
- * It makes a bridge between the MetaPlaylist timeline, and the original
- * timeline of content. (e.g. the segment whose "meta" time is 1500, is actually a
- * segment whose original time is 200, played with an offset of 1300)
- * @class MetaRepresentationIndex
- */
-export default class MetaRepresentationIndex implements IRepresentationIndex {
-  /** Real underlying RepresentationIndex implementation. */
-  protected _wrappedIndex : IRepresentationIndex;
-  /** Offset time to add to the start of the Representation, in seconds. */
-  private _timeOffset : number;
-  /** Absolute end of the Representation, in the seconds. */
-  private _contentEnd : number | undefined;
-  /** Underlying transport for the Representation (e.g. "dash" or "smooth"). */
-  private _transport : string;
-  /** Various information about the real underlying Representation. */
-  private _baseContentInfos : IBaseContentInfos;
-
-  /**
-   * Create a new `MetaRepresentationIndex`.
-   * @param {Object} wrappedIndex - "Real" RepresentationIndex implementation of
-   * the concerned Representation.
-   * @param {Array.<number|undefined>} contentBounds - Start time and end time
-   * the Representation will be played between, in seconds.
-   * @param {string} transport - Transport for the "real" RepresentationIndex
-   * (e.g. "dash" or "smooth").
-   * @param {Object} baseContentInfos - Various information about the "real"
-   * Representation.
-   */
-  constructor(
-    wrappedIndex: IRepresentationIndex,
-    contentBounds: [number, number|undefined],
-    transport: string,
-    baseContentInfos: IBaseContentInfos
-  ) {
-    this._wrappedIndex = wrappedIndex;
-    this._timeOffset = contentBounds[0];
-    this._contentEnd = contentBounds[1];
-    this._transport = transport;
-    this._baseContentInfos = baseContentInfos;
-  }
-
-  /**
-   * Returns information about the initialization segment.
-   */
-  public getInitSegment() : ISegment | null {
-    const segment = this._wrappedIndex.getInitSegment();
-    if (segment === null) {
-      return null;
-    }
-    return this._cloneWithPrivateInfos(segment);
-  }
-
-  /**
-   * Returns information about the segments asked.
-   * @param {number} up - Starting time wanted, in seconds.
-   * @param {Number} duration - Amount of time wanted, in seconds
-   * @returns {Array.<Object>}
-   */
-  public getSegments(up : number, duration : number) : ISegment[] {
-    return this._wrappedIndex.getSegments(up - this._timeOffset, duration)
-      .map((segment) => {
-        const clonedSegment = this._cloneWithPrivateInfos(segment);
-        clonedSegment.time += this._timeOffset;
-        clonedSegment.end += this._timeOffset;
-        return clonedSegment;
-      });
-  }
-
-  /**
-   * Whether this RepresentationIndex should be refreshed now.
-   * Returns `false` as MetaPlaylist contents do not support underlying live
-   * contents yet.
-   * @returns {Boolean}
-   */
-  public shouldRefresh() : false {
-    return false;
-  }
-
-  /**
-   * Returns first possible position the first segment plays at, in seconds.
-   * `undefined` if we do not know this value.
-   * @return {Number|undefined}
-   */
-  public getFirstAvailablePosition(): number|undefined {
-    const wrappedFirstPosition = this._wrappedIndex.getFirstAvailablePosition();
-    return wrappedFirstPosition != null ? wrappedFirstPosition + this._timeOffset :
-                                          undefined;
-  }
-
-  /**
-   * Returns last possible position the last segment plays at, in seconds.
-   * `undefined` if we do not know this value.
-   * @return {Number|undefined}
-   */
-  public getLastAvailablePosition(): number|undefined {
-    const wrappedLastPosition = this._wrappedIndex.getLastAvailablePosition();
-    return wrappedLastPosition != null ? wrappedLastPosition + this._timeOffset :
-                                         undefined;
-  }
-
-  /**
-   * Returns the absolute end in seconds this RepresentationIndex can reach once
-   * all segments are available.
-   * @returns {number|null|undefined}
-   */
-  public getEnd(): number|undefined|null {
-    const wrappedEnd = this._wrappedIndex.getEnd();
-    return wrappedEnd != null ? wrappedEnd + this._timeOffset :
-                                undefined;
-  }
-
-  /**
-   * 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}
-   */
-  public awaitSegmentBetween(start: number, end: number): boolean | undefined {
-    return this._wrappedIndex.awaitSegmentBetween(start - this._timeOffset,
-                                                  end - this._timeOffset);
-  }
-
-  /**
-   * Returns `false` if that segment is not currently available in the Manifest
-   * (e.g. it corresponds to a segment which is before the current buffer
-   * depth).
-   * @param {Object} segment
-   * @returns {boolean|undefined}
-   */
-  public isSegmentStillAvailable(segment : ISegment) : boolean | undefined {
-    if (segment.privateInfos?.metaplaylistInfos === undefined) {
-      return false;
-    }
-    const { originalSegment } = segment.privateInfos.metaplaylistInfos;
-    return this._wrappedIndex.isSegmentStillAvailable(originalSegment);
-  }
-
-  /**
-   * @param {Error} error
-   * @param {Object} segment
-   * @returns {Boolean}
-   */
-  public canBeOutOfSyncError(error : IPlayerError, segment : ISegment) : boolean {
-    if (segment.privateInfos?.metaplaylistInfos === undefined) {
-      return false;
-    }
-    const { originalSegment } = segment.privateInfos.metaplaylistInfos;
-    return this._wrappedIndex.canBeOutOfSyncError(error, originalSegment);
-  }
-
-  /**
-   *
-   * @param {Number} time
-   * @returns {Number | null}
-   */
-  public checkDiscontinuity(time: number): number | null {
-    return this._wrappedIndex.checkDiscontinuity(time - this._timeOffset);
-  }
-
-  /**
-   * @returns {Boolean}
-   */
-  public isStillAwaitingFutureSegments() : boolean {
-    return this._wrappedIndex.isStillAwaitingFutureSegments();
-  }
-
-  /**
-   * @returns {Boolean}
-   */
-  public isInitialized() : boolean {
-    return this._wrappedIndex.isInitialized();
-  }
-
-  /**
-   * @param {Object} newIndex
-   */
-  public _replace(newIndex : IRepresentationIndex): void {
-    if (!(newIndex instanceof MetaRepresentationIndex)) {
-      throw new Error("A MetaPlaylist can only be replaced with another MetaPlaylist");
-    }
-    this._wrappedIndex._replace(newIndex._wrappedIndex);
-  }
-
-  /**
-   * @param {Object} newIndex
-   */
-  public _update(newIndex : IRepresentationIndex): void {
-    if (!(newIndex instanceof MetaRepresentationIndex)) {
-      throw new Error("A MetaPlaylist can only be updated with another MetaPlaylist");
-    }
-    this._wrappedIndex._update(newIndex._wrappedIndex);
-  }
-
-  /**
-   * Clone the given segment, presumably coming from its original
-   * RepresentationIndex, and add the linked metaplaylist privateInfos to it.
-   * Return that cloned and enhanced segment.
-   * @param {Object} segment
-   * @returns {Object}
-   */
-  private _cloneWithPrivateInfos(segment : ISegment) : ISegment {
-    const clonedSegment = objectAssign({}, segment);
-    if (clonedSegment.privateInfos === undefined) {
-      clonedSegment.privateInfos = {};
-    }
-    clonedSegment.privateInfos.metaplaylistInfos = {
-      transportType: this._transport,
-      baseContent: this._baseContentInfos,
-      contentStart: this._timeOffset,
-      contentEnd: this._contentEnd,
-      originalSegment: segment,
-    };
-    return clonedSegment;
-  }
-}