rx-player 3.26.2 → 3.27.0-dev.20220317

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

@@ -26,14 +26,13 @@ import {
 import {
   IAdaptationSetIntermediateRepresentation,
   IRepresentationIntermediateRepresentation,
-  ISegmentTemplateIntermediateRepresentation,
   IScheme,
   IContentProtectionIntermediateRepresentation,
 } from "../node_parser_types";
 import { getWEBMHDRInformation } from "./get_hdr_information";
-import ManifestBoundsCalculator from "./manifest_bounds_calculator";
-import parseRepresentationIndex from "./parse_representation_index";
-import { IResolvedBaseUrl } from "./resolve_base_urls";
+import parseRepresentationIndex, {
+  IRepresentationIndexContext,
+} from "./parse_representation_index";
 
 /**
  * Combine inband event streams from representation and
@@ -59,49 +58,6 @@ function combineInbandEventStreams(
   return newSchemeId;
 }
 
-/** Supplementary context needed to parse a Representation. */
-export interface IAdaptationInfos {
-  /** Whether we should request new segments even if they are not yet finished. */
-  aggressiveMode : boolean;
-  availabilityTimeComplete: boolean;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset: number;
-  /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : IResolvedBaseUrl[];
-  /** Allows to obtain the first/last available position of a dynamic content. */
-  manifestBoundsCalculator : ManifestBoundsCalculator;
-  /** End time of the current period, in seconds. */
-  end? : number;
-  /** Whether the Manifest can evolve with time. */
-  isDynamic : boolean;
-  /** Manifest DASH profiles used for signalling some features */
-  manifestProfiles?: string;
-  /**
-   * Parent parsed SegmentTemplate elements.
-   * Sorted by provenance from higher level (e.g. Period) to lower-lever (e.g.
-   * AdaptationSet).
-   */
-  parentSegmentTemplates : ISegmentTemplateIntermediateRepresentation[];
-  /**
-   * Time (in terms of `performance.now`) at which the XML file containing this
-   * Representation was received.
-   */
-  receivedTime? : number;
-  /** Start time of the current period, in seconds. */
-  start : number;
-  /** Depth of the buffer for the whole content, in seconds. */
-  timeShiftBufferDepth? : number;
-  /**
-   * The parser should take this Adaptation - which is from a previously parsed
-   * Manifest for the same dynamic content - as a base to speed-up the parsing
-   * process.
-   * /!\ If unexpected differences exist between both, there is a risk of
-   * de-synchronization with what is actually on the server,
-   * Use with moderation.
-   */
-  unsafelyBaseOnPreviousAdaptation : Adaptation | null;
-}
-
 /**
  * Extract HDR information from manifest and codecs.
  * @param {Object}
@@ -111,9 +67,9 @@ function getHDRInformation(
   { adaptationProfiles,
     manifestProfiles,
     codecs,
-  }: { adaptationProfiles?: string;
-       manifestProfiles?: string;
-       codecs?: string; }
+  }: { adaptationProfiles?: string | undefined;
+       manifestProfiles?: string | undefined;
+       codecs?: string | undefined; }
 ): undefined | IHDRInformation {
   const profiles = (adaptationProfiles ?? "") + (manifestProfiles ?? "");
   if (codecs === undefined) {
@@ -138,13 +94,13 @@ function getHDRInformation(
 /**
  * Process intermediate representations to create final parsed representations.
  * @param {Array.<Object>} representationsIR
- * @param {Object} adaptationInfos
+ * @param {Object} context
  * @returns {Array.<Object>}
  */
 export default function parseRepresentations(
   representationsIR : IRepresentationIntermediateRepresentation[],
   adaptation : IAdaptationSetIntermediateRepresentation,
-  adaptationInfos : IAdaptationInfos
+  context : IRepresentationContext
 ): IParsedRepresentation[] {
   const parsedRepresentations : IParsedRepresentation[] = [];
   for (const representation of representationsIR) {
@@ -171,7 +127,7 @@ export default function parseRepresentations(
     }
 
     // Retrieve previous version of the Representation, if one.
-    const unsafelyBaseOnPreviousRepresentation = adaptationInfos
+    const unsafelyBaseOnPreviousRepresentation = context
       .unsafelyBaseOnPreviousAdaptation?.getRepresentation(representationID) ??
       null;
 
@@ -180,18 +136,19 @@ export default function parseRepresentations(
 
     const availabilityTimeComplete =
       representation.attributes.availabilityTimeComplete ??
-      adaptationInfos.availabilityTimeComplete;
+      context.availabilityTimeComplete;
     const availabilityTimeOffset =
       (representation.attributes.availabilityTimeOffset ?? 0) +
-      adaptationInfos.availabilityTimeOffset;
-    const representationInfos = objectAssign({}, adaptationInfos,
-                                             { availabilityTimeOffset,
-                                               availabilityTimeComplete,
-                                               unsafelyBaseOnPreviousRepresentation,
-                                               adaptation,
-                                               inbandEventStreams });
+      context.availabilityTimeOffset;
+    const reprIndexCtxt = objectAssign({},
+                                       context,
+                                       { availabilityTimeOffset,
+                                         availabilityTimeComplete,
+                                         unsafelyBaseOnPreviousRepresentation,
+                                         adaptation,
+                                         inbandEventStreams });
     const representationIndex = parseRepresentationIndex(representation,
-                                                         representationInfos);
+                                                         reprIndexCtxt);
 
     // Find bitrate
     let representationBitrate : number;
@@ -297,10 +254,34 @@ export default function parseRepresentations(
 
     parsedRepresentation.hdrInfo =
       getHDRInformation({ adaptationProfiles: adaptation.attributes.profiles,
-                          manifestProfiles: adaptationInfos.manifestProfiles,
+                          manifestProfiles: context.manifestProfiles,
                           codecs });
 
     parsedRepresentations.push(parsedRepresentation);
   }
   return parsedRepresentations;
 }
+
+/** Supplementary context needed to parse a Representation. */
+export interface IRepresentationContext extends IInheritedRepresentationIndexContext {
+  /** Manifest DASH profiles used for signalling some features */
+  manifestProfiles?: string | undefined;
+  /**
+   * The parser should take this Adaptation - which is from a previously parsed
+   * Manifest for the same dynamic content - as a base to speed-up the parsing
+   * process.
+   * /!\ If unexpected differences exist between both, there is a risk of
+   * de-synchronization with what is actually on the server,
+   * Use with moderation.
+   */
+  unsafelyBaseOnPreviousAdaptation : Adaptation | null;
+}
+
+/**
+ * Supplementary context needed to parse a Representation common with
+ * `IRepresentationIndexContext`.
+ */
+type IInheritedRepresentationIndexContext = Omit<IRepresentationIndexContext,
+                                                 "adaptation" |
+                                                 "unsafelyBaseOnPreviousRepresentation" |
+                                                 "inbandEventStreams">;

package/src/parsers/manifest/dash/node_parser_types.ts

@@ -131,7 +131,7 @@ export interface IPeriodChildren {
   /**
    * Provide a template with which we will be able to request segments.
    */
-  segmentTemplate? : ISegmentTemplateIntermediateRepresentation;
+  segmentTemplate? : ISegmentTemplateIntermediateRepresentation | undefined;
   /**
    * Allows to signal events linked to this Period.
    *
@@ -189,17 +189,17 @@ export interface IAdaptationSetChildren {
   representations : IRepresentationIntermediateRepresentation[];
 
   // optional
-  accessibilities? : IScheme[];
-  contentComponent? : IContentComponentAttributes;
-  contentProtections? : IContentProtectionIntermediateRepresentation[];
-  essentialProperties? : IScheme[];
-  inbandEventStreams? : IScheme[];
+  accessibilities? : IScheme[] | undefined;
+  contentComponent? : IContentComponentAttributes | undefined;
+  contentProtections? : IContentProtectionIntermediateRepresentation[] | undefined;
+  essentialProperties? : IScheme[] | undefined;
+  inbandEventStreams? : IScheme[] | undefined;
   roles? : IScheme[];
-  supplementalProperties? : IScheme[];
+  supplementalProperties? : IScheme[] | undefined;
 
-  segmentBase? : ISegmentBaseIntermediateRepresentation;
-  segmentList? : ISegmentListIntermediateRepresentation;
-  segmentTemplate? : ISegmentTemplateIntermediateRepresentation;
+  segmentBase? : ISegmentBaseIntermediateRepresentation | undefined;
+  segmentList? : ISegmentListIntermediateRepresentation | undefined;
+  segmentTemplate? : ISegmentTemplateIntermediateRepresentation | undefined;
 }
 
 /* Intermediate representation for An AdaptationSet node's attributes. */
@@ -336,20 +336,20 @@ export interface IContentProtectionAttributes {
 }
 
 export interface ISegmentTemplateIntermediateRepresentation {
-  availabilityTimeComplete? : boolean;
-  availabilityTimeOffset?: number;
-  bitstreamSwitching? : boolean;
-  duration? : number;
-  index? : string;
-  indexRange?: [number, number];
-  indexRangeExact? : boolean;
-  media? : string;
-  presentationTimeOffset? : number;
-  startNumber? : number;
-  timescale? : number;
-  initialization? : { media?: string };
-  timeline? : ISegmentTimelineElement[];
-  timelineParser? : ITimelineParser;
+  availabilityTimeComplete? : boolean | undefined;
+  availabilityTimeOffset? : number | undefined;
+  bitstreamSwitching? : boolean | undefined;
+  duration? : number | undefined;
+  index? : string | undefined;
+  indexRange?: [number, number] | undefined;
+  indexRangeExact? : boolean | undefined;
+  media? : string | undefined;
+  presentationTimeOffset? : number | undefined;
+  startNumber? : number | undefined;
+  timescale? : number | undefined;
+  initialization? : { media?: string } | undefined;
+  timeline? : ISegmentTimelineElement[] | undefined;
+  timelineParser? : ITimelineParser | undefined;
 }
 
 export interface ISegmentTimelineElement {
@@ -382,9 +382,9 @@ export interface IScheme {
    *
    * `undefined` if no `schemeIdUri` attribute has been found.
    */
-  schemeIdUri? : string;
+  schemeIdUri? : string | undefined;
   /** Inner content of that scheme. */
-  value? : string;
+  value? : string | undefined;
 }
 
 export interface IEventStreamIntermediateRepresentation {
@@ -395,9 +395,9 @@ export interface IEventStreamIntermediateRepresentation {
 }
 
 export interface IEventStreamAttributes {
-  schemeIdUri? : string;
-  timescale? : number;
-  value? : string;
+  schemeIdUri? : string | undefined;
+  timescale? : number | undefined;
+  value? : string | undefined;
 
   /**
    * XML namespaces linked to the `<EventStream>` element.
@@ -406,7 +406,7 @@ export interface IEventStreamAttributes {
    * not parsed through the browser's DOMParser API, and thus might depend on
    * parent namespaces to be parsed correctly.
    */
-  namespaces? : Array<{ key: string; value: string }>;
+  namespaces? : Array<{ key: string; value: string }> | undefined;
 }
 
 export interface IEventStreamChildren {

package/src/parsers/manifest/dash/parsers_types.ts

@@ -71,19 +71,19 @@ export interface ILoadedResource<T extends string | ArrayBuffer> {
    * The URL of the loaded resource (post-redirection if one).
    * `undefined` if unknown or inexistant.
    */
-  url? : string;
+  url? : string | undefined;
   /**
    * The time, in terms of `performance.now()`, at which the resource was
    * starting to be fetched.
    * `undefined` if unknown or not applicable.
    */
-  sendingTime? : number;
+  sendingTime? : number | undefined;
   /**
    * The time, in terms of `performance.now()`, at which the resource was
    * fully-fetched.
    * `undefined` if unknown or not applicable.
    */
-  receivedTime? : number;
+  receivedTime? : number | undefined;
   /** The loaded resource itself, under the right format.
    * Or an error, when fetching ressources.
    */

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import log from "../../../../../log";
 import assertUnreachable from "../../../../../utils/assert_unreachable";
 import noop from "../../../../../utils/noop";
+import PPromise from "../../../../../utils/promise";
 import parseMpdIr, {
   IIrParserResponse,
   ILoadedXlinkData,

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

@@ -69,11 +69,11 @@ export interface IMetaPlaylist {
 export default function parseMetaPlaylist(
   data : unknown,
   parserOptions : {
-    url?: string;
+    url?: string | undefined;
     serverSyncInfos?: {
       serverTimestamp: number;
       clientTime: number;
-    };
+    } | undefined;
   }
 ): IParserResponse<IParsedManifest> {
   let parsedData;
@@ -147,9 +147,9 @@ export default function parseMetaPlaylist(
 function createManifest(
   mplData : IMetaPlaylist,
   manifests : Manifest[],
-  parserOptions:  { url?: string;
+  parserOptions:  { url?: string | undefined;
                     serverSyncInfos?: { serverTimestamp: number;
-                                        clientTime: number; }; }
+                                        clientTime: number; } | undefined; }
 ): IParsedManifest {
   const { url, serverSyncInfos } = parserOptions;
   const clockOffset = serverSyncInfos !== undefined ?

package/src/parsers/manifest/smooth/create_parser.ts

@@ -64,8 +64,8 @@ interface IAdaptationParserArguments { root : Element;
                                        timescale : number;
                                        protections : IContentProtectionSmooth[];
                                        isLive : boolean;
-                                       timeShiftBufferDepth? : number;
-                                       manifestReceivedTime? : number; }
+                                       timeShiftBufferDepth? : number | undefined;
+                                       manifestReceivedTime? : number | undefined; }
 
 type IAdaptationType = "audio" |
                        "video" |
@@ -83,18 +83,19 @@ const MIME_TYPES : Partial<Record<string, string>> = {
   AVC1: "video/mp4",
   H264: "video/mp4",
   TTML: "application/ttml+xml+mp4",
+  DFXP: "application/ttml+xml+mp4",
 };
 
 export interface IHSSParserConfiguration {
-  aggressiveMode? : boolean;
-  suggestedPresentationDelay? : number;
-  referenceDateTime? : number;
-  minRepresentationBitrate? : number;
-  keySystems? : (hex? : Uint8Array) => IKeySystem[];
+  aggressiveMode? : boolean | undefined;
+  suggestedPresentationDelay? : number | undefined;
+  referenceDateTime? : number | undefined;
+  minRepresentationBitrate? : number | undefined;
+  keySystems? : ((hex : Uint8Array | undefined) => IKeySystem[]) | undefined;
   serverSyncInfos? : {
     serverTimestamp: number;
     clientTime: number;
-  };
+  } | undefined;
 }
 
 interface ISmoothParsedQualityLevel {
@@ -104,16 +105,16 @@ interface ISmoothParsedQualityLevel {
   customAttributes : string[];
 
   // optional
-  audiotag? : number;
-  bitsPerSample? : number;
-  channels? : number;
-  codecs? : string;
-  height? : number;
-  id? : string;
-  mimeType? : string;
-  packetSize? : number;
-  samplingRate? : number;
-  width? : number;
+  audiotag? : number | undefined;
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  codecs? : string | undefined;
+  height? : number | undefined;
+  id? : string | undefined;
+  mimeType? : string | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  width? : number | undefined;
 }
 
 /**
@@ -122,9 +123,11 @@ interface ISmoothParsedQualityLevel {
  */
 function createSmoothStreamingParser(
   parserOptions : IHSSParserConfiguration = {}
-) : (manifest : Document, url? : string, manifestReceivedTime? : number)
-  => IParsedManifest
-{
+) : (
+    manifest : Document,
+    url? : string | undefined,
+    manifestReceivedTime? : number | undefined
+  ) => IParsedManifest {
   const referenceDateTime = parserOptions.referenceDateTime === undefined ?
     Date.UTC(1970, 0, 1, 0, 0, 0, 0) / 1000 :
     parserOptions.referenceDateTime;

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

@@ -178,12 +178,12 @@ export interface ISmoothRepresentationIndexContextInformation {
 
 /** Information allowing to generate a Smooth initialization segment. */
 interface ISmoothInitSegmentPrivateInfos {
-  bitsPerSample? : number;
-  channels? : number;
-  codecPrivateData? : string;
-  packetSize? : number;
-  samplingRate? : number;
-  protection? : { keyId : Uint8Array };
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  codecPrivateData? : string | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  protection? : { keyId : Uint8Array } | undefined;
 }
 
 /**
@@ -198,13 +198,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Information needed to generate an initialization segment.
    * Taken from the Manifest.
    */
-  private _initSegmentInfos : { codecPrivateData? : string;
-                                bitsPerSample? : number;
-                                channels? : number;
-                                packetSize? : number;
-                                samplingRate? : number;
+  private _initSegmentInfos : { codecPrivateData? : string | undefined;
+                                bitsPerSample? : number | undefined;
+                                channels? : number | undefined;
+                                packetSize? : number | undefined;
+                                samplingRate? : number | undefined;
                                 timescale : number;
-                                protection? : { keyId : Uint8Array }; };
+                                protection? : { keyId : Uint8Array } | undefined; };
 
   /**
    * if `true`, this class will return segments even if we're not sure they had
@@ -225,13 +225,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Useful to know if a segment present in the timeline has actually been
    * generated on the server-side
    */
-  private _scaledLiveGap? : number;
+  private _scaledLiveGap : number | undefined;
 
   /**
    * Defines the end of the latest available segment when this index was known to
    * be valid, in the index's timescale.
    */
-  private _initialScaledLastPosition? : number;
+  private _initialScaledLastPosition : number | undefined;
 
   /**
    * Defines the earliest time when this index was known to be valid (that is, when

package/src/parsers/manifest/types.ts

@@ -18,8 +18,8 @@ import { IRepresentationIndex } from "../../manifest";
 import { IHDRInformation } from "../../manifest/types";
 
 export interface IManifestStreamEvent { start: number;
-                                        end?: number;
-                                        id?: string;
+                                        end?: number | undefined;
+                                        id?: string | undefined;
                                         data: IParsedStreamEventData; }
 
 export interface IParsedStreamEventData {
@@ -33,7 +33,7 @@ export interface IParsedStreamEventData {
 
 /** Describes information about an encryption Key ID of a given media. */
 export interface IContentProtectionKID { keyId : Uint8Array;
-                                         systemId?: string; }
+                                         systemId?: string | undefined; }
 
 /**
  * Encryption initialization data.
@@ -92,37 +92,37 @@ export interface IParsedRepresentation {
   id: string;
 
   /** Codec(s) associated with this Representation. */
-  codecs?: string;
+  codecs?: string | undefined;
   /**
    * Information about the encryption associated with this Representation.
    * Not set if unknown or if the content is not encrypted.
    */
-  contentProtections? : IContentProtections;
+  contentProtections? : IContentProtections | undefined;
   /**
    * Frame rate (images per seconds) associated with this Representation.
    * Not set if unknown or if it makes no sense (e.g. for subtitles).
    */
-  frameRate?: string;
+  frameRate?: string | undefined;
   /**
    * Height (top to bottom) in pixels this Representation has.
    * Not set if unknown or if it makes no sense (e.g. for audio).
    */
-  height?: number;
+  height?: number | undefined;
   /**
    * Defines the mime-type of the content.
    * This allows to deduce the media container but most of the time, the
    * `codecs` will also be needed to know how to decode that media.
    */
-  mimeType?: string;
+  mimeType?: string | undefined;
   /**
    * Width (left to right) in pixels this Representation has.
    * Not set if unknown or if it makes no sense (e.g. for audio).
    */
-  width?: number;
+  width?: number | undefined;
   /**
    * Information about the HDR characteristic of a content.
    */
-  hdrInfo?: IHDRInformation;
+  hdrInfo?: IHDRInformation | undefined;
 }
 
 /** Every possible types an Adaptation can have. */
@@ -155,34 +155,34 @@ export interface IParsedAdaptation {
    * Not set if unknown or if it makes no sense for the current track (e.g. for
    * a video track).
    */
-  audioDescription? : boolean;
+  audioDescription? : boolean | undefined;
   /**
    * Whether this Adaptation are closed captions for the hard of hearing.
    * Not set if unknown or if it makes no sense for the current track (e.g. for
    * a video track).
    */
-  closedCaption? : boolean;
+  closedCaption? : boolean | undefined;
   /**
    * If true this Adaptation is in a dub: it was recorded in another language
    * than the original(s) one(s).
    */
-  isDub? : boolean;
+  isDub? : boolean | undefined;
   /**
    * If true this Adaptation is in a sign interpreted: which is a variant of the
    * video with sign language.
    */
-  isSignInterpreted? : boolean;
+  isSignInterpreted? : boolean | undefined;
   /** Tells if the track is a trick mode track. */
-  isTrickModeTrack? : boolean;
+  isTrickModeTrack? : boolean | undefined;
   /**
    * Language the `Adaptation` is in.
    * Not set if unknown or if it makes no sense for the current track.
    */
-  language?: string;
+  language?: string | undefined;
   /**
    * TrickMode tracks attached to the adaptation.
    */
-  trickModeTracks?: IParsedAdaptation[];
+  trickModeTracks?: IParsedAdaptation[] | undefined;
 }
 
 /** Information on a given period of time in the Manifest */
@@ -205,18 +205,18 @@ export interface IParsedPeriod {
    * Duration of the Period (from the start to the end), in seconds.
    * `undefined` if the Period is the last one and is still being updated.
    */
-  duration? : number;
+  duration? : number | undefined;
   /**
    * Time at which the Period ends, in seconds.
    * `undefined` if the Period is the last one and is still
    * being updated.
    */
-  end? : number;
+  end? : number | undefined;
   /**
    * Array containing every stream event from period in manifest.
    * `undefined` if no parsed stream event in manifest.
    */
-  streamEvents?: IManifestStreamEvent[];
+  streamEvents?: IManifestStreamEvent[] | undefined;
 }
 
 /** Information on the whole content */
@@ -240,23 +240,23 @@ export interface IParsedManifest {
    * The wall-clock time when the manifest was generated and published at the
    * origin server
    */
-  publishTime?: number;
+  publishTime? : number | undefined;
   /** Underlying transport protocol: "smooth", "dash", "metaplaylist" etc. */
   transportType: string;
   /** Base time from which the segments are generated. */
-  availabilityStartTime? : number;
+  availabilityStartTime? : number | undefined;
   /**
    * Offset, in milliseconds, the client's clock (in terms of `performance.now`)
    * has relatively to the server's
    */
-  clockOffset?: number;
+  clockOffset? : number | undefined;
   /** If set, the Manifest needs to be updated when that Promise resolves. */
-  expired? : Promise<void>;
+  expired? : Promise<void> | undefined;
   /**
    * Duration of the validity of this Manifest from its download time.
    * After that time has elapsed, the Manifest should be refreshed.
    */
-  lifetime?: number;
+  lifetime? : number | undefined;
   /**
    * Data allowing to calculate the minimum and maximum seekable positions at
    * any given time.
@@ -266,7 +266,7 @@ export interface IParsedManifest {
      * The minimum time, in seconds, available in this Manifest.
      * `undefined` if that value is unknown.
      */
-    absoluteMinimumTime? : number;
+    absoluteMinimumTime? : number | undefined;
     /**
      * Some dynamic contents have the concept of a "window depth" (or "buffer
      * depth") which allows to set a minimum position for all reachable
@@ -311,8 +311,8 @@ export interface IParsedManifest {
    * Suggested delay from the last position the player should start from by
    * default.
    */
-  suggestedPresentationDelay? : number;
+  suggestedPresentationDelay? : number | undefined;
   /** URIs where the manifest can be refreshed by order of importance. */
-  uris?: string[];
+  uris? : string[] | undefined;
 }