rx-player 3.33.0 → 3.33.1

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

@@ -1,381 +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 {
-  IAdaptationSetAttributes,
-  IAdaptationSetChildren,
-  IAdaptationSetIntermediateRepresentation,
-} from "../../node_parser_types";
-import parseBaseURL from "./BaseURL";
-import parseContentComponent from "./ContentComponent";
-import parseContentProtection from "./ContentProtection";
-import {
-  createRepresentationIntermediateRepresentation,
-} from "./Representation";
-import parseSegmentBase from "./SegmentBase";
-import parseSegmentList from "./SegmentList";
-import parseSegmentTemplate from "./SegmentTemplate";
-import {
-  parseBoolean,
-  parseIntOrBoolean,
-  parseMPDFloat,
-  parseMPDInteger,
-  parseScheme,
-  ValueParser,
-} from "./utils";
-
-/**
- * Parse child nodes from an AdaptationSet.
- * @param {NodeList} adaptationSetChildren - The AdaptationSet child nodes.
- * @returns {Array.<Object>}
- */
-function parseAdaptationSetChildren(
-  adaptationSetChildren : NodeList
-) : [IAdaptationSetChildren, Error[]] {
-  const children : IAdaptationSetChildren = {
-    baseURLs: [],
-    representations: [],
-  };
-  const contentProtections = [];
-  let warnings : Error[] = [];
-  for (let i = 0; i < adaptationSetChildren.length; i++) {
-    if (adaptationSetChildren[i].nodeType === Node.ELEMENT_NODE) {
-      const currentElement = adaptationSetChildren[i] as Element;
-
-      switch (currentElement.nodeName) {
-
-        case "Accessibility":
-          if (children.accessibilities === undefined) {
-            children.accessibilities = [parseScheme(currentElement)];
-          } else {
-            children.accessibilities.push(parseScheme(currentElement));
-          }
-          break;
-
-        case "BaseURL":
-          const [baseURLObj, baseURLWarnings] = parseBaseURL(currentElement);
-          if (baseURLObj !== undefined) {
-            children.baseURLs.push(baseURLObj);
-          }
-          if (baseURLWarnings.length > 0) {
-            warnings = warnings.concat(baseURLWarnings);
-          }
-          break;
-
-        case "ContentComponent":
-          children.contentComponent = parseContentComponent(currentElement);
-          break;
-
-        case "EssentialProperty":
-          if (children.essentialProperties == null) {
-            children.essentialProperties = [parseScheme(currentElement)];
-          } else {
-            children.essentialProperties.push(parseScheme(currentElement));
-          }
-          break;
-
-        case "InbandEventStream":
-          if (children.inbandEventStreams === undefined) {
-            children.inbandEventStreams = [];
-          }
-          children.inbandEventStreams.push(parseScheme(currentElement));
-          break;
-
-        case "Label":
-          const label = currentElement.textContent;
-
-          if (label !== null && label !== undefined) {
-            children.label = label;
-          }
-          break;
-
-        case "Representation":
-          const [representation, representationWarnings] =
-            createRepresentationIntermediateRepresentation(currentElement);
-          children.representations.push(representation);
-          if (representationWarnings.length > 0) {
-            warnings = warnings.concat(representationWarnings);
-          }
-          break;
-
-        case "Role":
-          if (children.roles == null) {
-            children.roles = [parseScheme(currentElement)];
-          } else {
-            children.roles.push(parseScheme(currentElement));
-          }
-          break;
-
-        case "SupplementalProperty":
-          if (children.supplementalProperties == null) {
-            children.supplementalProperties = [parseScheme(currentElement)];
-          } else {
-            children.supplementalProperties.push(parseScheme(currentElement));
-          }
-          break;
-
-        case "SegmentBase":
-          const [segmentBase, segmentBaseWarnings] = parseSegmentBase(currentElement);
-          children.segmentBase = segmentBase;
-          if (segmentBaseWarnings.length > 0) {
-            warnings = warnings.concat(segmentBaseWarnings);
-          }
-          break;
-
-        case "SegmentList":
-          const [segmentList, segmentListWarnings] = parseSegmentList(currentElement);
-          children.segmentList = segmentList;
-          if (segmentListWarnings.length > 0) {
-            warnings = warnings.concat(segmentListWarnings);
-          }
-          break;
-
-        case "SegmentTemplate":
-          const [segmentTemplate, segmentTemplateWarnings] =
-            parseSegmentTemplate(currentElement);
-          children.segmentTemplate = segmentTemplate;
-          if (segmentTemplateWarnings.length > 0) {
-            warnings = warnings.concat(segmentTemplateWarnings);
-          }
-          break;
-
-        case "ContentProtection":
-          const [ contentProtection,
-                  contentProtectionWarnings ] = parseContentProtection(currentElement);
-          if (contentProtectionWarnings.length > 0) {
-            warnings = warnings.concat(contentProtectionWarnings);
-          }
-          if (contentProtection !== undefined) {
-            contentProtections.push(contentProtection);
-          }
-          break;
-
-          // case "Rating":
-          //   children.rating = currentElement;
-          //   break;
-
-          // case "Viewpoint":
-          //   children.viewpoint = currentElement;
-          //   break;
-      }
-    }
-  }
-  if (contentProtections.length > 0) {
-    children.contentProtections = contentProtections;
-  }
-  return [children, warnings];
-}
-
-/**
- * Parse every attributes from an AdaptationSet root element into a simple JS
- * object.
- * @param {Element} root - The AdaptationSet root element.
- * @returns {Array.<Object>}
- */
-function parseAdaptationSetAttributes(
-  root : Element
-) : [IAdaptationSetAttributes, Error[]] {
-  const parsedAdaptation : IAdaptationSetAttributes = {};
-  const warnings : Error[] = [];
-  const parseValue = ValueParser(parsedAdaptation, warnings);
-
-  for (let i = 0; i < root.attributes.length; i++) {
-    const attribute = root.attributes[i];
-
-    switch (attribute.name) {
-
-      case "id":
-        parsedAdaptation.id = attribute.value;
-        break;
-
-      case "group":
-        parseValue(attribute.value, { asKey: "group",
-                                      parser: parseMPDInteger,
-                                      dashName: "group" });
-        break;
-
-      case "lang":
-        parsedAdaptation.language = attribute.value;
-        break;
-
-      case "contentType":
-        parsedAdaptation.contentType = attribute.value;
-        break;
-
-      case "par":
-        parsedAdaptation.par = attribute.value;
-        break;
-
-      case "minBandwidth":
-        parseValue(attribute.value, { asKey: "minBitrate",
-                                      parser: parseMPDInteger,
-                                      dashName: "minBandwidth" });
-        break;
-
-      case "maxBandwidth":
-        parseValue(attribute.value, { asKey: "maxBitrate",
-                                      parser: parseMPDInteger,
-                                      dashName: "maxBandwidth" });
-        break;
-
-      case "minWidth":
-        parseValue(attribute.value, { asKey: "minWidth",
-                                      parser: parseMPDInteger,
-                                      dashName: "minWidth" });
-        break;
-
-      case "maxWidth":
-        parseValue(attribute.value, { asKey: "maxWidth",
-                                      parser: parseMPDInteger,
-                                      dashName: "maxWidth" });
-        break;
-
-      case "minHeight":
-        parseValue(attribute.value, { asKey: "minHeight",
-                                      parser: parseMPDInteger,
-                                      dashName: "minHeight" });
-        break;
-
-      case "maxHeight":
-        parseValue(attribute.value, { asKey: "maxHeight",
-                                      parser: parseMPDInteger,
-                                      dashName: "maxHeight" });
-        break;
-
-      case "minFrameRate": {
-        parsedAdaptation.minFrameRate = attribute.value;
-      }
-        break;
-
-      case "maxFrameRate":
-        parsedAdaptation.maxFrameRate = attribute.value;
-        break;
-
-      case "selectionPriority":
-        parseValue(attribute.value, { asKey: "selectionPriority",
-                                      parser: parseMPDInteger,
-                                      dashName: "selectionPriority" });
-        break;
-
-      case "segmentAlignment":
-        parseValue(attribute.value, { asKey: "segmentAlignment",
-                                      parser: parseIntOrBoolean,
-                                      dashName: "segmentAlignment" });
-        break;
-
-      case "subsegmentAlignment":
-        parseValue(attribute.value, { asKey: "subsegmentAlignment",
-                                      parser: parseIntOrBoolean,
-                                      dashName: "subsegmentAlignment" });
-        break;
-
-      case "bitstreamSwitching":
-        parseValue(attribute.value, { asKey: "bitstreamSwitching",
-                                      parser: parseBoolean,
-                                      dashName: "bitstreamSwitching" });
-        break;
-
-      case "audioSamplingRate":
-        parsedAdaptation.audioSamplingRate = attribute.value;
-        break;
-
-      case "codecs":
-        parsedAdaptation.codecs = attribute.value;
-        break;
-
-      case "scte214:supplementalCodecs":
-        parsedAdaptation.supplementalCodecs = attribute.value;
-        break;
-
-      case "codingDependency":
-        parseValue(attribute.value, { asKey: "codingDependency",
-                                      parser: parseBoolean,
-                                      dashName: "codingDependency" });
-        break;
-
-      case "frameRate":
-        parsedAdaptation.frameRate = attribute.value;
-        break;
-
-      case "height":
-        parseValue(attribute.value, { asKey: "height",
-                                      parser: parseMPDInteger,
-                                      dashName: "height" });
-        break;
-
-      case "maxPlayoutRate":
-        parseValue(attribute.value, { asKey: "maxPlayoutRate",
-                                      parser: parseMPDFloat,
-                                      dashName: "maxPlayoutRate" });
-        break;
-
-      case "maximumSAPPeriod":
-        parseValue(attribute.value, { asKey: "maximumSAPPeriod",
-                                      parser: parseMPDFloat,
-                                      dashName: "maximumSAPPeriod" });
-        break;
-
-      case "mimeType":
-        parsedAdaptation.mimeType = attribute.value;
-        break;
-
-      case "profiles":
-        parsedAdaptation.profiles = attribute.value;
-        break;
-
-      case "segmentProfiles":
-        parsedAdaptation.segmentProfiles = attribute.value;
-        break;
-
-      case "width":
-        parseValue(attribute.value, { asKey: "width",
-                                      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;
-    }
-  }
-
-  return [parsedAdaptation, warnings];
-}
-
-/**
- * Parse an AdaptationSet element into an AdaptationSet intermediate
- * representation.
- * @param {Element} adaptationSetElement - The AdaptationSet root element.
- * @returns {Array.<Object>}
- */
-export function createAdaptationSetIntermediateRepresentation(
-  adaptationSetElement : Element
-) : [IAdaptationSetIntermediateRepresentation, Error[]] {
-  const childNodes = adaptationSetElement.childNodes;
-  const [ children, childrenWarnings ] = parseAdaptationSetChildren(childNodes);
-  const [ attributes, attrsWarnings ] =
-    parseAdaptationSetAttributes(adaptationSetElement);
-  const warnings = childrenWarnings.concat(attrsWarnings);
-  return [{ children, attributes }, warnings];
-}

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

@@ -1,35 +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 { IBaseUrlIntermediateRepresentation } from "../../node_parser_types";
-
-/**
- * Parse an BaseURL element into an BaseURL intermediate
- * representation.
- * @param {Element} root - The BaseURL root element.
- * @returns {Array.<Object|undefined>}
- */
-export default function parseBaseURL(
-  root: Element
-) : [IBaseUrlIntermediateRepresentation | undefined, Error[]] {
-  const value = root.textContent;
-  const warnings : Error[] = [];
-  if (value === null || value.length === 0) {
-    return [undefined, warnings];
-  }
-  return [ { value },
-           warnings ];
-}

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

@@ -1,49 +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 { IContentComponentAttributes } from "../../node_parser_types";
-
-/**
- * Parse a "ContentComponent" Element in a DASH MPD.
- * @param {Element} root
- * @returns {Object}
- */
-export default function parseContentComponent(
-  root: Element
-) : IContentComponentAttributes {
-  const ret : IContentComponentAttributes = {};
-
-  for (let i = 0; i < root.attributes.length; i++) {
-    const attribute = root.attributes[i];
-
-    switch (attribute.name) {
-      case "id":
-        ret.id = attribute.value;
-        break;
-      case "lang":
-        ret.language = attribute.value;
-        break;
-      case "contentType":
-        ret.contentType = attribute.value;
-        break;
-      case "par":
-        ret.par = attribute.value;
-        break;
-    }
-  }
-
-  return ret;
-}

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

@@ -1,94 +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 { hexToBytes } from "../../../../../utils/string_parsing";
-import {
-  IContentProtectionAttributes,
-  IContentProtectionChildren,
-  IContentProtectionIntermediateRepresentation,
-} from "../../node_parser_types";
-import { parseBase64 } from "./utils";
-
-/**
- * @param {NodeList} contentProtectionChildren
- * @Returns {Object}
- */
-function parseContentProtectionChildren(
-  contentProtectionChildren : NodeList
-) : [IContentProtectionChildren, Error[]] {
-  const warnings : Error[] = [];
-  const cencPssh : Uint8Array[] = [];
-  for (let i = 0; i < contentProtectionChildren.length; i++) {
-    if (contentProtectionChildren[i].nodeType === Node.ELEMENT_NODE) {
-      const currentElement = contentProtectionChildren[i] as Element;
-      if (currentElement.nodeName === "cenc:pssh") {
-        const content = currentElement.textContent;
-        if (content !== null && content.length > 0) {
-          const [ toUint8Array,
-                  error ] = parseBase64(content, "cenc:pssh");
-          if (error !== null) {
-            log.warn(error.message);
-            warnings.push(error);
-          }
-          if (toUint8Array !== null) {
-            cencPssh.push(toUint8Array);
-          }
-        }
-      }
-    }
-  }
-  return [{ cencPssh }, warnings];
-}
-
-/**
- * @param {Element} root
- * @returns {Object}
- */
-function parseContentProtectionAttributes(
-  root: Element
-) : IContentProtectionAttributes {
-  const ret : IContentProtectionAttributes = {};
-  for (let i = 0; i < root.attributes.length; i++) {
-    const attribute = root.attributes[i];
-
-    switch (attribute.name) {
-      case "schemeIdUri":
-        ret.schemeIdUri = attribute.value;
-        break;
-      case "value":
-        ret.value = attribute.value;
-        break;
-      case "cenc:default_KID":
-        ret.keyId = hexToBytes(attribute.value.replace(/-/g, ""));
-    }
-  }
-
-  return ret;
-}
-
-/**
- * @param {Element} contentProtectionElement
- * @returns {Object}
- */
-export default function parseContentProtection(
-  contentProtectionElement : Element
-) : [IContentProtectionIntermediateRepresentation, Error[]] {
-  const [ children, childrenWarnings ] =
-    parseContentProtectionChildren(contentProtectionElement.childNodes);
-  const attributes = parseContentProtectionAttributes(contentProtectionElement);
-  return [ { children, attributes }, childrenWarnings ];
-}

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

@@ -1,117 +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 {
-  IEventStreamEventIntermediateRepresentation,
-  IEventStreamIntermediateRepresentation,
-} from "../../node_parser_types";
-import {
-  parseMPDInteger,
-  ValueParser,
-} from "./utils";
-
-/**
- * Parse the EventStream node to extract Event nodes and their
- * content.
- * @param {Element} element
- * @returns {Array}
- */
-export default function parseEventStream(
-  element: Element
-): [IEventStreamIntermediateRepresentation, Error[]] {
-  const eventStreamIR: IEventStreamIntermediateRepresentation = {
-    children: { events : [] },
-    attributes: {},
-  };
-  let warnings: Error[] = [];
-
-  // 1 - Parse attributes
-  const parseValue = ValueParser(eventStreamIR.attributes, warnings);
-  for (let i = 0; i < element.attributes.length; i++) {
-    const attr = element.attributes[i];
-    switch (attr.name) {
-
-      case "schemeIdUri":
-        eventStreamIR.attributes.schemeIdUri = attr.value;
-        break;
-
-      case "timescale":
-        parseValue(attr.value, { asKey: "timescale",
-                                 parser: parseMPDInteger,
-                                 dashName: "timescale" });
-        break;
-
-      case "value":
-        eventStreamIR.attributes.value = attr.value;
-        break;
-    }
-  }
-
-  for (let i = 0; i < element.childNodes.length; i++) {
-    if (element.childNodes[i].nodeType === Node.ELEMENT_NODE) {
-      const currentElement = element.childNodes[i] as Element;
-
-      switch (currentElement.nodeName) {
-
-        case "Event":
-          const [event, eventWarnings] = parseEvent(currentElement);
-          eventStreamIR.children.events.push(event);
-          if (eventWarnings.length > 0) {
-            warnings = warnings.concat(eventWarnings);
-          }
-          break;
-      }
-    }
-  }
-
-  return [eventStreamIR, warnings];
-}
-
-/**
- * Parse `Event` Element, as found in EventStream nodes.
- * @param {Element} element
- * @returns {Array}
- */
-function parseEvent(
-  element: Element
-): [IEventStreamEventIntermediateRepresentation, Error[]] {
-  const eventIR: IEventStreamEventIntermediateRepresentation = {
-    eventStreamData : element,
-  };
-  const warnings : Error[] = [];
-
-  // 1 - Parse attributes
-  const parseValue = ValueParser(eventIR, warnings);
-  for (let i = 0; i < element.attributes.length; i++) {
-    const attr = element.attributes[i];
-    switch (attr.name) {
-      case "presentationTime":
-        parseValue(attr.value, { asKey: "presentationTime",
-                                 parser: parseMPDInteger,
-                                 dashName: "presentationTime" });
-        break;
-      case "duration":
-        parseValue(attr.value, { asKey: "duration",
-                                 parser: parseMPDInteger,
-                                 dashName: "duration" });
-        break;
-      case "id":
-        eventIR.id = attr.value;
-        break;
-    }
-  }
-  return [eventIR, warnings];
-}