rx-player 3.26.1 → 3.26.2

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/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

@@ -161,6 +161,8 @@ export interface IPeriodAttributes {
    */
   duration? : number;
   bitstreamSwitching? : boolean;
+  availabilityTimeComplete?: boolean;
+  availabilityTimeOffset?: number;
   xlinkHref? : string;
   xlinkActuate? : string;
 
@@ -230,6 +232,8 @@ export interface IAdaptationSetAttributes {
   segmentProfiles? : string;
   subsegmentAlignment? : number|boolean;
   width? : number;
+  availabilityTimeComplete?: boolean;
+  availabilityTimeOffset?: number;
 }
 
 export interface IRepresentationIntermediateRepresentation {
@@ -242,6 +246,7 @@ export interface IRepresentationChildren {
   baseURLs : IBaseUrlIntermediateRepresentation[];
 
   // optional
+  contentProtections? : IContentProtectionIntermediateRepresentation[];
   inbandEventStreams? : IScheme[];
   segmentBase? : ISegmentBaseIntermediateRepresentation;
   segmentList? : ISegmentListIntermediateRepresentation;
@@ -264,6 +269,8 @@ export interface IRepresentationAttributes {
   qualityRanking? : number;
   segmentProfiles? : string;
   width? : number;
+  availabilityTimeComplete?: boolean;
+  availabilityTimeOffset?: number;
 }
 
 export interface ISegmentBaseIntermediateRepresentation {
@@ -364,6 +371,7 @@ export interface IBaseUrlIntermediateRepresentation {
   attributes: {
     /** availabilityTimeOffset attribute assiociated to that BaseURL node. */
     availabilityTimeOffset?: number;
+    availabilityTimeComplete?: boolean;
   };
 }
 

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

@@ -61,6 +61,10 @@ 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> {
   /**
@@ -80,6 +84,8 @@ export interface ILoadedResource<T extends string | ArrayBuffer> {
    * `undefined` if unknown or not applicable.
    */
   receivedTime? : number;
-  /** The loaded resource itself, under the right format. */
-  responseData : T;
+  /** The loaded resource itself, under the right format.
+   * Or an error, when fetching ressources.
+   */
+  responseData : IResponseData<T>;
 }

package/src/parsers/manifest/dash/wasm-parser/rs/lib.rs

@@ -81,12 +81,5 @@ extern "C" {
 pub extern "C" fn parse() {
     let buf_read = BufReader::new(MPDReader {});
     let mut processor = MPDProcessor::new(buf_read);
-    processor.process_document();
-}
-
-#[no_mangle]
-pub extern "C" fn parse_xlink() {
-    let buf_read = BufReader::new(MPDReader {});
-    let mut processor = MPDProcessor::new(buf_read);
-    processor.process_xlink();
+    processor.process_tags();
 }

package/src/parsers/manifest/dash/wasm-parser/rs/processor/attributes.rs

@@ -44,6 +44,10 @@ pub fn report_period_attrs(tag_bs : &quick_xml::events::BytesStart) {
                 b"start" => Start.try_report_as_iso_8601_duration(&attr),
                 b"duration" => Duration.try_report_as_iso_8601_duration(&attr),
                 b"bitstreamSwitching" => BitstreamSwitching.try_report_as_bool(&attr),
+                b"availabilityTimeOffset" => match attr.value.as_ref() {
+                    b"INF" => AvailabilityTimeOffset.report(f64::INFINITY),
+                    _ => AvailabilityTimeOffset.try_report_as_u64(&attr),
+                },
                 b"xlink:href" => XLinkHref.try_report_as_string(&attr),
                 b"xlink:actuate" => XLinkActuate.try_report_as_string(&attr),
                 x => {
@@ -90,6 +94,12 @@ pub fn report_adaptation_set_attrs(e : &quick_xml::events::BytesStart) {
                 b"width" => Width.try_report_as_u64(&attr),
                 b"maxPlayoutRate" => MaxPlayoutRate.try_report_as_f64(&attr),
                 b"maxSAPPeriod" => MaxSAPPeriod.try_report_as_f64(&attr),
+                b"availabilityTimeOffset" => match attr.value.as_ref() {
+                    b"INF" => AvailabilityTimeOffset.report(f64::INFINITY),
+                    _ => AvailabilityTimeOffset.try_report_as_u64(&attr),
+                },
+                b"availabilityTimeComplete" =>
+                    AvailabilityTimeComplete.try_report_as_bool(&attr),
                 _ => {},
             },
             Err(err) => ParsingError::from(err).report_err(),
@@ -115,6 +125,12 @@ pub fn report_representation_attrs(tag_bs : &quick_xml::events::BytesStart) {
                 b"profiles" => Profiles.try_report_as_string(&attr),
                 b"qualityRanking" => QualityRanking.try_report_as_u64(&attr),
                 b"segmentProfiles" => SegmentProfiles.try_report_as_string(&attr),
+                b"availabilityTimeOffset" => match attr.value.as_ref() {
+                    b"INF" => AvailabilityTimeOffset.report(f64::INFINITY),
+                    _ => AvailabilityTimeOffset.try_report_as_u64(&attr),
+                },
+                b"availabilityTimeComplete" =>
+                    AvailabilityTimeComplete.try_report_as_bool(&attr),
                 _ => {},
             },
             Err(err) => ParsingError::from(err).report_err(),
@@ -125,11 +141,16 @@ pub fn report_representation_attrs(tag_bs : &quick_xml::events::BytesStart) {
 pub fn report_base_url_attrs(tag_bs : &quick_xml::events::BytesStart) {
     for res_attr in tag_bs.attributes() {
         match res_attr {
-            Ok(attr) => if let b"availabilityTimeOffset" = attr.key {
-                match attr.value.as_ref() {
-                    b"INF" => AvailabilityTimeOffset.report(f64::INFINITY),
-                    _ => AvailabilityTimeOffset.try_report_as_u64(&attr),
-                }
+            Ok(attr) => match attr.key {
+                b"availabilityTimeOffset" => {
+                    match attr.value.as_ref() {
+                        b"INF" => AvailabilityTimeOffset.report(f64::INFINITY),
+                        _ => AvailabilityTimeOffset.try_report_as_u64(&attr),
+                    }
+                },
+                b"availabilityTimeComplete" =>
+                    AvailabilityTimeComplete.try_report_as_bool(&attr),
+                _ => {},
             },
             Err(err) => ParsingError::from(err).report_err(),
         };