Source: lib/dash/mpd_utils.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.dash.MpdUtils');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.net.NetworkingEngine');
  23. goog.require('shaka.util.AbortableOperation');
  24. goog.require('shaka.util.Error');
  25. goog.require('shaka.util.Functional');
  26. goog.require('shaka.util.ManifestParserUtils');
  27. goog.require('shaka.util.StringUtils');
  28. goog.require('shaka.util.XmlUtils');
  31. /**
  32.  * @namespace shaka.dash.MpdUtils
  33.  * @summary MPD processing utility functions.
  34.  */
  37. /**
  38.  * @typedef {{
  39.  *   start: number,
  40.  *   unscaledStart: number,
  41.  *   end: number
  42.  * }}
  43.  *
  44.  * @description
  45.  * Defines a time range of a media segment.  Times are in seconds.
  46.  *
  47.  * @property {number} start
  48.  *   The start time of the range.
  49.  * @property {number} unscaledStart
  50.  *   The start time of the range in representation timescale units.
  51.  * @property {number} end
  52.  *   The end time (exclusive) of the range.
  53.  */
  54. shaka.dash.MpdUtils.TimeRange;
  57. /**
  58.  * @typedef {{
  59.  *   timescale: number,
  60.  *   segmentDuration: ?number,
  61.  *   startNumber: number,
  62.  *   scaledPresentationTimeOffset: number,
  63.  *   unscaledPresentationTimeOffset: number,
  64.  *   timeline: Array.<shaka.dash.MpdUtils.TimeRange>
  65.  * }}
  66.  *
  67.  * @description
  68.  * Contains common information between SegmentList and SegmentTemplate items.
  69.  *
  70.  * @property {number} timescale
  71.  *   The time-scale of the representation.
  72.  * @property {?number} segmentDuration
  73.  *   The duration of the segments in seconds, if given.
  74.  * @property {number} startNumber
  75.  *   The start number of the segments; 1 or greater.
  76.  * @property {number} scaledPresentationTimeOffset
  77.  *   The presentation time offset of the representation, in seconds.
  78.  * @property {number} unscaledPresentationTimeOffset
  79.  *   The presentation time offset of the representation, in timescale units.
  80.  * @property {Array.<shaka.dash.MpdUtils.TimeRange>} timeline
  81.  *   The timeline of the representation, if given.  Times in seconds.
  82.  */
  83. shaka.dash.MpdUtils.SegmentInfo;
  86. /**
  87.  * @const {string}
  88.  * @private
  89.  */
  90. shaka.dash.MpdUtils.XlinkNamespaceUri_ = 'http://www.w3.org/1999/xlink';
  93. /**
  94.  * Fills a SegmentTemplate URI template.  This function does not validate the
  95.  * resulting URI.
  96.  *
  97.  * @param {string} uriTemplate
  98.  * @param {?string} representationId
  99.  * @param {?number} number
  100.  * @param {?number} bandwidth
  101.  * @param {?number} time
  102.  * @return {string} A URI string.
  103.  * @see ISO/IEC 23009-1:2014 section 5.3.9.4.4
  104.  */
  105. shaka.dash.MpdUtils.fillUriTemplate = function(
  106.     uriTemplate, representationId, number, bandwidth, time) {
  107.   /** @type {!Object.<string, ?number|?string>} */
  108.   let valueTable = {
  109.     'RepresentationID': representationId,
  110.     'Number': number,
  111.     'Bandwidth': bandwidth,
  112.     'Time': time
  113.   };
  115.   const re =
  116.       /\$(RepresentationID|Number|Bandwidth|Time)?(?:%0([0-9]+)([diouxX]))?\$/g;
  117.   let uri = uriTemplate.replace(re, function(match, name, widthString, format) {
  118.     if (match == '$$') {
  119.       return '$';
  120.     }
  122.     let value = valueTable[name];
  123.     goog.asserts.assert(value !== undefined, 'Unrecognized identifier');
  125.     // Note that |value| may be 0 or ''.
  126.     if (value == null) {
  127.       shaka.log.warning(
  128.           'URL template does not have an available substitution for identifier',
  129.           '"' + name + '":',
  130.           uriTemplate);
  131.       return match;
  132.     }
  134.     if (name == 'RepresentationID' && widthString) {
  135.       shaka.log.warning(
  136.           'URL template should not contain a width specifier for identifier',
  137.           '"RepresentationID":',
  138.           uriTemplate);
  139.       widthString = undefined;
  140.     }
  142.     if (name == 'Time') {
  143.       goog.asserts.assert(Math.abs(value - Math.round(value)) < 0.2,
  144.                           'Calculated $Time$ values must be close to integers');
  145.       value = Math.round(value);
  146.     }
  148.     /** @type {string} */
  149.     let valueString;
  150.     switch (format) {
  151.       case undefined:  // Happens if there is no format specifier.
  152.       case 'd':
  153.       case 'i':
  154.       case 'u':
  155.         valueString = value.toString();
  156.         break;
  157.       case 'o':
  158.         valueString = value.toString(8);
  159.         break;
  160.       case 'x':
  161.         valueString = value.toString(16);
  162.         break;
  163.       case 'X':
  164.         valueString = value.toString(16).toUpperCase();
  165.         break;
  166.       default:
  167.         goog.asserts.assert(false, 'Unhandled format specifier');
  168.         valueString = value.toString();
  169.         break;
  170.     }
  172.     // Create a padding string.
  173.     let width = window.parseInt(widthString, 10) || 1;
  174.     let paddingSize = Math.max(0, width - valueString.length);
  175.     let padding = (new Array(paddingSize + 1)).join('0');
  177.     return padding + valueString;
  178.   });
  180.   return uri;
  181. };
  184. /**
  185.  * Expands a SegmentTimeline into an array-based timeline.  The results are in
  186.  * seconds.
  187.  *
  188.  * @param {!Element} segmentTimeline
  189.  * @param {number} timescale
  190.  * @param {number} unscaledPresentationTimeOffset
  191.  * @param {number} periodDuration The Period's duration in seconds.
  192.  *   Infinity indicates that the Period continues indefinitely.
  193.  * @return {!Array.<shaka.dash.MpdUtils.TimeRange>}
  194.  */
  195. shaka.dash.MpdUtils.createTimeline =
  196.     function(segmentTimeline, timescale, unscaledPresentationTimeOffset,
  197.              periodDuration) {
  198.   goog.asserts.assert(
  199.       timescale > 0 && timescale < Infinity,
  200.       'timescale must be a positive, finite integer');
  201.   goog.asserts.assert(periodDuration > 0,
  202.                       'period duration must be a positive integer');
  204.   // Alias.
  205.   const XmlUtils = shaka.util.XmlUtils;
  207.   let timePoints = XmlUtils.findChildren(segmentTimeline, 'S');
  209.   /** @type {!Array.<shaka.dash.MpdUtils.TimeRange>} */
  210.   let timeline = [];
  211.   let lastEndTime = 0;
  213.   for (let i = 0; i < timePoints.length; ++i) {
  214.     let timePoint = timePoints[i];
  215.     let t = XmlUtils.parseAttr(timePoint, 't', XmlUtils.parseNonNegativeInt);
  216.     let d = XmlUtils.parseAttr(timePoint, 'd', XmlUtils.parseNonNegativeInt);
  217.     let r = XmlUtils.parseAttr(timePoint, 'r', XmlUtils.parseInt);
  219.     // Adjust the start time to account for the presentation time offset.
  220.     if (t != null) {
  221.       t -= unscaledPresentationTimeOffset;
  222.     }
  224.     if (!d) {
  225.       shaka.log.warning(
  226.           '"S" element must have a duration:',
  227.           'ignoring the remaining "S" elements.',
  228.           timePoint);
  229.       return timeline;
  230.     }
  232.     let startTime = t != null ? t : lastEndTime;
  234.     let repeat = r || 0;
  235.     if (repeat < 0) {
  236.       if (i + 1 < timePoints.length) {
  237.         let nextTimePoint = timePoints[i + 1];
  238.         let nextStartTime = XmlUtils.parseAttr(
  239.             nextTimePoint, 't', XmlUtils.parseNonNegativeInt);
  240.         if (nextStartTime == null) {
  241.           shaka.log.warning(
  242.               'An "S" element cannot have a negative repeat',
  243.               'if the next "S" element does not have a valid start time:',
  244.               'ignoring the remaining "S" elements.',
  245.               timePoint);
  246.           return timeline;
  247.         } else if (startTime >= nextStartTime) {
  248.           shaka.log.warning(
  249.               'An "S" element cannot have a negative repeat',
  250.               'if its start time exceeds the next "S" element\'s start time:',
  251.               'ignoring the remaining "S" elements.',
  252.               timePoint);
  253.           return timeline;
  254.         }
  255.         repeat = Math.ceil((nextStartTime - startTime) / d) - 1;
  256.       } else {
  257.         if (periodDuration == Infinity) {
  258.           // The DASH spec. actually allows the last "S" element to have a
  259.           // negative repeat value even when the Period has an infinite
  260.           // duration.  No one uses this feature and no one ever should, ever.
  261.           shaka.log.warning(
  262.               'The last "S" element cannot have a negative repeat',
  263.               'if the Period has an infinite duration:',
  264.               'ignoring the last "S" element.',
  265.               timePoint);
  266.           return timeline;
  267.         } else if (startTime / timescale >= periodDuration) {
  268.           shaka.log.warning(
  269.               'The last "S" element cannot have a negative repeat',
  270.               'if its start time exceeds the Period\'s duration:',
  271.               'igoring the last "S" element.',
  272.               timePoint);
  273.           return timeline;
  274.         }
  275.         repeat = Math.ceil((periodDuration * timescale - startTime) / d) - 1;
  276.       }
  277.     }
  279.     // The end of the last segment may be before the start of the current
  280.     // segment (a gap) or after the start of the current segment (an overlap).
  281.     // If there is a gap/overlap then stretch/compress the end of the last
  282.     // segment to the start of the current segment.
  283.     //
  284.     // Note: it is possible to move the start of the current segment to the
  285.     // end of the last segment, but this would complicate the computation of
  286.     // the $Time$ placeholder later on.
  287.     if ((timeline.length > 0) && (startTime != lastEndTime)) {
  288.       let delta = startTime - lastEndTime;
  290.       if (Math.abs(delta / timescale) >=
  291.           shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS) {
  292.         shaka.log.warning(
  293.             'SegmentTimeline contains a large gap/overlap:',
  294.             'the content may have errors in it.',
  295.             timePoint);
  296.       }
  298.       timeline[timeline.length - 1].end = startTime / timescale;
  299.     }
  301.     for (let j = 0; j <= repeat; ++j) {
  302.       let endTime = startTime + d;
  303.       let item = {
  304.         start: startTime / timescale,
  305.         end: endTime / timescale,
  306.         unscaledStart: startTime
  307.       };
  308.       timeline.push(item);
  310.       startTime = endTime;
  311.       lastEndTime = endTime;
  312.     }
  313.   }
  315.   return timeline;
  316. };
  319. /**
  320.  * Parses common segment info for SegmentList and SegmentTemplate.
  321.  *
  322.  * @param {shaka.dash.DashParser.Context} context
  323.  * @param {function(?shaka.dash.DashParser.InheritanceFrame):Element} callback
  324.  *   Gets the element that contains the segment info.
  325.  * @return {shaka.dash.MpdUtils.SegmentInfo}
  326.  */
  327. shaka.dash.MpdUtils.parseSegmentInfo = function(context, callback) {
  328.   goog.asserts.assert(
  329.       callback(context.representation),
  330.       'There must be at least one element of the given type.');
  331.   const MpdUtils = shaka.dash.MpdUtils;
  332.   const XmlUtils = shaka.util.XmlUtils;
  334.   let timescaleStr = MpdUtils.inheritAttribute(context, callback, 'timescale');
  335.   let timescale = 1;
  336.   if (timescaleStr) {
  337.     timescale = XmlUtils.parsePositiveInt(timescaleStr) || 1;
  338.   }
  340.   let durationStr = MpdUtils.inheritAttribute(context, callback, 'duration');
  341.   let segmentDuration = XmlUtils.parsePositiveInt(durationStr || '');
  342.   if (segmentDuration) {
  343.     segmentDuration /= timescale;
  344.   }
  346.   let startNumberStr =
  347.       MpdUtils.inheritAttribute(context, callback, 'startNumber');
  348.   let unscaledPresentationTimeOffset =
  349.       Number(MpdUtils.inheritAttribute(context, callback,
  350.                                        'presentationTimeOffset')) || 0;
  351.   let startNumber = XmlUtils.parseNonNegativeInt(startNumberStr || '');
  352.   if (startNumberStr == null || startNumber == null) {
  353.     startNumber = 1;
  354.   }
  356.   let timelineNode =
  357.       MpdUtils.inheritChild(context, callback, 'SegmentTimeline');
  358.   /** @type {Array.<shaka.dash.MpdUtils.TimeRange>} */
  359.   let timeline = null;
  360.   if (timelineNode) {
  361.     timeline = MpdUtils.createTimeline(
  362.         timelineNode, timescale, unscaledPresentationTimeOffset,
  363.         context.periodInfo.duration || Infinity);
  364.   }
  366.   let scaledPresentationTimeOffset =
  367.       (unscaledPresentationTimeOffset / timescale) || 0;
  368.   return {
  369.     timescale: timescale,
  370.     segmentDuration: segmentDuration,
  371.     startNumber: startNumber,
  372.     scaledPresentationTimeOffset: scaledPresentationTimeOffset,
  373.     unscaledPresentationTimeOffset: unscaledPresentationTimeOffset,
  374.     timeline: timeline
  375.   };
  376. };
  379. /**
  380.  * Searches the inheritance for a Segment* with the given attribute.
  381.  *
  382.  * @param {shaka.dash.DashParser.Context} context
  383.  * @param {function(?shaka.dash.DashParser.InheritanceFrame):Element} callback
  384.  *   Gets the Element that contains the attribute to inherit.
  385.  * @param {string} attribute
  386.  * @return {?string}
  387.  */
  388. shaka.dash.MpdUtils.inheritAttribute = function(context, callback, attribute) {
  389.   const Functional = shaka.util.Functional;
  390.   goog.asserts.assert(
  391.       callback(context.representation),
  392.       'There must be at least one element of the given type');
  394.   /** @type {!Array.<!Element>} */
  395.   let nodes = [
  396.     callback(context.representation),
  397.     callback(context.adaptationSet),
  398.     callback(context.period)
  399.   ].filter(Functional.isNotNull);
  401.   return nodes
  402.       .map(function(s) { return s.getAttribute(attribute); })
  403.       .reduce(function(all, part) { return all || part; });
  404. };
  407. /**
  408.  * Searches the inheritance for a Segment* with the given child.
  409.  *
  410.  * @param {shaka.dash.DashParser.Context} context
  411.  * @param {function(?shaka.dash.DashParser.InheritanceFrame):Element} callback
  412.  *   Gets the Element that contains the child to inherit.
  413.  * @param {string} child
  414.  * @return {Element}
  415.  */
  416. shaka.dash.MpdUtils.inheritChild = function(context, callback, child) {
  417.   const Functional = shaka.util.Functional;
  418.   goog.asserts.assert(
  419.       callback(context.representation),
  420.       'There must be at least one element of the given type');
  422.   /** @type {!Array.<!Element>} */
  423.   let nodes = [
  424.     callback(context.representation),
  425.     callback(context.adaptationSet),
  426.     callback(context.period)
  427.   ].filter(Functional.isNotNull);
  429.   const XmlUtils = shaka.util.XmlUtils;
  430.   return nodes
  431.       .map(function(s) { return XmlUtils.findChild(s, child); })
  432.       .reduce(function(all, part) { return all || part; });
  433. };
  436. /**
  437.  * Parse some UTF8 data and return the resulting root element if
  438.  * it was valid XML.
  439.  * @param {ArrayBuffer} data
  440.  * @param {string} expectedRootElemName
  441.  * @return {Element|undefined}
  442.  */
  443. shaka.dash.MpdUtils.parseXml = function(data, expectedRootElemName) {
  444.   let parser = new DOMParser();
  445.   let rootElem;
  446.   let xml;
  447.   try {
  448.     let string = shaka.util.StringUtils.fromUTF8(data);
  449.     xml = parser.parseFromString(string, 'text/xml');
  450.   } catch (exception) {}
  451.   if (xml) {
  452.     // The top-level element in the loaded xml should have the
  453.     // same type as the element linking.
  454.     if (xml.documentElement.tagName == expectedRootElemName) {
  455.       rootElem = xml.documentElement;
  456.     }
  457.   }
  458.   if (rootElem && rootElem.getElementsByTagName('parsererror').length > 0) {
  459.     return null;
  460.   }  // It had a parser error in it.
  462.   return rootElem;
  463. };
  466. /**
  467.  * Follow the xlink link contained in the given element.
  468.  * It also strips the xlink properties off of the element,
  469.  * even if the process fails.
  470.  *
  471.  * @param {!Element} element
  472.  * @param {!shakaExtern.RetryParameters} retryParameters
  473.  * @param {boolean} failGracefully
  474.  * @param {string} baseUri
  475.  * @param {!shaka.net.NetworkingEngine} networkingEngine
  476.  * @param {number} linkDepth
  477.  * @return {!shaka.util.AbortableOperation.<!Element>}
  478.  * @private
  479.  */
  480. shaka.dash.MpdUtils.handleXlinkInElement_ =
  481.     function(element, retryParameters, failGracefully, baseUri,
  482.              networkingEngine, linkDepth) {
  483.   const MpdUtils = shaka.dash.MpdUtils;
  484.   const XmlUtils = shaka.util.XmlUtils;
  485.   const Error = shaka.util.Error;
  486.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  487.   const NS = MpdUtils.XlinkNamespaceUri_;
  489.   let xlinkHref = XmlUtils.getAttributeNS(element, NS, 'href');
  490.   let xlinkActuate =
  491.       XmlUtils.getAttributeNS(element, NS, 'actuate') || 'onRequest';
  493.   // Remove the xlink properties, so it won't download again
  494.   // when re-processed.
  495.   for (let i = 0; i < element.attributes.length; i++) {
  496.     let attribute = element.attributes[i];
  497.     if (attribute.namespaceURI == NS) {
  498.       element.removeAttributeNS(attribute.namespaceURI, attribute.localName);
  499.       i -= 1;
  500.     }
  501.   }
  503.   if (linkDepth >= 5) {
  504.     return shaka.util.AbortableOperation.failed(new Error(
  505.         Error.Severity.CRITICAL, Error.Category.MANIFEST,
  506.         Error.Code.DASH_XLINK_DEPTH_LIMIT));
  507.   }
  509.   if (xlinkActuate != 'onLoad') {
  510.     // Only xlink:actuate="onLoad" is supported.
  511.     // When no value is specified, the assumed value is "onRequest".
  512.     return shaka.util.AbortableOperation.failed(new Error(
  513.         Error.Severity.CRITICAL, Error.Category.MANIFEST,
  514.         Error.Code.DASH_UNSUPPORTED_XLINK_ACTUATE));
  515.   }
  517.   // Resolve the xlink href, in case it's a relative URL.
  518.   let uris = ManifestParserUtils.resolveUris([baseUri], [xlinkHref]);
  520.   // Load in the linked elements.
  521.   const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  522.   let request = shaka.net.NetworkingEngine.makeRequest(
  523.       uris, retryParameters);
  525.   let requestOperation = networkingEngine.request(requestType, request);
  526.   // The interface is abstract, but we know it was implemented with the
  527.   // more capable internal class.
  528.   goog.asserts.assert(requestOperation instanceof shaka.util.AbortableOperation,
  529.                       'Unexpected implementation of IAbortableOperation!');
  530.   // Satisfy the compiler with a cast.
  531.   let networkOperation =
  532.       /** @type {!shaka.util.AbortableOperation.<shakaExtern.Response>} */(
  533.           requestOperation);
  535.   // Chain onto that operation.
  536.   return networkOperation.chain((response) => {
  537.     // This only supports the case where the loaded xml has a single
  538.     // top-level element.  If there are multiple roots, it will be rejected.
  539.     let rootElem = MpdUtils.parseXml(response.data, element.tagName);
  540.     if (!rootElem) {
  541.       // It was not valid XML.
  542.       return shaka.util.AbortableOperation.failed(new Error(
  543.           Error.Severity.CRITICAL, Error.Category.MANIFEST,
  544.           Error.Code.DASH_INVALID_XML, xlinkHref));
  545.     }
  547.     // Now that there is no other possibility of the process erroring,
  548.     // the element can be changed further.
  550.     // Remove the current contents of the node.
  551.     while (element.childNodes.length) {
  552.       element.removeChild(element.childNodes[0]);
  553.     }
  555.     // Move the children of the loaded xml into the current element.
  556.     while (rootElem.childNodes.length) {
  557.       let child = rootElem.childNodes[0];
  558.       rootElem.removeChild(child);
  559.       element.appendChild(child);
  560.     }
  562.     // Move the attributes of the loaded xml into the current element.
  563.     for (let i = 0; i < rootElem.attributes.length; i++) {
  564.       let attribute = rootElem.attributes[i].nodeName;
  565.       let attributeValue = rootElem.getAttribute(attribute);
  566.       element.setAttribute(attribute, attributeValue);
  567.     }
  569.     return shaka.dash.MpdUtils.processXlinks(
  570.         element, retryParameters, failGracefully, uris[0], networkingEngine,
  571.         linkDepth + 1);
  572.   });
  573. };
  576. /**
  577.  * Filter the contents of a node recursively, replacing xlink links
  578.  * with their associated online data.
  579.  *
  580.  * @param {!Element} element
  581.  * @param {!shakaExtern.RetryParameters} retryParameters
  582.  * @param {boolean} failGracefully
  583.  * @param {string} baseUri
  584.  * @param {!shaka.net.NetworkingEngine} networkingEngine
  585.  * @param {number=} opt_linkDepth
  586.  * @return {!shaka.util.AbortableOperation.<!Element>}
  587.  */
  588. shaka.dash.MpdUtils.processXlinks =
  589.     function(element, retryParameters, failGracefully, baseUri,
  590.              networkingEngine, opt_linkDepth) {
  591.   const MpdUtils = shaka.dash.MpdUtils;
  592.   const XmlUtils = shaka.util.XmlUtils;
  593.   const NS = MpdUtils.XlinkNamespaceUri_;
  595.   opt_linkDepth = opt_linkDepth || 0;
  597.   if (XmlUtils.getAttributeNS(element, NS, 'href')) {
  598.     let handled = MpdUtils.handleXlinkInElement_(
  599.         element, retryParameters, failGracefully, baseUri,
  600.         networkingEngine, opt_linkDepth);
  601.     if (failGracefully) {
  602.       // Catch any error and go on.
  603.       handled = handled.chain(undefined, (error) => {
  604.         // handleXlinkInElement_ strips the xlink properties off of the element
  605.         // even if it fails, so calling processXlinks again will handle whatever
  606.         // contents the element natively has.
  607.         return MpdUtils.processXlinks(element, retryParameters, failGracefully,
  608.                                       baseUri, networkingEngine,
  609.                                       opt_linkDepth);
  610.       });
  611.     }
  612.     return handled;
  613.   }
  615.   let childOperations = [];
  616.   for (let i = 0; i < element.childNodes.length; i++) {
  617.     let child = element.childNodes[i];
  618.     if (child instanceof Element) {
  619.       const resolveToZeroString = 'urn:mpeg:dash:resolve-to-zero:2013';
  620.       if (XmlUtils.getAttributeNS(child, NS, 'href') == resolveToZeroString) {
  621.         // This is a 'resolve to zero' code; it means the element should
  622.         // be removed, as specified by the mpeg-dash rules for xlink.
  623.         element.removeChild(child);
  624.         i -= 1;
  625.       } else if (child.tagName != 'SegmentTimeline') {
  626.         // Don't recurse into a SegmentTimeline since xlink attributes aren't
  627.         // valid in there and looking at each segment can take a long time with
  628.         // larger manifests.
  630.         // Replace the child with its processed form.
  631.         childOperations.push(shaka.dash.MpdUtils.processXlinks(
  632.             /** @type {!Element} */ (child), retryParameters, failGracefully,
  633.             baseUri, networkingEngine, opt_linkDepth));
  634.       }
  635.     }
  636.   }
  638.   return shaka.util.AbortableOperation.all(childOperations).chain(() => {
  639.     return element;
  640.   });
  641. };