rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -26,12 +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 parseRepresentationIndex, {
+  IRepresentationIndexContext,
+} from "./parse_representation_index";
 
 /**
  * Combine inband event streams from representation and
@@ -57,48 +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;
-  /** availability time offset of the concerned Adaptation. */
-  availabilityTimeOffset: number;
-  /** Eventual URLs from which every relative URL will be based on. */
-  baseURLs : string[];
-  /** 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}
@@ -108,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) {
@@ -135,18 +94,16 @@ 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 (let reprIdx = 0; reprIdx < representationsIR.length; reprIdx++) {
-    const representation = representationsIR[reprIdx];
-
+  for (const representation of representationsIR) {
     // Compute Representation ID
     let representationID = representation.attributes.id != null ?
       representation.attributes.id :
@@ -170,19 +127,28 @@ export default function parseRepresentations(
     }
 
     // Retrieve previous version of the Representation, if one.
-    const unsafelyBaseOnPreviousRepresentation = adaptationInfos
+    const unsafelyBaseOnPreviousRepresentation = context
       .unsafelyBaseOnPreviousAdaptation?.getRepresentation(representationID) ??
       null;
 
     const inbandEventStreams =
       combineInbandEventStreams(representation, adaptation);
 
-    const representationInfos = objectAssign({}, adaptationInfos,
-                                             { unsafelyBaseOnPreviousRepresentation,
-                                               adaptation,
-                                               inbandEventStreams });
+    const availabilityTimeComplete =
+      representation.attributes.availabilityTimeComplete ??
+      context.availabilityTimeComplete;
+    const availabilityTimeOffset =
+      (representation.attributes.availabilityTimeOffset ?? 0) +
+      context.availabilityTimeOffset;
+    const reprIndexCtxt = objectAssign({},
+                                       context,
+                                       { availabilityTimeOffset,
+                                         availabilityTimeComplete,
+                                         unsafelyBaseOnPreviousRepresentation,
+                                         adaptation,
+                                         inbandEventStreams });
     const representationIndex = parseRepresentationIndex(representation,
-                                                         representationInfos);
+                                                         reprIndexCtxt);
 
     // Find bitrate
     let representationBitrate : number;
@@ -239,8 +205,16 @@ export default function parseRepresentations(
         adaptation.attributes.width;
     }
 
-    if (adaptation.children.contentProtections != null) {
-      const contentProtections = adaptation.children.contentProtections
+    const contentProtectionsIr : IContentProtectionIntermediateRepresentation[] =
+      adaptation.children.contentProtections !== undefined ?
+        adaptation.children.contentProtections :
+        [];
+    if (representation.children.contentProtections !== undefined) {
+      contentProtectionsIr.push(...representation.children.contentProtections);
+    }
+
+    if (contentProtectionsIr.length > 0) {
+      const contentProtections = contentProtectionsIr
         .reduce<IContentProtections>((acc, cp) => {
           let systemId : string|undefined;
           if (cp.attributes.schemeIdUri !== undefined &&
@@ -257,8 +231,7 @@ export default function parseRepresentations(
             const { cencPssh } = cp.children;
             const values : Array<{ systemId: string;
                                    data: Uint8Array; }> = [];
-            for (let i = 0; i < cencPssh.length; i++) {
-              const data = cencPssh[i];
+            for (const data of cencPssh) {
               values.push({ systemId, data });
             }
             if (values.length > 0) {
@@ -281,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/common/resolve_base_urls.ts

@@ -14,39 +14,48 @@
  * limitations under the License.
  */
 
-import arrayIncludes from "../../../../utils/array_includes";
 import resolveURL from "../../../../utils/resolve_url";
 import { IBaseUrlIntermediateRepresentation } from "../node_parser_types";
 
