Source: lib/dash/dash_parser.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.DashParser');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.dash.ContentProtection');
  22. goog.require('shaka.dash.SegmentBase');
  23. goog.require('shaka.dash.SegmentList');
  24. goog.require('shaka.dash.SegmentTemplate');
  25. goog.require('shaka.log');
  26. goog.require('shaka.media.DrmEngine');
  27. goog.require('shaka.media.ManifestParser');
  28. goog.require('shaka.media.PresentationTimeline');
  29. goog.require('shaka.media.SegmentReference');
  30. goog.require('shaka.net.NetworkingEngine');
  31. goog.require('shaka.text.TextEngine');
  32. goog.require('shaka.util.Error');
  33. goog.require('shaka.util.Functional');
  34. goog.require('shaka.util.LanguageUtils');
  35. goog.require('shaka.util.ManifestParserUtils');
  36. goog.require('shaka.util.MimeUtils');
  37. goog.require('shaka.util.StringUtils');
  38. goog.require('shaka.util.XmlUtils');
  42. /**
  43.  * Creates a new DASH parser.
  44.  *
  45.  * @struct
  46.  * @constructor
  47.  * @implements {shakaExtern.ManifestParser}
  48.  * @export
  49.  */
  50. shaka.dash.DashParser = function() {
  51.   /** @private {?shakaExtern.ManifestConfiguration} */
  52.   this.config_ = null;
  54.   /** @private {?shakaExtern.ManifestParser.PlayerInterface} */
  55.   this.playerInterface_ = null;
  57.   /** @private {!Array.<string>} */
  58.   this.manifestUris_ = [];
  60.   /** @private {?shakaExtern.Manifest} */
  61.   this.manifest_ = null;
  63.   /** @private {!Array.<string>} */
  64.   this.periodIds_ = [];
  66.   /** @private {number} */
  67.   this.globalId_ = 1;
  69.   /**
  70.    * A map of IDs to SegmentIndex objects.
  71.    * ID: Period@id,AdaptationSet@id,@Representation@id
  72.    * e.g.: '1,5,23'
  73.    * @private {!Object.<string, !shaka.media.SegmentIndex>}
  74.    */
  75.   this.segmentIndexMap_ = {};
  77.   /**
  78.    * The update period in seconds; or 0 for no updates.
  79.    * @private {number}
  80.    */
  81.   this.updatePeriod_ = 0;
  83.   /** @private {?number} */
  84.   this.updateTimer_ = null;
  85. };
  88. /**
  89.  * Contains the minimum amount of time, in seconds, between manifest update
  90.  * requests.
  91.  *
  92.  * @private
  93.  * @const {number}
  94.  */
  95. shaka.dash.DashParser.MIN_UPDATE_PERIOD_ = 3;
  98. /**
  99.  * The default MPD@suggestedPresentationDelay in seconds.
  100.  *
  101.  * @private
  102.  * @const {number}
  103.  */
  104. shaka.dash.DashParser.DEFAULT_SUGGESTED_PRESENTATION_DELAY_ = 10;
  107. /**
  108.  * @typedef {
  109.  *   !function(!Array.<string>, ?number, ?number):!Promise.<!ArrayBuffer>
  110.  * }
  111.  */
  112. shaka.dash.DashParser.RequestInitSegmentCallback;
  115. /**
  116.  * @typedef {{
  117.  *   segmentBase: Element,
  118.  *   segmentList: Element,
  119.  *   segmentTemplate: Element,
  120.  *   baseUris: !Array.<string>,
  121.  *   width: (number|undefined),
  122.  *   height: (number|undefined),
  123.  *   contentType: string,
  124.  *   mimeType: string,
  125.  *   codecs: string,
  126.  *   frameRate: (number|undefined),
  127.  *   containsEmsgBoxes: boolean,
  128.  *   id: string,
  129.  *   numChannels: ?number
  130.  * }}
  131.  *
  132.  * @description
  133.  * A collection of elements and properties which are inherited across levels
  134.  * of a DASH manifest.
  135.  *
  136.  * @property {Element} segmentBase
  137.  *   The XML node for SegmentBase.
  138.  * @property {Element} segmentList
  139.  *   The XML node for SegmentList.
  140.  * @property {Element} segmentTemplate
  141.  *   The XML node for SegmentTemplate.
  142.  * @property {!Array.<string>} baseUris
  143.  *   An array of absolute base URIs for the frame.
  144.  * @property {(number|undefined)} width
  145.  *   The inherited width value.
  146.  * @property {(number|undefined)} height
  147.  *   The inherited height value.
  148.  * @property {string} contentType
  149.  *   The inherited media type.
  150.  * @property {string} mimeType
  151.  *   The inherited MIME type value.
  152.  * @property {string} codecs
  153.  *   The inherited codecs value.
  154.  * @property {(number|undefined)} frameRate
  155.  *   The inherited framerate value.
  156.  * @property {boolean} containsEmsgBoxes
  157.  *   Whether there are 'emsg' boxes.
  158.  * @property {string} id
  159.  *   The ID of the element.
  160.  * @property {?number} numChannels
  161.  *   The number of audio channels, or null if unknown.
  162.  */
  163. shaka.dash.DashParser.InheritanceFrame;
  166. /**
  167.  * @typedef {{
  168.  *   dynamic: boolean,
  169.  *   presentationTimeline: !shaka.media.PresentationTimeline,
  170.  *   period: ?shaka.dash.DashParser.InheritanceFrame,
  171.  *   periodInfo: ?shaka.dash.DashParser.PeriodInfo,
  172.  *   adaptationSet: ?shaka.dash.DashParser.InheritanceFrame,
  173.  *   representation: ?shaka.dash.DashParser.InheritanceFrame,
  174.  *   bandwidth: number,
  175.  *   indexRangeWarningGiven: boolean
  176.  * }}
  177.  *
  178.  * @description
  179.  * Contains context data for the streams.
  180.  *
  181.  * @property {boolean} dynamic
  182.  *   True if the MPD is dynamic (not all segments available at once)
  183.  * @property {!shaka.media.PresentationTimeline} presentationTimeline
  184.  *   The PresentationTimeline.
  185.  * @property {?shaka.dash.DashParser.InheritanceFrame} period
  186.  *   The inheritance from the Period element.
  187.  * @property {?shaka.dash.DashParser.PeriodInfo} periodInfo
  188.  *   The Period info for the current Period.
  189.  * @property {?shaka.dash.DashParser.InheritanceFrame} adaptationSet
  190.  *   The inheritance from the AdaptationSet element.
  191.  * @property {?shaka.dash.DashParser.InheritanceFrame} representation
  192.  *   The inheritance from the Representation element.
  193.  * @property {number} bandwidth
  194.  *   The bandwidth of the Representation, or zero if missing.
  195.  * @property {boolean} indexRangeWarningGiven
  196.  *   True if the warning about SegmentURL@indexRange has been printed.
  197.  */
  198. shaka.dash.DashParser.Context;
  201. /**
  202.  * @typedef {{
  203.  *   start: number,
  204.  *   duration: ?number,
  205.  *   node: !Element,
  206.  *   isLastPeriod: boolean
  207.  * }}
  208.  *
  209.  * @description
  210.  * Contains information about a Period element.
  211.  *
  212.  * @property {number} start
  213.  *   The start time of the period.
  214.  * @property {?number} duration
  215.  *   The duration of the period; or null if the duration is not given.  This
  216.  *   will be non-null for all periods except the last.
  217.  * @property {!Element} node
  218.  *   The XML Node for the Period.
  219.  * @property {boolean} isLastPeriod
  220.  *   Whether this Period is the last one in the manifest.
  221.  */
  222. shaka.dash.DashParser.PeriodInfo;
  225. /**
  226.  * @typedef {{
  227.  *   id: string,
  228.  *   contentType: ?string,
  229.  *   language: string,
  230.  *   main: boolean,
  231.  *   streams: !Array.<shakaExtern.Stream>,
  232.  *   drmInfos: !Array.<shakaExtern.DrmInfo>,
  233.  *   trickModeFor: ?string,
  234.  *   representationIds: !Array.<string>
  235.  * }}
  236.  *
  237.  * @description
  238.  * Contains information about an AdaptationSet element.
  239.  *
  240.  * @property {string} id
  241.  *   The unique ID of the adaptation set.
  242.  * @property {?string} contentType
  243.  *   The content type of the AdaptationSet.
  244.  * @property {string} language
  245.  *   The language of the AdaptationSet.
  246.  * @property {boolean} main
  247.  *   Whether the AdaptationSet has the 'main' type.
  248.  * @property {!Array.<shakaExtern.Stream>} streams
  249.  *   The streams this AdaptationSet contains.
  250.  * @property {!Array.<shakaExtern.DrmInfo>} drmInfos
  251.  *   The DRM info for the AdaptationSet.
  252.  * @property {?string} trickModeFor
  253.  *   If non-null, this AdaptationInfo represents trick mode tracks.  This
  254.  *   property is the ID of the normal AdaptationSet these tracks should be
  255.  *   associated with.
  256.  * @property {!Array.<string>} representationIds
  257.  *   An array of the IDs of the Representations this AdaptationSet contains.
  258.  */
  259. shaka.dash.DashParser.AdaptationInfo;
  262. /**
  263.  * @typedef {{
  264.  *   createSegmentIndex: shakaExtern.CreateSegmentIndexFunction,
  265.  *   findSegmentPosition: shakaExtern.FindSegmentPositionFunction,
  266.  *   getSegmentReference: shakaExtern.GetSegmentReferenceFunction
  267.  * }}
  268.  *
  269.  * @description
  270.  * Contains functions used to create and find segment references.
  271.  *
  272.  * @property {shakaExtern.CreateSegmentIndexFunction} createSegmentIndex
  273.  *   The createSegmentIndex function.
  274.  * @property {shakaExtern.FindSegmentPositionFunction} findSegmentPosition
  275.  *   The findSegmentPosition function.
  276.  * @property {shakaExtern.GetSegmentReferenceFunction} getSegmentReference
  277.  *   The getSegmentReference function.
  278.  */
  279. shaka.dash.DashParser.SegmentIndexFunctions;
  282. /**
  283.  * @typedef {{
  284.  *   createSegmentIndex: shakaExtern.CreateSegmentIndexFunction,
  285.  *   findSegmentPosition: shakaExtern.FindSegmentPositionFunction,
  286.  *   getSegmentReference: shakaExtern.GetSegmentReferenceFunction,
  287.  *   initSegmentReference: shaka.media.InitSegmentReference,
  288.  *   presentationTimeOffset: (number|undefined)
  289.  * }}
  290.  *
  291.  * @description
  292.  * Contains information about a Stream.  This is passed from the createStream
  293.  * methods.
  294.  *
  295.  * @property {shakaExtern.CreateSegmentIndexFunction} createSegmentIndex
  296.  *   The createSegmentIndex function for the stream.
  297.  * @property {shakaExtern.FindSegmentPositionFunction} findSegmentPosition
  298.  *   The findSegmentPosition function for the stream.
  299.  * @property {shakaExtern.GetSegmentReferenceFunction} getSegmentReference
  300.  *   The getSegmentReference function for the stream.
  301.  * @property {shaka.media.InitSegmentReference} initSegmentReference
  302.  *   The init segment for the stream.
  303.  * @property {(number|undefined)} presentationTimeOffset
  304.  *   The presentationTimeOffset for the stream.
  305.  */
  306. shaka.dash.DashParser.StreamInfo;
  309. /**
  310.  * @override
  311.  * @exportInterface
  312.  */
  313. shaka.dash.DashParser.prototype.configure = function(config) {
  314.   goog.asserts.assert(config.dash != null,
  315.                       'DashManifestConfiguration should not be null!');
  317.   this.config_ = config;
  318. };
  321. /**
  322.  * @override
  323.  * @exportInterface
  324.  */
  325. shaka.dash.DashParser.prototype.start = function(uri, playerInterface) {
  326.   goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  327.   this.manifestUris_ = [uri];
  328.   this.playerInterface_ = playerInterface;
  329.   return this.requestManifest_().then(function() {
  330.     if (this.playerInterface_)
  331.       this.setUpdateTimer_(0);
  332.     return this.manifest_;
  333.   }.bind(this));
  334. };
  337. /**
  338.  * @override
  339.  * @exportInterface
  340.  */
  341. shaka.dash.DashParser.prototype.stop = function() {
  342.   this.playerInterface_ = null;
  343.   this.config_ = null;
  345.   this.manifestUris_ = [];
  346.   this.manifest_ = null;
  347.   this.periodIds_ = [];
  348.   this.segmentIndexMap_ = {};
  349.   if (this.updateTimer_ != null) {
  350.     window.clearTimeout(this.updateTimer_);
  351.     this.updateTimer_ = null;
  352.   }
  354.   return Promise.resolve();
  355. };
  358. /**
  359.  * @override
  360.  * @exportInterface
  361.  */
  362. shaka.dash.DashParser.prototype.update = function() {
  363.   this.requestManifest_().catch(function(error) {
  364.     if (!this.playerInterface_) return;
  365.     this.playerInterface_.onError(error);
  366.   }.bind(this));
  367. };
  370. /**
  371.  * @override
  372.  * @exportInterface
  373.  */
  374. shaka.dash.DashParser.prototype.onExpirationUpdated = function(
  375.     sessionId, expiration) {
  376.   // No-op
  377. };
  380. /**
  381.  * Makes a network request for the manifest and parses the resulting data.
  382.  *
  383.  * @return {!Promise}
  384.  * @private
  385.  */
  386. shaka.dash.DashParser.prototype.requestManifest_ = function() {
  387.   var requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  388.   var request = shaka.net.NetworkingEngine.makeRequest(
  389.       this.manifestUris_, this.config_.retryParameters);
  390.   return this.playerInterface_.networkingEngine.request(requestType, request)
  391.       .then(function(response) {
  392.         // Detect calls to stop().
  393.         if (!this.playerInterface_)
  394.           return;
  396.         // This may throw; but it will result in a failed promise.
  397.         return this.parseManifest_(response.data, response.uri);
  398.       }.bind(this));
  399. };
  402. /**
  403.  * Parses the manifest XML.  This also handles updates and will update the
  404.  * stored manifest.
  405.  *
  406.  * @param {!ArrayBuffer} data
  407.  * @param {string} finalManifestUri The final manifest URI, which may
  408.  *   differ from this.manifestUri_ if there has been a redirect.
  409.  * @return {!Promise}
  410.  * @throws shaka.util.Error When there is a parsing error.
  411.  * @private
  412.  */
  413. shaka.dash.DashParser.prototype.parseManifest_ =
  414.     function(data, finalManifestUri) {
  415.   var Error = shaka.util.Error;
  416.   var MpdUtils = shaka.dash.MpdUtils;
  418.   var mpd = MpdUtils.parseXml(data, 'MPD');
  419.   if (!mpd) {
  420.     throw new Error(
  421.         Error.Severity.CRITICAL, Error.Category.MANIFEST,
  422.         Error.Code.DASH_INVALID_XML, finalManifestUri);
  423.   }
  425.   // Process the mpd to account for xlink connections.
  426.   var failGracefully = this.config_.dash.xlinkFailGracefully;
  427.   var xlinkPromise = MpdUtils.processXlinks(
  428.       mpd, this.config_.retryParameters, failGracefully, finalManifestUri,
  429.       this.playerInterface_.networkingEngine);
  430.   return xlinkPromise.then(function(finalMpd) {
  431.     return this.processManifest_(finalMpd, finalManifestUri);
  432.   }.bind(this));
  433. };
  436. /**
  437.  * Taked a formatted MPD and converts it into a manifest.
  438.  *
  439.  * @param {!Element} mpd
  440.  * @param {string} finalManifestUri The final manifest URI, which may
  441.  *   differ from this.manifestUri_ if there has been a redirect.
  442.  * @return {!Promise}
  443.  * @throws shaka.util.Error When there is a parsing error.
  444.  * @private
  445.  */
  446. shaka.dash.DashParser.prototype.processManifest_ =
  447.     function(mpd, finalManifestUri) {
  448.   var Functional = shaka.util.Functional;
  449.   var XmlUtils = shaka.util.XmlUtils;
  450.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  452.   // Get any Location elements.  This will update the manifest location and
  453.   // the base URI.
  454.   /** @type {!Array.<string>} */
  455.   var manifestBaseUris = [finalManifestUri];
  456.   /** @type {!Array.<string>} */
  457.   var locations = XmlUtils.findChildren(mpd, 'Location')
  458.                       .map(XmlUtils.getContents)
  459.                       .filter(Functional.isNotNull);
  460.   if (locations.length > 0) {
  461.     this.manifestUris_ = locations;
  462.     manifestBaseUris = locations;
  463.   }
  465.   var uris = XmlUtils.findChildren(mpd, 'BaseURL').map(XmlUtils.getContents);
  466.   var baseUris = ManifestParserUtils.resolveUris(manifestBaseUris, uris);
  468.   var minBufferTime =
  469.       XmlUtils.parseAttr(mpd, 'minBufferTime', XmlUtils.parseDuration);
  470.   this.updatePeriod_ = /** @type {number} */ (XmlUtils.parseAttr(
  471.       mpd, 'minimumUpdatePeriod', XmlUtils.parseDuration, -1));
  473.   var presentationStartTime = XmlUtils.parseAttr(
  474.       mpd, 'availabilityStartTime', XmlUtils.parseDate);
  475.   var segmentAvailabilityDuration = XmlUtils.parseAttr(
  476.       mpd, 'timeShiftBufferDepth', XmlUtils.parseDuration);
  477.   var suggestedPresentationDelay = XmlUtils.parseAttr(
  478.       mpd, 'suggestedPresentationDelay', XmlUtils.parseDuration);
  479.   var maxSegmentDuration = XmlUtils.parseAttr(
  480.       mpd, 'maxSegmentDuration', XmlUtils.parseDuration);
  481.   var mpdType = mpd.getAttribute('type') || 'static';
  483.   /** @type {!shaka.media.PresentationTimeline} */
  484.   var presentationTimeline;
  485.   if (this.manifest_) {
  486.     presentationTimeline = this.manifest_.presentationTimeline;
  487.   } else {
  488.     // DASH IOP v3.0 suggests using a default delay between minBufferTime and
  489.     // timeShiftBufferDepth.  This is literally the range of all feasible
  490.     // choices for the value.  Nothing older than timeShiftBufferDepth is still
  491.     // available, and anything less than minBufferTime will cause buffering
  492.     // issues.
  493.     //
  494.     // We have decided that our default will be 1.5 * minBufferTime, or 10s,
  495.     // whichever is larger.  This is fairly conservative.  Content providers
  496.     // should provide a suggestedPresentationDelay whenever possible to optimize
  497.     // the live streaming experience.
  498.     var defaultPresentationDelay = Math.max(
  499.         shaka.dash.DashParser.DEFAULT_SUGGESTED_PRESENTATION_DELAY_,
  500.         minBufferTime * 1.5);
  501.     var presentationDelay = suggestedPresentationDelay != null ?
  502.         suggestedPresentationDelay : defaultPresentationDelay;
  503.     presentationTimeline = new shaka.media.PresentationTimeline(
  504.         presentationStartTime, presentationDelay);
  505.   }
  507.   /** @type {shaka.dash.DashParser.Context} */
  508.   var context = {
  509.     // Don't base on updatePeriod_ since emsg boxes can cause manifest updates.
  510.     dynamic: mpdType != 'static',
  511.     presentationTimeline: presentationTimeline,
  512.     period: null,
  513.     periodInfo: null,
  514.     adaptationSet: null,
  515.     representation: null,
  516.     bandwidth: 0,
  517.     indexRangeWarningGiven: false
  518.   };
  520.   var periodsAndDuration = this.parsePeriods_(context, baseUris, mpd);
  521.   var duration = periodsAndDuration.duration;
  522.   var periods = periodsAndDuration.periods;
  524.   presentationTimeline.setStatic(mpdType == 'static');
  525.   presentationTimeline.setDuration(duration || Infinity);
  526.   presentationTimeline.setSegmentAvailabilityDuration(
  527.       segmentAvailabilityDuration != null ?
  528.       segmentAvailabilityDuration :
  529.       Infinity);
  530.   // Use @maxSegmentDuration to override smaller, derived values.
  531.   presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
  532.   if (!COMPILED) presentationTimeline.assertIsValid();
  534.   if (this.manifest_) {
  535.     // This is a manifest update, so we're done.
  536.     return Promise.resolve();
  537.   }
  539.   // This is the first manifest parse, so we cannot return until we calculate
  540.   // the clock offset.
  541.   var timingElements = XmlUtils.findChildren(mpd, 'UTCTiming');
  543.   var isLive = presentationTimeline.isLive();
  545.   return this.parseUtcTiming_(
  546.       baseUris, timingElements, isLive).then(function(offset) {
  547.     // Detect calls to stop().
  548.     if (!this.playerInterface_)
  549.       return;
  551.     presentationTimeline.setClockOffset(offset);
  553.     this.manifest_ = {
  554.       presentationTimeline: presentationTimeline,
  555.       periods: periods,
  556.       offlineSessionIds: [],
  557.       minBufferTime: minBufferTime || 0
  558.     };
  559.   }.bind(this));
  560. };
  563. /**
  564.  * Reads and parses the periods from the manifest.  This first does some
  565.  * partial parsing so the start and duration is available when parsing children.
  566.  *
  567.  * @param {shaka.dash.DashParser.Context} context
  568.  * @param {!Array.<string>} baseUris
  569.  * @param {!Element} mpd
  570.  * @return {{periods: !Array.<shakaExtern.Period>, duration: ?number}}
  571.  * @private
  572.  */
  573. shaka.dash.DashParser.prototype.parsePeriods_ = function(
  574.     context, baseUris, mpd) {
  575.   var XmlUtils = shaka.util.XmlUtils;
  576.   var presentationDuration = XmlUtils.parseAttr(
  577.       mpd, 'mediaPresentationDuration', XmlUtils.parseDuration);
  579.   var periods = [];
  580.   var prevEnd = 0;
  581.   var periodNodes = XmlUtils.findChildren(mpd, 'Period');
  582.   for (var i = 0; i < periodNodes.length; i++) {
  583.     var elem = periodNodes[i];
  584.     var start = /** @type {number} */ (
  585.         XmlUtils.parseAttr(elem, 'start', XmlUtils.parseDuration, prevEnd));
  586.     var givenDuration =
  587.         XmlUtils.parseAttr(elem, 'duration', XmlUtils.parseDuration);
  589.     var periodDuration = null;
  590.     if (i != periodNodes.length - 1) {
  591.       // "The difference between the start time of a Period and the start time
  592.       // of the following Period is the duration of the media content
  593.       // represented by this Period."
  594.       var nextPeriod = periodNodes[i + 1];
  595.       var nextStart =
  596.           XmlUtils.parseAttr(nextPeriod, 'start', XmlUtils.parseDuration);
  597.       if (nextStart != null)
  598.         periodDuration = nextStart - start;
  599.     } else if (presentationDuration != null) {
  600.       // "The Period extends until the Period.start of the next Period, or
  601.       // until the end of the Media Presentation in the case of the last
  602.       // Period."
  603.       periodDuration = presentationDuration - start;
  604.     }
  606.     var threshold =
  607.         shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS;
  608.     if (periodDuration && givenDuration &&
  609.         Math.abs(periodDuration - givenDuration) > threshold) {
  610.       shaka.log.warning('There is a gap/overlap between Periods', elem);
  611.     }
  612.     // Only use the @duration in the MPD if we can't calculate it.  We should
  613.     // favor the @start of the following Period.  This ensures that there aren't
  614.     // gaps between Periods.
  615.     if (periodDuration == null)
  616.       periodDuration = givenDuration;
  619.     // Parse child nodes.
  620.     var info = {
  621.       start: start,
  622.       duration: periodDuration,
  623.       node: elem,
  624.       isLastPeriod: periodDuration == null || i == periodNodes.length - 1
  625.     };
  626.     var period = this.parsePeriod_(context, baseUris, info);
  627.     periods.push(period);
  629.     // If the period ID is new, add it to the list.  This must be done for both
  630.     // the initial manifest parse and for updates.
  631.     // See https://github.com/google/shaka-player/issues/963
  632.     var periodId = context.period.id;
  633.     if (this.periodIds_.indexOf(periodId) == -1) {
  634.       this.periodIds_.push(periodId);
  636.       // If this is an update, call filterNewPeriod and add it to the manifest.
  637.       // If this is the first parse of the manifest (this.manifest_ == null),
  638.       // filterAllPeriods will be called later.
  639.       if (this.manifest_) {
  640.         this.playerInterface_.filterNewPeriod(period);
  641.         this.manifest_.periods.push(period);
  642.       }
  643.     }
  645.     if (periodDuration == null) {
  646.       if (i != periodNodes.length - 1) {
  647.         // If the duration is still null and we aren't at the end, then we will
  648.         // skip any remaining periods.
  649.         shaka.log.warning(
  650.             'Skipping Period', i + 1, 'and any subsequent Periods:', 'Period',
  651.             i + 1, 'does not have a valid start time.', periods[i + 1]);
  652.       }
  654.       // The duration is unknown, so the end is unknown.
  655.       prevEnd = null;
  656.       break;
  657.     }
  659.     prevEnd = start + periodDuration;
  660.   } // end of period parsing loop
  662.   // Call filterAllPeriods if this is the initial parse.
  663.   if (this.manifest_ == null) {
  664.     this.playerInterface_.filterAllPeriods(periods);
  665.   }
  667.   if (presentationDuration != null) {
  668.     if (prevEnd != presentationDuration) {
  669.       shaka.log.warning(
  670.           '@mediaPresentationDuration does not match the total duration of all',
  671.           'Periods.');
  672.       // Assume @mediaPresentationDuration is correct.
  673.     }
  674.     return {
  675.       periods: periods,
  676.       duration: presentationDuration
  677.     };
  678.   } else {
  679.     return {
  680.       periods: periods,
  681.       duration: prevEnd
  682.     };
  683.   }
  684. };
  687. /**
  688.  * Parses a Period XML element.  Unlike the other parse methods, this is not
  689.  * given the Node; it is given a PeriodInfo structure.  Also, partial parsing
  690.  * was done before this was called so start and duration are valid.
  691.  *
  692.  * @param {shaka.dash.DashParser.Context} context
  693.  * @param {!Array.<string>} baseUris
  694.  * @param {shaka.dash.DashParser.PeriodInfo} periodInfo
  695.  * @return {shakaExtern.Period}
  696.  * @throws shaka.util.Error When there is a parsing error.
  697.  * @private
  698.  */
  699. shaka.dash.DashParser.prototype.parsePeriod_ = function(
  700.     context, baseUris, periodInfo) {
  701.   var Functional = shaka.util.Functional;
  702.   var XmlUtils = shaka.util.XmlUtils;
  703.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  705.   context.period = this.createFrame_(periodInfo.node, null, baseUris);
  706.   context.periodInfo = periodInfo;
  708.   // If the period doesn't have an ID, give it one based on its start time.
  709.   if (!context.period.id) {
  710.     shaka.log.info(
  711.         'No Period ID given for Period with start time ' + periodInfo.start +
  712.         ',  Assigning a default');
  713.     context.period.id = '__shaka_period_' + periodInfo.start;
  714.   }
  716.   var eventStreamNodes = XmlUtils.findChildren(periodInfo.node, 'EventStream');
  717.   eventStreamNodes.forEach(
  718.       this.parseEventStream_.bind(this, periodInfo.start, periodInfo.duration));
  720.   var adaptationSetNodes =
  721.       XmlUtils.findChildren(periodInfo.node, 'AdaptationSet');
  722.   var adaptationSets = adaptationSetNodes
  723.       .map(this.parseAdaptationSet_.bind(this, context))
  724.       .filter(Functional.isNotNull);
  726.   var representationIds = adaptationSets
  727.       .map(function(as) { return as.representationIds; })
  728.       .reduce(Functional.collapseArrays, []);
  729.   var uniqueRepIds = representationIds.filter(Functional.isNotDuplicate);
  730.   if (context.dynamic && representationIds.length != uniqueRepIds.length) {
  731.     throw new shaka.util.Error(
  732.         shaka.util.Error.Severity.CRITICAL,
  733.         shaka.util.Error.Category.MANIFEST,
  734.         shaka.util.Error.Code.DASH_DUPLICATE_REPRESENTATION_ID);
  735.   }
  737.   var normalAdaptationSets = adaptationSets
  738.       .filter(function(as) { return !as.trickModeFor; });
  740.   var trickModeAdaptationSets = adaptationSets
  741.       .filter(function(as) { return as.trickModeFor; });
  743.   // Attach trick mode tracks to normal tracks.
  744.   trickModeAdaptationSets.forEach(function(trickModeSet) {
  745.     // There may be multiple trick mode streams, but we do not currently
  746.     // support that.  Just choose one.
  747.     var trickModeVideo = trickModeSet.streams[0];
  748.     var targetId = trickModeSet.trickModeFor;
  749.     normalAdaptationSets.forEach(function(normalSet) {
  750.       if (normalSet.id == targetId) {
  751.         normalSet.streams.forEach(function(stream) {
  752.           stream.trickModeVideo = trickModeVideo;
  753.         });
  754.       }
  755.     });
  756.   });
  758.   var videoSets = this.getSetsOfType_(normalAdaptationSets, ContentType.VIDEO);
  759.   var audioSets = this.getSetsOfType_(normalAdaptationSets, ContentType.AUDIO);
  761.   if (!videoSets.length && !audioSets.length) {
  762.     throw new shaka.util.Error(
  763.         shaka.util.Error.Severity.CRITICAL,
  764.         shaka.util.Error.Category.MANIFEST,
  765.         shaka.util.Error.Code.DASH_EMPTY_PERIOD);
  766.   }
  768.   // In case of audio-only or video-only content, we create an array of one item
  769.   // containing a null.  This way, the double-loop works for all kinds of
  770.   // content.
  771.   if (!audioSets.length) {
  772.     audioSets = [null];
  773.   }
  774.   if (!videoSets.length) {
  775.     videoSets = [null];
  776.   }
  778.   // TODO: Limit number of combinations. Come up with a heuristic
  779.   // to decide which audio tracks to combine with which video tracks.
  780.   var variants = [];
  781.   for (var i = 0; i < audioSets.length; i++) {
  782.     for (var j = 0; j < videoSets.length; j++) {
  783.       var audioSet = audioSets[i];
  784.       var videoSet = videoSets[j];
  785.       this.createVariants_(audioSet, videoSet, variants);
  786.     }
  787.   }
  789.   var textSets = this.getSetsOfType_(normalAdaptationSets, ContentType.TEXT);
  790.   var textStreams = [];
  791.   for (var i = 0; i < textSets.length; i++) {
  792.     textStreams.push.apply(textStreams, textSets[i].streams);
  793.   }
  795.   return {
  796.     startTime: periodInfo.start,
  797.     textStreams: textStreams,
  798.     variants: variants
  799.   };
  800. };
  803. /**
  804.  * @param {!Array.<!shaka.dash.DashParser.AdaptationInfo>} adaptationSets
  805.  * @param {string} type
  806.  * @return {!Array.<!shaka.dash.DashParser.AdaptationInfo>}
  807.  * @private
  808.  */
  809. shaka.dash.DashParser.prototype.getSetsOfType_ = function(
  810.     adaptationSets, type) {
  811.   return adaptationSets.filter(function(as) {
  812.     return as.contentType == type;
  813.   });
  814. };
  817. /**
  818.  * Combines Streams into Variants
  819.  *
  820.  * @param {?shaka.dash.DashParser.AdaptationInfo} audio
  821.  * @param {?shaka.dash.DashParser.AdaptationInfo} video
  822.  * @param {!Array.<shakaExtern.Variant>} variants New variants are pushed onto
  823.  *   this array.
  824.  * @private
  825.  */
  826. shaka.dash.DashParser.prototype.createVariants_ =
  827.     function(audio, video, variants) {
  828.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  830.   // Since both audio and video are of the same type, this assertion will catch
  831.   // certain mistakes at runtime that the compiler would miss.
  832.   goog.asserts.assert(!audio || audio.contentType == ContentType.AUDIO,
  833.                       'Audio parameter mismatch!');
  834.   goog.asserts.assert(!video || video.contentType == ContentType.VIDEO,
  835.                       'Video parameter mismatch!');
  837.   /** @type {number} */
  838.   var bandwidth;
  839.   /** @type {shakaExtern.Variant} */
  840.   var variant;
  842.   if (!audio && !video) {
  843.     return;
  844.   } else if (audio && video) {
  845.     // Audio+video variants
  846.     var DrmEngine = shaka.media.DrmEngine;
  847.     if (DrmEngine.areDrmCompatible(audio.drmInfos, video.drmInfos)) {
  848.       var drmInfos = DrmEngine.getCommonDrmInfos(audio.drmInfos,
  849.                                                  video.drmInfos);
  851.       for (var i = 0; i < audio.streams.length; i++) {
  852.         for (var j = 0; j < video.streams.length; j++) {
  853.           bandwidth =
  854.               (video.streams[j].bandwidth || 0) +
  855.               (audio.streams[i].bandwidth || 0);
  856.           variant = {
  857.             id: this.globalId_++,
  858.             language: audio.language,
  859.             primary: audio.main || video.main,
  860.             audio: audio.streams[i],
  861.             video: video.streams[j],
  862.             bandwidth: bandwidth,
  863.             drmInfos: drmInfos,
  864.             allowedByApplication: true,
  865.             allowedByKeySystem: true
  866.           };
  868.           variants.push(variant);
  869.         }
  870.       }
  871.     }
  872.   } else {
  873.     // Audio or video only variants
  874.     var set = audio || video;
  875.     for (var i = 0; i < set.streams.length; i++) {
  876.       bandwidth = set.streams[i].bandwidth || 0;
  877.       variant = {
  878.         id: this.globalId_++,
  879.         language: set.language || 'und',
  880.         primary: set.main,
  881.         audio: audio ? set.streams[i] : null,
  882.         video: video ? set.streams[i] : null,
  883.         bandwidth: bandwidth,
  884.         drmInfos: set.drmInfos,
  885.         allowedByApplication: true,
  886.         allowedByKeySystem: true
  887.       };
  889.       variants.push(variant);
  890.     }
  891.   }
  892. };
  895. /**
  896.  * Parses an AdaptationSet XML element.
  897.  *
  898.  * @param {shaka.dash.DashParser.Context} context
  899.  * @param {!Element} elem The AdaptationSet element.
  900.  * @return {?shaka.dash.DashParser.AdaptationInfo}
  901.  * @throws shaka.util.Error When there is a parsing error.
  902.  * @private
  903.  */
  904. shaka.dash.DashParser.prototype.parseAdaptationSet_ = function(context, elem) {
  905.   var XmlUtils = shaka.util.XmlUtils;
  906.   var Functional = shaka.util.Functional;
  907.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  908.   var ContentType = ManifestParserUtils.ContentType;
  910.   context.adaptationSet = this.createFrame_(elem, context.period, null);
  912.   var main = false;
  913.   var roleElements = XmlUtils.findChildren(elem, 'Role');
  914.   var roleValues = roleElements.map(function(role) {
  915.     return role.getAttribute('value');
  916.   }).filter(Functional.isNotNull);
  918.   // Default kind for text streams is 'subtitle' if unspecified in the manifest.
  919.   var kind = undefined;
  920.   if (context.adaptationSet.contentType == ManifestParserUtils.ContentType.TEXT)
  921.     kind = ManifestParserUtils.TextStreamKind.SUBTITLE;
  923.   for (var i = 0; i < roleElements.length; i++) {
  924.     var scheme = roleElements[i].getAttribute('schemeIdUri');
  925.     if (scheme == null || scheme == 'urn:mpeg:dash:role:2011') {
  926.       // These only apply for the given scheme, but allow them to be specified
  927.       // if there is no scheme specified.
  928.       // See: DASH section 5.8.5.5
  929.       var value = roleElements[i].getAttribute('value');
  930.       switch (value) {
  931.         case 'main':
  932.           main = true;
  933.           break;
  934.         case 'caption':
  935.         case 'subtitle':
  936.           kind = value;
  937.           break;
  938.       }
  939.     }
  940.   }
  942.   var essentialProperties = XmlUtils.findChildren(elem, 'EssentialProperty');
  943.   // ID of real AdaptationSet if this is a trick mode set:
  944.   var trickModeFor = null;
  945.   var unrecognizedEssentialProperty = false;
  946.   essentialProperties.forEach(function(prop) {
  947.     var schemeId = prop.getAttribute('schemeIdUri');
  948.     if (schemeId == 'http://dashif.org/guidelines/trickmode') {
  949.       trickModeFor = prop.getAttribute('value');
  950.     } else {
  951.       unrecognizedEssentialProperty = true;
  952.     }
  953.   });
  955.   // According to DASH spec (2014) section 5.8.4.8, "the successful processing
  956.   // of the descriptor is essential to properly use the information in the
  957.   // parent element".  According to DASH IOP v3.3, section 3.3.4, "if the scheme
  958.   // or the value" for EssentialProperty is not recognized, "the DASH client
  959.   // shall ignore the parent element."
  960.   if (unrecognizedEssentialProperty) {
  961.     // Stop parsing this AdaptationSet and let the caller filter out the nulls.
  962.     return null;
  963.   }
  965.   var contentProtectionElems = XmlUtils.findChildren(elem, 'ContentProtection');
  966.   var contentProtection = shaka.dash.ContentProtection.parseFromAdaptationSet(
  967.       contentProtectionElems, this.config_.dash.customScheme,
  968.       this.config_.dash.ignoreDrmInfo);
  970.   var language =
  971.       shaka.util.LanguageUtils.normalize(elem.getAttribute('lang') || 'und');
  973.   // non-standard attribute(yet) supported by Kaltura
  974.   var label = elem.getAttribute('label');
  976.   // Parse Representations into Streams.
  977.   var representations = XmlUtils.findChildren(elem, 'Representation');
  978.   var streams = representations
  979.       .map(this.parseRepresentation_.bind(this, context, contentProtection,
  980.           kind, language, label, main, roleValues))
  981.       .filter(function(s) { return !!s; });
  983.   if (streams.length == 0) {
  984.     throw new shaka.util.Error(
  985.         shaka.util.Error.Severity.CRITICAL,
  986.         shaka.util.Error.Category.MANIFEST,
  987.         shaka.util.Error.Code.DASH_EMPTY_ADAPTATION_SET);
  988.   }
  990.   // If AdaptationSet's type is unknown or is ambiguously "application",
  991.   // guess based on the information in the first stream.  If the attributes
  992.   // mimeType and codecs are split across levels, they will both be inherited
  993.   // down to the stream level by this point, so the stream will have all the
  994.   // necessary information.
  995.   if (!context.adaptationSet.contentType ||
  996.       context.adaptationSet.contentType == ContentType.APPLICATION) {
  997.     var mimeType = streams[0].mimeType;
  998.     var codecs = streams[0].codecs;
  999.     context.adaptationSet.contentType =
  1000.         shaka.dash.DashParser.guessContentType_(mimeType, codecs);
  1002.     streams.forEach(function(stream) {
  1003.       stream.type = context.adaptationSet.contentType;
  1004.     });
  1005.   }
  1007.   streams.forEach(function(stream) {
  1008.     // Some DRM license providers require that we have a default
  1009.     // key ID from the manifest in the wrapped license request.
  1010.     // Thus, it should be put in drmInfo to be accessible to request filters.
  1011.     contentProtection.drmInfos.forEach(function(drmInfo) {
  1012.       if (stream.keyId) {
  1013.         drmInfo.keyIds.push(stream.keyId);
  1014.       }
  1015.     });
  1016.   });
  1018.   var repIds = representations
  1019.       .map(function(node) { return node.getAttribute('id'); })
  1020.       .filter(shaka.util.Functional.isNotNull);
  1022.   return {
  1023.     id: context.adaptationSet.id || ('__fake__' + this.globalId_++),
  1024.     contentType: context.adaptationSet.contentType,
  1025.     language: language,
  1026.     main: main,
  1027.     streams: streams,
  1028.     drmInfos: contentProtection.drmInfos,
  1029.     trickModeFor: trickModeFor,
  1030.     representationIds: repIds
  1031.   };
  1032. };
  1035. /**
  1036.  * Parses a Representation XML element.
  1037.  *
  1038.  * @param {shaka.dash.DashParser.Context} context
  1039.  * @param {shaka.dash.ContentProtection.Context} contentProtection
  1040.  * @param {(string|undefined)} kind
  1041.  * @param {string} language
  1042.  * @param {string} label
  1043.  * @param {boolean} isPrimary
  1044.  * @param {!Array.<string>} roles
  1045.  * @param {!Element} node
  1046.  * @return {?shakaExtern.Stream} The Stream, or null when there is a
  1047.  *   non-critical parsing error.
  1048.  * @throws shaka.util.Error When there is a parsing error.
  1049.  * @private
  1050.  */
  1051. shaka.dash.DashParser.prototype.parseRepresentation_ = function(
  1052.     context, contentProtection, kind, language, label, isPrimary, roles, node) {
  1053.   var XmlUtils = shaka.util.XmlUtils;
  1054.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1056.   context.representation = this.createFrame_(node, context.adaptationSet, null);
  1057.   if (!this.verifyRepresentation_(context.representation)) {
  1058.     shaka.log.warning('Skipping Representation', context.representation);
  1059.     return null;
  1060.   }
  1062.   // NOTE: bandwidth is a mandatory attribute according to the spec, and zero
  1063.   // does not make sense in the DASH spec's bandwidth formulas.
  1064.   // In some content, however, the attribute is missing or zero.
  1065.   // To avoid NaN at the variant level on broken content, fall back to zero.
  1066.   // https://github.com/google/shaka-player/issues/938#issuecomment-317278180
  1067.   context.bandwidth =
  1068.       XmlUtils.parseAttr(node, 'bandwidth', XmlUtils.parsePositiveInt) || 0;
  1070.   /** @type {?shaka.dash.DashParser.StreamInfo} */
  1071.   var streamInfo;
  1072.   var requestInitSegment = this.requestInitSegment_.bind(this);
  1073.   if (context.representation.segmentBase) {
  1074.     streamInfo = shaka.dash.SegmentBase.createStream(
  1075.         context, requestInitSegment);
  1076.   } else if (context.representation.segmentList) {
  1077.     streamInfo = shaka.dash.SegmentList.createStream(
  1078.         context, this.segmentIndexMap_);
  1079.   } else if (context.representation.segmentTemplate) {
  1080.     streamInfo = shaka.dash.SegmentTemplate.createStream(
  1081.         context, requestInitSegment, this.segmentIndexMap_, !!this.manifest_);
  1082.   } else {
  1083.     goog.asserts.assert(
  1084.         context.representation.contentType == ContentType.TEXT ||
  1085.         context.representation.contentType == ContentType.APPLICATION,
  1086.         'Must have Segment* with non-text streams.');
  1088.     var baseUris = context.representation.baseUris;
  1089.     var duration = context.periodInfo.duration || 0;
  1090.     streamInfo = {
  1091.       createSegmentIndex: Promise.resolve.bind(Promise),
  1092.       findSegmentPosition:
  1093.           /** @return {?number} */ function(/** number */ time) {
  1094.             if (time >= 0 && time < duration)
  1095.               return 1;
  1096.             else
  1097.               return null;
  1098.           },
  1099.       getSegmentReference:
  1100.           /** @return {shaka.media.SegmentReference} */
  1101.           function(/** number */ ref) {
  1102.             if (ref != 1)
  1103.               return null;
  1105.             return new shaka.media.SegmentReference(
  1106.                 1, 0, duration, function() { return baseUris; }, 0, null);
  1107.           },
  1108.       initSegmentReference: null,
  1109.       presentationTimeOffset: 0
  1110.     };
  1111.   }
  1113.   var contentProtectionElems = XmlUtils.findChildren(node, 'ContentProtection');
  1114.   var keyId = shaka.dash.ContentProtection.parseFromRepresentation(
  1115.       contentProtectionElems, this.config_.dash.customScheme,
  1116.       contentProtection, this.config_.dash.ignoreDrmInfo);
  1118.   return {
  1119.     id: this.globalId_++,
  1120.     createSegmentIndex: streamInfo.createSegmentIndex,
  1121.     findSegmentPosition: streamInfo.findSegmentPosition,
  1122.     getSegmentReference: streamInfo.getSegmentReference,
  1123.     initSegmentReference: streamInfo.initSegmentReference,
  1124.     presentationTimeOffset: streamInfo.presentationTimeOffset,
  1125.     mimeType: context.representation.mimeType,
  1126.     codecs: context.representation.codecs,
  1127.     frameRate: context.representation.frameRate,
  1128.     bandwidth: context.bandwidth,
  1129.     width: context.representation.width,
  1130.     height: context.representation.height,
  1131.     kind: kind,
  1132.     encrypted: contentProtection.drmInfos.length > 0,
  1133.     keyId: keyId,
  1134.     language: language,
  1135.     label: label,
  1136.     type: context.adaptationSet.contentType,
  1137.     primary: isPrimary,
  1138.     trickModeVideo: null,
  1139.     containsEmsgBoxes: context.representation.containsEmsgBoxes,
  1140.     roles: roles,
  1141.     channelsCount: context.representation.numChannels
  1142.   };
  1143. };
  1146. /**
  1147.  * Called when the update timer ticks.
  1148.  *
  1149.  * @private
  1150.  */
  1151. shaka.dash.DashParser.prototype.onUpdate_ = function() {
  1152.   goog.asserts.assert(this.updateTimer_, 'Should only be called by timer');
  1153.   goog.asserts.assert(this.updatePeriod_ >= 0,
  1154.                       'There should be an update period');
  1156.   shaka.log.info('Updating manifest...');
  1158.   this.updateTimer_ = null;
  1159.   var startTime = Date.now();
  1161.   this.requestManifest_().then(function() {
  1162.     // Detect a call to stop()
  1163.     if (!this.playerInterface_)
  1164.       return;
  1166.     // Ensure the next update occurs within |updatePeriod_| seconds by taking
  1167.     // into account the time it took to update the manifest.
  1168.     var endTime = Date.now();
  1169.     this.setUpdateTimer_((endTime - startTime) / 1000.0);
  1170.   }.bind(this)).catch(function(error) {
  1171.     goog.asserts.assert(error instanceof shaka.util.Error,
  1172.                         'Should only receive a Shaka error');
  1174.     // Try updating again, but ensure we haven't been destroyed.
  1175.     if (this.playerInterface_) {
  1176.       // We will retry updating, so override the severity of the error.
  1177.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  1178.       this.playerInterface_.onError(error);
  1180.       this.setUpdateTimer_(0);
  1181.     }
  1182.   }.bind(this));
  1183. };
  1186. /**
  1187.  * Sets the update timer.  Does nothing if the manifest does not specify an
  1188.  * update period.
  1189.  *
  1190.  * @param {number} offset An offset, in seconds, to apply to the manifest's
  1191.  *   update period.
  1192.  * @private
  1193.  */
  1194. shaka.dash.DashParser.prototype.setUpdateTimer_ = function(offset) {
  1195.   // NOTE: An updatePeriod_ of -1 means the attribute was missing.
  1196.   // An attribute which is present and set to 0 should still result in periodic
  1197.   // updates. For more, see: https://github.com/google/shaka-player/issues/331
  1198.   if (this.updatePeriod_ < 0)
  1199.     return;
  1200.   goog.asserts.assert(this.updateTimer_ == null,
  1201.                       'Timer should not be already set');
  1203.   var period =
  1204.       Math.max(shaka.dash.DashParser.MIN_UPDATE_PERIOD_, this.updatePeriod_);
  1205.   var interval = Math.max(period - offset, 0);
  1206.   shaka.log.debug('updateInterval', interval);
  1208.   var callback = this.onUpdate_.bind(this);
  1209.   this.updateTimer_ = window.setTimeout(callback, 1000 * interval);
  1210. };
  1213. /**
  1214.  * Creates a new inheritance frame for the given element.
  1215.  *
  1216.  * @param {!Element} elem
  1217.  * @param {?shaka.dash.DashParser.InheritanceFrame} parent
  1218.  * @param {Array.<string>} baseUris
  1219.  * @return {shaka.dash.DashParser.InheritanceFrame}
  1220.  * @private
  1221.  */
  1222. shaka.dash.DashParser.prototype.createFrame_ = function(
  1223.     elem, parent, baseUris) {
  1224.   goog.asserts.assert(parent || baseUris,
  1225.                       'Must provide either parent or baseUris');
  1226.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  1227.   var XmlUtils = shaka.util.XmlUtils;
  1228.   parent = parent || /** @type {shaka.dash.DashParser.InheritanceFrame} */ ({
  1229.     contentType: '',
  1230.     mimeType: '',
  1231.     codecs: '',
  1232.     containsEmsgBoxes: false,
  1233.     frameRate: undefined,
  1234.     numChannels: null
  1235.   });
  1236.   baseUris = baseUris || parent.baseUris;
  1238.   var parseNumber = XmlUtils.parseNonNegativeInt;
  1239.   var evalDivision = XmlUtils.evalDivision;
  1240.   var uris = XmlUtils.findChildren(elem, 'BaseURL').map(XmlUtils.getContents);
  1242.   var contentType = elem.getAttribute('contentType') || parent.contentType;
  1243.   var mimeType = elem.getAttribute('mimeType') || parent.mimeType;
  1244.   var codecs = elem.getAttribute('codecs') || parent.codecs;
  1245.   var frameRate =
  1246.       XmlUtils.parseAttr(elem, 'frameRate', evalDivision) || parent.frameRate;
  1247.   var containsEmsgBoxes =
  1248.       !!XmlUtils.findChildren(elem, 'InbandEventStream').length;
  1249.   var audioChannelConfigs =
  1250.       XmlUtils.findChildren(elem, 'AudioChannelConfiguration');
  1251.   var numChannels =
  1252.       this.parseAudioChannels_(audioChannelConfigs) || parent.numChannels;
  1254.   if (!contentType) {
  1255.     contentType = shaka.dash.DashParser.guessContentType_(mimeType, codecs);
  1256.   }
  1258.   return {
  1259.     baseUris: ManifestParserUtils.resolveUris(baseUris, uris),
  1260.     segmentBase: XmlUtils.findChild(elem, 'SegmentBase') || parent.segmentBase,
  1261.     segmentList: XmlUtils.findChild(elem, 'SegmentList') || parent.segmentList,
  1262.     segmentTemplate:
  1263.         XmlUtils.findChild(elem, 'SegmentTemplate') || parent.segmentTemplate,
  1264.     width: XmlUtils.parseAttr(elem, 'width', parseNumber) || parent.width,
  1265.     height: XmlUtils.parseAttr(elem, 'height', parseNumber) || parent.height,
  1266.     contentType: contentType,
  1267.     mimeType: mimeType,
  1268.     codecs: codecs,
  1269.     frameRate: frameRate,
  1270.     containsEmsgBoxes: containsEmsgBoxes || parent.containsEmsgBoxes,
  1271.     id: elem.getAttribute('id'),
  1272.     numChannels: numChannels
  1273.   };
  1274. };
  1277. /**
  1278.  * @param {!Array.<!Element>} audioChannelConfigs an array of
  1279.  *   AudioChannelConfiguration elements
  1280.  * @return {?number} the number of audio channels, or null if unknown
  1281.  * @private
  1282.  */
  1283. shaka.dash.DashParser.prototype.parseAudioChannels_ =
  1284.     function(audioChannelConfigs) {
  1285.   for (var i = 0; i < audioChannelConfigs.length; ++i) {
  1286.     var elem = audioChannelConfigs[i];
  1288.     var scheme = elem.getAttribute('schemeIdUri');
  1289.     if (!scheme) continue;
  1291.     var value = elem.getAttribute('value');
  1292.     if (!value) continue;
  1294.     switch (scheme) {
  1295.       case 'urn:mpeg:dash:outputChannelPositionList:2012':
  1296.         // A space-separated list of speaker positions, so num channels is the
  1297.         // length of this list.
  1298.         return value.trim().split(/ +/).length;
  1300.       case 'urn:mpeg:dash:23003:3:audio_channel_configuration:2011':
  1301.       case 'urn:dts:dash:audio_channel_configuration:2012':
  1302.         // As far as we can tell, this is a number of channels.
  1303.         var intValue = parseInt(value, 10);
  1304.         if (!intValue) {  // 0 or NaN
  1305.           shaka.log.warning('Channel parsing failure! ' +
  1306.                             'Ignoring scheme and value', scheme, value);
  1307.           continue;
  1308.         }
  1309.         return intValue;
  1311.       case 'tag:dolby.com,2014:dash:audio_channel_configuration:2011':
  1312.       case 'urn:dolby:dash:audio_channel_configuration:2011':
  1313.         // A hex-encoded 16-bit integer, in which each bit represents a channel.
  1314.         var hexValue = parseInt(value, 16);
  1315.         if (!hexValue) {  // 0 or NaN
  1316.           shaka.log.warning('Channel parsing failure! ' +
  1317.                             'Ignoring scheme and value', scheme, value);
  1318.           continue;
  1319.         }
  1320.         // Count the 1-bits in hexValue.
  1321.         var numBits = 0;
  1322.         while (hexValue) {
  1323.           if (hexValue & 1) ++numBits;
  1324.           hexValue >>= 1;
  1325.         }
  1326.         return numBits;
  1328.       default:
  1329.         shaka.log.warning('Unrecognized audio channel scheme:', scheme, value);
  1330.         continue;
  1331.     }
  1332.   }
  1334.   return null;
  1335. };
  1338. /**
  1339.  * Verifies that a Representation has exactly one Segment* element.  Prints
  1340.  * warnings if there is a problem.
  1341.  *
  1342.  * @param {shaka.dash.DashParser.InheritanceFrame} frame
  1343.  * @return {boolean} True if the Representation is usable; otherwise return
  1344.  *   false.
  1345.  * @private
  1346.  */
  1347. shaka.dash.DashParser.prototype.verifyRepresentation_ = function(frame) {
  1348.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1350.   var n = 0;
  1351.   n += frame.segmentBase ? 1 : 0;
  1352.   n += frame.segmentList ? 1 : 0;
  1353.   n += frame.segmentTemplate ? 1 : 0;
  1355.   if (n == 0) {
  1356.     // TODO: extend with the list of MIME types registered to TextEngine.
  1357.     if (frame.contentType == ContentType.TEXT ||
  1358.         frame.contentType == ContentType.APPLICATION) {
  1359.       return true;
  1360.     } else {
  1361.       shaka.log.warning(
  1362.           'Representation does not contain a segment information source:',
  1363.           'the Representation must contain one of SegmentBase, SegmentList,',
  1364.           'SegmentTemplate, or explicitly indicate that it is "text".',
  1365.           frame);
  1366.       return false;
  1367.     }
  1368.   }
  1370.   if (n != 1) {
  1371.     shaka.log.warning(
  1372.         'Representation contains multiple segment information sources:',
  1373.         'the Representation should only contain one of SegmentBase,',
  1374.         'SegmentList, or SegmentTemplate.',
  1375.         frame);
  1376.     if (frame.segmentBase) {
  1377.       shaka.log.info('Using SegmentBase by default.');
  1378.       frame.segmentList = null;
  1379.       frame.segmentTemplate = null;
  1380.     } else {
  1381.       goog.asserts.assert(frame.segmentList, 'There should be a SegmentList');
  1382.       shaka.log.info('Using SegmentList by default.');
  1383.       frame.segmentTemplate = null;
  1384.     }
  1385.   }
  1387.   return true;
  1388. };
  1391. /**
  1392.  * Makes a request to the given URI and calculates the clock offset.
  1393.  *
  1394.  * @param {!Array.<string>} baseUris
  1395.  * @param {string} uri
  1396.  * @param {string} method
  1397.  * @return {!Promise.<number>}
  1398.  * @private
  1399.  */
  1400. shaka.dash.DashParser.prototype.requestForTiming_ =
  1401.     function(baseUris, uri, method) {
  1402.   var requestUris = shaka.util.ManifestParserUtils.resolveUris(baseUris, [uri]);
  1403.   var request = shaka.net.NetworkingEngine.makeRequest(
  1404.       requestUris, this.config_.retryParameters);
  1405.   request.method = method;
  1406.   var type = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  1407.   return this.playerInterface_.networkingEngine.request(type, request)
  1408.       .then(function(response) {
  1409.         var text;
  1410.         if (method == 'HEAD') {
  1411.           if (!response.headers || !response.headers['date']) return 0;
  1413.           text = response.headers['date'];
  1414.         } else {
  1415.           text = shaka.util.StringUtils.fromUTF8(response.data);
  1416.         }
  1418.         var date = Date.parse(text);
  1419.         return isNaN(date) ? 0 : (date - Date.now());
  1420.       });
  1421. };
  1424. /**
  1425.  * Parses an array of UTCTiming elements.
  1426.  *
  1427.  * @param {!Array.<string>} baseUris
  1428.  * @param {!Array.<!Element>} elems
  1429.  * @param {boolean} isLive
  1430.  * @return {!Promise.<number>}
  1431.  * @private
  1432.  */
  1433. shaka.dash.DashParser.prototype.parseUtcTiming_ =
  1434.     function(baseUris, elems, isLive) {
  1435.   var schemesAndValues = elems.map(function(elem) {
  1436.     return {
  1437.       scheme: elem.getAttribute('schemeIdUri'),
  1438.       value: elem.getAttribute('value')
  1439.     };
  1440.   });
  1442.   // If there's nothing specified in the manifest, but we have a default from
  1443.   // the config, use that.
  1444.   var clockSyncUri = this.config_.dash.clockSyncUri;
  1445.   if (isLive && !schemesAndValues.length && clockSyncUri) {
  1446.     schemesAndValues.push({
  1447.       scheme: 'urn:mpeg:dash:utc:http-head:2014',
  1448.       value: clockSyncUri
  1449.     });
  1450.   }
  1452.   var Functional = shaka.util.Functional;
  1453.   return Functional.createFallbackPromiseChain(schemesAndValues, function(sv) {
  1454.     var scheme = sv.scheme;
  1455.     var value = sv.value;
  1456.     switch (scheme) {
  1457.       // See DASH IOP Guidelines Section 4.7
  1458.       // http://goo.gl/CQFNJT
  1459.       case 'urn:mpeg:dash:utc:http-head:2014':
  1460.       // Some old ISO23009-1 drafts used 2012.
  1461.       case 'urn:mpeg:dash:utc:http-head:2012':
  1462.         return this.requestForTiming_(baseUris, value, 'HEAD');
  1463.       case 'urn:mpeg:dash:utc:http-xsdate:2014':
  1464.       case 'urn:mpeg:dash:utc:http-iso:2014':
  1465.       case 'urn:mpeg:dash:utc:http-xsdate:2012':
  1466.       case 'urn:mpeg:dash:utc:http-iso:2012':
  1467.         return this.requestForTiming_(baseUris, value, 'GET');
  1468.       case 'urn:mpeg:dash:utc:direct:2014':
  1469.       case 'urn:mpeg:dash:utc:direct:2012':
  1470.         var date = Date.parse(value);
  1471.         return isNaN(date) ? 0 : (date - Date.now());
  1473.       case 'urn:mpeg:dash:utc:http-ntp:2014':
  1474.       case 'urn:mpeg:dash:utc:ntp:2014':
  1475.       case 'urn:mpeg:dash:utc:sntp:2014':
  1476.         shaka.log.warning('NTP UTCTiming scheme is not supported');
  1477.         return Promise.reject();
  1478.       default:
  1479.         shaka.log.warning(
  1480.             'Unrecognized scheme in UTCTiming element', scheme);
  1481.         return Promise.reject();
  1482.     }
  1483.   }.bind(this)).catch(function() {
  1484.     if (isLive) {
  1485.       shaka.log.warning(
  1486.           'A UTCTiming element should always be given in live manifests! ' +
  1487.           'This content may not play on clients with bad clocks!');
  1488.     }
  1489.     return 0;
  1490.   });
  1491. };
  1494. /**
  1495.  * Parses an EventStream element.
  1496.  *
  1497.  * @param {number} periodStart
  1498.  * @param {?number} periodDuration
  1499.  * @param {!Element} elem
  1500.  * @private
  1501.  */
  1502. shaka.dash.DashParser.prototype.parseEventStream_ = function(
  1503.     periodStart, periodDuration, elem) {
  1504.   var XmlUtils = shaka.util.XmlUtils;
  1505.   var parseNumber = XmlUtils.parseNonNegativeInt;
  1507.   var schemeIdUri = elem.getAttribute('schemeIdUri') || '';
  1508.   var value = elem.getAttribute('value') || '';
  1509.   var timescale = XmlUtils.parseAttr(elem, 'timescale', parseNumber) || 1;
  1511.   XmlUtils.findChildren(elem, 'Event').forEach(function(eventNode) {
  1512.     var presentationTime =
  1513.         XmlUtils.parseAttr(eventNode, 'presentationTime', parseNumber) || 0;
  1514.     var duration = XmlUtils.parseAttr(eventNode, 'duration', parseNumber) || 0;
  1516.     var startTime = presentationTime / timescale + periodStart;
  1517.     var endTime = startTime + (duration / timescale);
  1518.     if (periodDuration != null) {
  1519.       // An event should not go past the Period, even if the manifest says so.
  1520.       // See: Dash sec. 5.10.2.1
  1521.       startTime = Math.min(startTime, periodStart + periodDuration);
  1522.       endTime = Math.min(endTime, periodStart + periodDuration);
  1523.     }
  1525.     /** @type {shakaExtern.TimelineRegionInfo} */
  1526.     var region = {
  1527.       schemeIdUri: schemeIdUri,
  1528.       value: value,
  1529.       startTime: startTime,
  1530.       endTime: endTime,
  1531.       id: eventNode.getAttribute('id') || '',
  1532.       eventElement: eventNode
  1533.     };
  1535.     this.playerInterface_.onTimelineRegionAdded(region);
  1536.   }.bind(this));
  1537. };
  1540. /**
  1541.  * Makes a network request on behalf of SegmentBase.createStream.
  1542.  *
  1543.  * @param {!Array.<string>} uris
  1544.  * @param {?number} startByte
  1545.  * @param {?number} endByte
  1546.  * @return {!Promise.<!ArrayBuffer>}
  1547.  * @private
  1548.  */
  1549. shaka.dash.DashParser.prototype.requestInitSegment_ = function(
  1550.     uris, startByte, endByte) {
  1551.   var requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1552.   var request = shaka.net.NetworkingEngine.makeRequest(
  1553.       uris, this.config_.retryParameters);
  1554.   if (startByte != null) {
  1555.     var end = (endByte != null ? endByte : '');
  1556.     request.headers['Range'] = 'bytes=' + startByte + '-' + end;
  1557.   }
  1559.   return this.playerInterface_.networkingEngine.request(requestType, request)
  1560.       .then(function(response) { return response.data; });
  1561. };
  1564. /**
  1565.  * Guess the content type based on MIME type and codecs.
  1566.  *
  1567.  * @param {string} mimeType
  1568.  * @param {string} codecs
  1569.  * @return {string}
  1570.  * @private
  1571.  */
  1572. shaka.dash.DashParser.guessContentType_ = function(mimeType, codecs) {
  1573.   var fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
  1575.   if (shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  1576.     // If it's supported by TextEngine, it's definitely text.
  1577.     // We don't check MediaSourceEngine, because that would report support
  1578.     // for platform-supported video and audio types as well.
  1579.     return shaka.util.ManifestParserUtils.ContentType.TEXT;
  1580.   }
  1582.   // Otherwise, just split the MIME type.  This handles video and audio
  1583.   // types well.
  1584.   return mimeType.split('/')[0];
  1585. };
  1588. shaka.media.ManifestParser.registerParserByExtension(
  1589.     'mpd', shaka.dash.DashParser);
  1590. shaka.media.ManifestParser.registerParserByMime(
  1591.     'application/dash+xml', shaka.dash.DashParser);