rx-player 4.0.0-dev.202402213 → 4.0.0-dev.2024022300

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/EventStream.js

@@ -0,0 +1,101 @@
+/**
+ * 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 isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
+import startsWith from "../../../../../utils/starts_with";
+import { parseMPDInteger, ValueParser } from "./utils";
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+function parseEventStreamAttributes(root) {
+    const res = {};
+    const warnings = [];
+    const parseValue = ValueParser(res, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "schemeIdUri":
+                res.schemeIdUri = attributeVal;
+                break;
+            case "value":
+                res.value = attributeVal;
+                break;
+            case "timescale":
+                parseValue(attributeVal, {
+                    asKey: "timescale",
+                    parser: parseMPDInteger,
+                    dashName: "timescale",
+                });
+                break;
+            default:
+                if (startsWith(attributeName, "xmlns:")) {
+                    if (res.namespaces === undefined) {
+                        res.namespaces = [];
+                    }
+                    res.namespaces.push({
+                        key: attributeName.substring(6),
+                        value: attributeVal,
+                    });
+                }
+                break;
+        }
+    }
+    return [res, warnings];
+}
+/**
+ * @param {Object} root
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+export function createEventStreamIntermediateRepresentation(root, fullMpd) {
+    const [attributes, warnings] = parseEventStreamAttributes(root);
+    const events = [];
+    for (const child of root.children) {
+        if (typeof child !== "string" && child.tagName === "Event") {
+            const data = {};
+            if (!isNullOrUndefined(child.attributes.id)) {
+                data.id = child.attributes.id;
+            }
+            if (!isNullOrUndefined(child.attributes.presentationTime)) {
+                const [val, parsedWarning] = parseMPDInteger(child.attributes.presentationTime, "presentationTime");
+                if (parsedWarning !== null) {
+                    warnings.push(parsedWarning);
+                }
+                if (val !== null) {
+                    data.presentationTime = val;
+                }
+            }
+            if (!isNullOrUndefined(child.attributes.duration)) {
+                const [val, parsedWarning] = parseMPDInteger(child.attributes.duration, "duration");
+                if (parsedWarning !== null) {
+                    warnings.push(parsedWarning);
+                }
+                if (val !== null) {
+                    data.duration = val;
+                }
+            }
+            if (child.posStart < child.posEnd) {
+                const eventStr = fullMpd.substring(child.posStart, child.posEnd);
+                data.eventStreamData = eventStr;
+            }
+            events.push(data);
+        }
+    }
+    return [{ children: { events }, attributes }, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/Initialization.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 type { ITNode } from "../../../../../utils/xml-parser";
+import type { IInitializationAttributes } from "../../node_parser_types";
+/**
+ * @param {Object} root
+ * @returns {Array.<Object>}
+ */
+export default function parseInitialization(root: ITNode): [IInitializationAttributes, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/Initialization.js

@@ -0,0 +1,45 @@
+/**
+ * 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 isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
+import { parseByteRange, ValueParser } from "./utils";
+/**
+ * @param {Object} root
+ * @returns {Array.<Object>}
+ */
+export default function parseInitialization(root) {
+    const parsedInitialization = {};
+    const warnings = [];
+    const parseValue = ValueParser(parsedInitialization, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "range":
+                parseValue(attributeVal, {
+                    asKey: "range",
+                    parser: parseByteRange,
+                    dashName: "range",
+                });
+                break;
+            case "sourceURL":
+                parsedInitialization.media = attributeVal;
+                break;
+        }
+    }
+    return [parsedInitialization, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/MPD.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type { ITNode } from "../../../../../utils/xml-parser";
+import type { IMPDIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * @param {Object} root
+ * @param {string} fullMpd
+ * @returns {Array.<Object>}
+ */
+export declare function createMPDIntermediateRepresentation(root: ITNode, fullMpd: string): [IMPDIntermediateRepresentation, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/MPD.js

@@ -0,0 +1,179 @@
+/**
+ * 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 isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
+import startsWith from "../../../../../utils/starts_with";
+import parseBaseURL from "./BaseURL";
+import { createPeriodIntermediateRepresentation } from "./Period";
+import { parseDateTime, parseDuration, parseScheme, textContent, ValueParser, } from "./utils";
+/**
+ * Parse children of the MPD's root into a simple object.
+ * @param {Array.<Object | string>} mpdChildren
+ * @returns {Array.<Object>}
+ */
+function parseMPDChildren(mpdChildren, fullMpd) {
+    const baseURLs = [];
+    const locations = [];
+    const periods = [];
+    const utcTimings = [];
+    let warnings = [];
+    for (let i = 0; i < mpdChildren.length; i++) {
+        const currentNode = mpdChildren[i];
+        if (typeof currentNode === "string") {
+            continue;
+        }
+        switch (currentNode.tagName) {
+            case "BaseURL":
+                const [baseURLObj, baseURLWarnings] = parseBaseURL(currentNode);
+                if (baseURLObj !== undefined) {
+                    baseURLs.push(baseURLObj);
+                }
+                warnings = warnings.concat(baseURLWarnings);
+                break;
+            case "Location":
+                locations.push(textContent(currentNode.children));
+                break;
+            case "Period":
+                const [period, periodWarnings] = createPeriodIntermediateRepresentation(currentNode, fullMpd);
+                periods.push(period);
+                warnings = warnings.concat(periodWarnings);
+                break;
+            case "UTCTiming":
+                const utcTiming = parseScheme(currentNode);
+                utcTimings.push(utcTiming);
+                break;
+        }
+    }
+    return [{ baseURLs, locations, periods, utcTimings }, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Array.<Object>}
+ */
+function parseMPDAttributes(root) {
+    const res = {};
+    const warnings = [];
+    const parseValue = ValueParser(res, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "id":
+                res.id = attributeVal;
+                break;
+            case "profiles":
+                res.profiles = attributeVal;
+                break;
+            case "type":
+                res.type = attributeVal;
+                break;
+            case "availabilityStartTime":
+                parseValue(attributeVal, {
+                    asKey: "availabilityStartTime",
+                    parser: parseDateTime,
+                    dashName: "availabilityStartTime",
+                });
+                break;
+            case "availabilityEndTime":
+                parseValue(attributeVal, {
+                    asKey: "availabilityEndTime",
+                    parser: parseDateTime,
+                    dashName: "availabilityEndTime",
+                });
+                break;
+            case "publishTime":
+                parseValue(attributeVal, {
+                    asKey: "publishTime",
+                    parser: parseDateTime,
+                    dashName: "publishTime",
+                });
+                break;
+            case "mediaPresentationDuration":
+                parseValue(attributeVal, {
+                    asKey: "duration",
+                    parser: parseDuration,
+                    dashName: "mediaPresentationDuration",
+                });
+                break;
+            case "minimumUpdatePeriod":
+                parseValue(attributeVal, {
+                    asKey: "minimumUpdatePeriod",
+                    parser: parseDuration,
+                    dashName: "minimumUpdatePeriod",
+                });
+                break;
+            case "minBufferTime":
+                parseValue(attributeVal, {
+                    asKey: "minBufferTime",
+                    parser: parseDuration,
+                    dashName: "minBufferTime",
+                });
+                break;
+            case "timeShiftBufferDepth":
+                parseValue(attributeVal, {
+                    asKey: "timeShiftBufferDepth",
+                    parser: parseDuration,
+                    dashName: "timeShiftBufferDepth",
+                });
+                break;
+            case "suggestedPresentationDelay":
+                parseValue(attributeVal, {
+                    asKey: "suggestedPresentationDelay",
+                    parser: parseDuration,
+                    dashName: "suggestedPresentationDelay",
+                });
+                break;
+            case "maxSegmentDuration":
+                parseValue(attributeVal, {
+                    asKey: "maxSegmentDuration",
+                    parser: parseDuration,
+                    dashName: "maxSegmentDuration",
+                });
+                break;
+            case "maxSubsegmentDuration":
+                parseValue(attributeVal, {
+                    asKey: "maxSubsegmentDuration",
+                    parser: parseDuration,
+                    dashName: "maxSubsegmentDuration",
+                });
+                break;
+            default:
+                if (startsWith(attributeName, "xmlns:")) {
+                    if (res.namespaces === undefined) {
+                        res.namespaces = [];
+                    }
+                    res.namespaces.push({
+                        key: attributeName.substring(6),
+                        value: attributeVal,
+                    });
+                }
+                break;
+        }
+    }
+    return [res, warnings];
+}
+/**
+ * @param {Object} root
+ * @param {string} fullMpd
+ * @returns {Array.<Object>}
+ */
+export function createMPDIntermediateRepresentation(root, fullMpd) {
+    const [children, childrenWarnings] = parseMPDChildren(root.children, fullMpd);
+    const [attributes, attrsWarnings] = parseMPDAttributes(root);
+    const warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children, attributes }, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/Period.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 type { ITNode } from "../../../../../utils/xml-parser";
+import type { IPeriodIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * @param {Object} periodElement
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+export declare function createPeriodIntermediateRepresentation(periodElement: ITNode, fullMpd: string): [IPeriodIntermediateRepresentation, Error[]];

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/Period.js

@@ -0,0 +1,137 @@
+/**
+ * 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 isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
+import startsWith from "../../../../../utils/starts_with";
+import { createAdaptationSetIntermediateRepresentation } from "./AdaptationSet";
+import parseBaseURL from "./BaseURL";
+import { createEventStreamIntermediateRepresentation } from "./EventStream";
+import parseSegmentTemplate from "./SegmentTemplate";
+import { parseBoolean, parseDuration, ValueParser } from "./utils";
+/**
+ * @param {Array.<Object | string>} periodChildren
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+function parsePeriodChildren(periodChildren, fullMpd) {
+    const baseURLs = [];
+    const adaptations = [];
+    let segmentTemplate;
+    let warnings = [];
+    const eventStreams = [];
+    for (let i = 0; i < periodChildren.length; i++) {
+        const currentElement = periodChildren[i];
+        if (typeof currentElement === "string") {
+            continue;
+        }
+        switch (currentElement.tagName) {
+            case "BaseURL":
+                const [baseURLObj, baseURLWarnings] = parseBaseURL(currentElement);
+                if (baseURLObj !== undefined) {
+                    baseURLs.push(baseURLObj);
+                }
+                warnings = warnings.concat(baseURLWarnings);
+                break;
+            case "AdaptationSet":
+                const [adaptation, adaptationWarnings] = createAdaptationSetIntermediateRepresentation(currentElement);
+                adaptations.push(adaptation);
+                warnings = warnings.concat(adaptationWarnings);
+                break;
+            case "EventStream":
+                const [eventStream, eventStreamWarnings] = createEventStreamIntermediateRepresentation(currentElement, fullMpd);
+                eventStreams.push(eventStream);
+                warnings = warnings.concat(eventStreamWarnings);
+                break;
+            case "SegmentTemplate":
+                const [parsedSegmentTemplate, segmentTemplateWarnings] = parseSegmentTemplate(currentElement);
+                segmentTemplate = parsedSegmentTemplate;
+                if (segmentTemplateWarnings.length > 0) {
+                    warnings = warnings.concat(segmentTemplateWarnings);
+                }
+                break;
+        }
+    }
+    return [{ baseURLs, adaptations, eventStreams, segmentTemplate }, warnings];
+}
+/**
+ * @param {Object} root
+ * @returns {Array}
+ */
+function parsePeriodAttributes(root) {
+    const res = {};
+    const warnings = [];
+    const parseValue = ValueParser(res, warnings);
+    for (const attributeName of Object.keys(root.attributes)) {
+        const attributeVal = root.attributes[attributeName];
+        if (isNullOrUndefined(attributeVal)) {
+            continue;
+        }
+        switch (attributeName) {
+            case "id":
+                res.id = attributeVal;
+                break;
+            case "start":
+                parseValue(attributeVal, {
+                    asKey: "start",
+                    parser: parseDuration,
+                    dashName: "start",
+                });
+                break;
+            case "duration":
+                parseValue(attributeVal, {
+                    asKey: "duration",
+                    parser: parseDuration,
+                    dashName: "duration",
+                });
+                break;
+            case "bitstreamSwitching":
+                parseValue(attributeVal, {
+                    asKey: "bitstreamSwitching",
+                    parser: parseBoolean,
+                    dashName: "bitstreamSwitching",
+                });
+                break;
+            case "xlink:href":
+                res.xlinkHref = attributeVal;
+                break;
+            case "xlink:actuate":
+                res.xlinkActuate = attributeVal;
+                break;
+            default:
+                if (startsWith(attributeName, "xmlns:")) {
+                    if (res.namespaces === undefined) {
+                        res.namespaces = [];
+                    }
+                    res.namespaces.push({
+                        key: attributeName.substring(6),
+                        value: attributeVal,
+                    });
+                }
+                break;
+        }
+    }
+    return [res, warnings];
+}
+/**
+ * @param {Object} periodElement
+ * @param {string} fullMpd
+ * @returns {Array}
+ */
+export function createPeriodIntermediateRepresentation(periodElement, fullMpd) {
+    const [children, childrenWarnings] = parsePeriodChildren(periodElement.children, fullMpd);
+    const [attributes, attrsWarnings] = parsePeriodAttributes(periodElement);
+    const warnings = childrenWarnings.concat(attrsWarnings);
+    return [{ children, attributes }, warnings];
+}

package/dist/es2017/parsers/manifest/dash/fast-js-parser/node_parsers/Representation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 type { ITNode } from "../../../../../utils/xml-parser";
+import type { IRepresentationIntermediateRepresentation } from "../../node_parser_types";
+/**
+ * @param {Object} representationElement
+ * @returns {Array}
+ */
+export declare function createRepresentationIntermediateRepresentation(representationElement: ITNode): [IRepresentationIntermediateRepresentation, Error[]];