+export interface IResolvedBaseUrl {
+  url : string;
+  availabilityTimeOffset : number;
+  availabilityTimeComplete : boolean;
+}
+
 /**
  * @param {Array.<string>} currentBaseURLs
- * @param {Array.<Object>} newBaseURLs
+ * @param {Array.<Object>} newBaseUrlsIR
  * @returns {Array.<string>}
  */
 export default function resolveBaseURLs(
-  currentBaseURLs : string[],
-  newBaseURLs : IBaseUrlIntermediateRepresentation[]
-) : string[] {
-  const result : string[] = [];
-  if (newBaseURLs.length === 0) {
+  currentBaseURLs : IResolvedBaseUrl[],
+  newBaseUrlsIR : IBaseUrlIntermediateRepresentation[]
+) : IResolvedBaseUrl[] {
+  if (newBaseUrlsIR.length === 0) {
     return currentBaseURLs;
-  } else if (currentBaseURLs.length === 0) {
-    for (let i = 0; i < newBaseURLs.length; i++) {
-      if (!arrayIncludes(result, newBaseURLs[i].value)) {
-        result.push(newBaseURLs[i].value);
-      }
-    }
-    return result;
-  } else {
-    for (let i = 0; i < currentBaseURLs.length; i++) {
-      const rootURL = currentBaseURLs[i];
-      for (let j = 0; j < newBaseURLs.length; j++) {
-        const newURL = resolveURL(rootURL,
-                                  newBaseURLs[j].value);
-        if (!arrayIncludes(result, newURL)) {
-          result.push(newURL);
-        }
-      }
+  }
+
+  const newBaseUrls : IResolvedBaseUrl[] = newBaseUrlsIR.map(ir => {
+    return { url: ir.value,
+             availabilityTimeOffset: ir.attributes.availabilityTimeOffset ?? 0,
+             availabilityTimeComplete: ir.attributes.availabilityTimeComplete ?? true };
+  });
+  if (currentBaseURLs.length === 0) {
+    return newBaseUrls;
+  }
+
+  const result : IResolvedBaseUrl[] = [];
+  for (let i = 0; i < currentBaseURLs.length; i++) {
+    const curBaseUrl = currentBaseURLs[i];
+    for (let j = 0; j < newBaseUrls.length; j++) {
+      const newBaseUrl = newBaseUrls[j];
+      const newUrl = resolveURL(curBaseUrl.url, newBaseUrl.url);
+      const newAvailabilityTimeOffset = curBaseUrl.availabilityTimeOffset +
+        newBaseUrl.availabilityTimeOffset;
+      result.push({ url: newUrl,
+                    availabilityTimeOffset: newAvailabilityTimeOffset,
+                    availabilityTimeComplete: newBaseUrl.availabilityTimeComplete });
     }
   }
   return result;

package/src/parsers/manifest/dash/js-parser/__tests__/parse_from_document.test.ts

@@ -34,7 +34,7 @@ describe("parseFromDocument", () => {
       });
     }).toThrow("document root should be MPD");
     expect(function() {
-      const prevManifest = {} as any as Manifest;
+      const prevManifest = {} as unknown as Manifest;
       parseFromDocument(doc, {
         url: "",
         aggressiveMode: false,

package/src/parsers/manifest/dash/js-parser/node_parsers/AdaptationSet.ts

@@ -333,6 +333,18 @@ function parseAdaptationSetAttributes(
                                       parser: parseMPDInteger,
                                       dashName: "width" });
         break;
+
+      case "availabilityTimeOffset":
+        parseValue(attribute.value, { asKey: "availabilityTimeOffset",
+                                      parser: parseMPDFloat,
+                                      dashName: "availabilityTimeOffset" });
+        break;
+
+      case "availabilityTimeComplete":
+        parseValue(attribute.value, { asKey: "availabilityTimeComplete",
+                                      parser: parseBoolean,
+                                      dashName: "availabilityTimeComplete" });
+        break;
     }
   }
 

package/src/parsers/manifest/dash/js-parser/node_parsers/BaseURL.ts

@@ -16,7 +16,8 @@
 
 import { IBaseUrlIntermediateRepresentation } from "../../node_parser_types";
 import {
-  parseMPDInteger,
+  parseBoolean,
+  parseMPDFloat,
   ValueParser,
 } from "./utils";
 
@@ -29,7 +30,8 @@ import {
 export default function parseBaseURL(
   root: Element
 ) : [IBaseUrlIntermediateRepresentation | undefined, Error[]] {
-  const attributes : { availabilityTimeOffset?: number } = {};
+  const attributes : { availabilityTimeOffset?: number;
+                       availabilityTimeComplete?: boolean; } = {};
   const value = root.textContent;
 
   const warnings : Error[] = [];
@@ -42,13 +44,15 @@ export default function parseBaseURL(
 
     switch (attribute.name) {
       case "availabilityTimeOffset":
-        if (attribute.value === "INF") {
-          attributes.availabilityTimeOffset = Infinity;
-        } else {
-          parseValue(attribute.value, { asKey: "availabilityTimeOffset",
-                                        parser: parseMPDInteger,
-                                        dashName: "availabilityTimeOffset" });
-        }
+        parseValue(attribute.value, { asKey: "availabilityTimeOffset",
+                                      parser: parseMPDFloat,
+                                      dashName: "availabilityTimeOffset" });
+        break;
+
+      case "availabilityTimeComplete":
+        parseValue(attribute.value, { asKey: "availabilityTimeComplete",
+                                      parser: parseBoolean,
+                                      dashName: "availabilityTimeComplete" });
         break;
     }
   }

package/src/parsers/manifest/dash/js-parser/node_parsers/Representation.ts

@@ -20,6 +20,7 @@ import {
   IRepresentationIntermediateRepresentation,
 } from "../../node_parser_types";
 import parseBaseURL from "./BaseURL";
+import parseContentProtection from "./ContentProtection";
 import parseSegmentBase from "./SegmentBase";
 import parseSegmentList from "./SegmentList";
 import parseSegmentTemplate from "./SegmentTemplate";
@@ -42,6 +43,7 @@ function parseRepresentationChildren(
   const children : IRepresentationChildren = {
     baseURLs: [],
   };
+  const contentProtections = [];
 
   let warnings : Error[] = [];
   for (let i = 0; i < representationChildren.length; i++) {
@@ -80,9 +82,23 @@ function parseRepresentationChildren(
           warnings = warnings.concat(segmentTemplateWarnings);
           children.segmentTemplate = segmentTemplate;
           break;
+
+        case "ContentProtection":
+          const [ contentProtection,
+                  contentProtectionWarnings ] = parseContentProtection(currentElement);
+          if (contentProtectionWarnings.length > 0) {
+            warnings = warnings.concat(contentProtectionWarnings);
+          }
+          if (contentProtection !== undefined) {
+            contentProtections.push(contentProtection);
+          }
+          break;
       }
     }
   }
+  if (contentProtections.length > 0) {
+    children.contentProtections = contentProtections;
+  }
   return [children, warnings];
 }
 
@@ -170,6 +186,18 @@ function parseRepresentationAttributes(
                                  parser: parseMPDInteger,
                                  dashName: "width" });
         break;
+
+      case "availabilityTimeOffset":
+        parseValue(attr.value, { asKey: "availabilityTimeOffset",
+                                 parser: parseMPDFloat,
+                                 dashName: "availabilityTimeOffset" });
+        break;
+
+      case "availabilityTimeComplete":
+        parseValue(attr.value, { asKey: "availabilityTimeComplete",
+                                 parser: parseBoolean,
+                                 dashName: "availabilityTimeComplete" });
+        break;
     }
   }
   if (attributes.bitrate === undefined) {

package/src/parsers/manifest/dash/js-parser/node_parsers/SegmentTemplate.ts

@@ -23,7 +23,7 @@ import parseSegmentBase from "./SegmentBase";
 import createSegmentTimelineParser from "./SegmentTimeline";
 import {
   parseBoolean,
-  parseMPDInteger,
+  parseMPDFloat,
   ValueParser,
 } from "./utils";
 
@@ -71,14 +71,17 @@ export default function parseSegmentTemplate(
         break;
 
       case "availabilityTimeOffset":
-        if (attribute.value === "INF") {
-          ret.availabilityTimeOffset = Infinity;
-        }
         parseValue(attribute.value, { asKey: "availabilityTimeOffset",
-                                      parser: parseMPDInteger,
+                                      parser: parseMPDFloat,
                                       dashName: "availabilityTimeOffset" });
         break;
 
+      case "availabilityTimeComplete":
+        parseValue(attribute.value, { asKey: "availabilityTimeComplete",
+                                      parser: parseBoolean,
+                                      dashName: "availabilityTimeComplete" });
+        break;
+
       case "media":
         ret.media = attribute.value;
         break;

package/src/parsers/manifest/dash/js-parser/node_parsers/utils.ts

@@ -106,6 +106,9 @@ function parseMPDFloat(
 ) : [number | null,
      MPDError | null]
 {
+  if (val === "INF") {
+    return [Infinity, null];
+  }
   const toInt = parseFloat(val);
   if (isNaN(toInt)) {
     const error = new MPDError(

package/src/parsers/manifest/dash/js-parser/parse_from_document.ts

@@ -88,11 +88,14 @@ export default function parseFromDocument(
           ) : IDashParserResponse<string> {
             const resourceInfos : ILoadedXlinkData[] = [];
             for (let i = 0; i < loadedXlinks.length; i++) {
-              const { responseData: xlinkData,
+              const { responseData: xlinkResp,
                       receivedTime,
                       sendingTime,
                       url } = loadedXlinks[i];
-              const wrappedData = "<root>" + xlinkData + "</root>";
+              if (!xlinkResp.success) {
+                throw xlinkResp.error;
+              }
+              const wrappedData = "<root>" + xlinkResp.data + "</root>";
               const dataAsXML = new DOMParser().parseFromString(wrappedData, "text/xml");
               if (dataAsXML == null || dataAsXML.children.length === 0) {
                 throw new Error("DASH parser: Invalid external ressources");

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

@@ -92,6 +92,16 @@ export interface IMPDAttributes {
   suggestedPresentationDelay? : number;
   maxSegmentDuration? : number;
   maxSubsegmentDuration? : number;
+
+  /**
+   * XML namespaces linked to the `<MPD>` element.
+   *
+   * This property is only needed when the EventStream's `<Event>` elements are
+   * 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; }>;
 }
 
 /** Intermediate representation of an encountered Period node. */
@@ -121,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.
    *
@@ -151,8 +161,20 @@ export interface IPeriodAttributes {
    */
   duration? : number;
   bitstreamSwitching? : boolean;
+  availabilityTimeComplete?: boolean;
+  availabilityTimeOffset?: number;
   xlinkHref? : string;
   xlinkActuate? : string;
+
+  /**
+   * XML namespaces linked to the `<Period>` element.
+   *
+   * This property is only needed when the EventStream's `<Event>` elements are
+   * 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; }>;
 }
 
 /** AdaptationSet once parsed into its intermediate representation. */
@@ -167,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. */
@@ -210,6 +232,8 @@ export interface IAdaptationSetAttributes {
   segmentProfiles? : string;
   subsegmentAlignment? : number|boolean;
   width? : number;
+  availabilityTimeComplete?: boolean;
+  availabilityTimeOffset?: number;
 }
 
 export interface IRepresentationIntermediateRepresentation {
@@ -222,6 +246,7 @@ export interface IRepresentationChildren {
   baseURLs : IBaseUrlIntermediateRepresentation[];
 
   // optional
+  contentProtections? : IContentProtectionIntermediateRepresentation[];
   inbandEventStreams? : IScheme[];
   segmentBase? : ISegmentBaseIntermediateRepresentation;
   segmentList? : ISegmentListIntermediateRepresentation;
@@ -244,6 +269,8 @@ export interface IRepresentationAttributes {
   qualityRanking? : number;
   segmentProfiles? : string;
   width? : number;
+  availabilityTimeComplete?: boolean;
+  availabilityTimeOffset?: number;
 }
 
 export interface ISegmentBaseIntermediateRepresentation {
@@ -309,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 {
@@ -344,6 +371,7 @@ export interface IBaseUrlIntermediateRepresentation {
   attributes: {
     /** availabilityTimeOffset attribute assiociated to that BaseURL node. */
     availabilityTimeOffset?: number;
+    availabilityTimeComplete?: boolean;
   };
 }
 
@@ -354,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 {
@@ -367,9 +395,18 @@ 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.
+   *
+   * This property is only needed when the EventStream's `<Event>` elements are
+   * 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 }> | undefined;
 }
 
 export interface IEventStreamChildren {

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

@@ -61,25 +61,31 @@ export interface IDashParserNeedsResources<T extends string | ArrayBuffer> {
   };
 }
 
+export type IResponseData<T> =
+  { success: true; data: T } |
+  { success: false; error: Error };
+
 /** Format a loaded resource should take. */
 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;
-  /** The loaded resource itself, under the right format. */
-  responseData : T;
+  receivedTime? : number | undefined;
+  /** The loaded resource itself, under the right format.
+   * Or an error, when fetching ressources.
+   */
+  responseData : IResponseData<T>;
 }