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.media.TextEngine');
  31. goog.require('shaka.net.NetworkingEngine');
  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.StreamUtils');
  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.  * }}
  130.  *
  131.  * @description
  132.  * A collection of elements and properties which are inherited across levels
  133.  * of a DASH manifest.
  134.  *
  135.  * @property {Element} segmentBase
  136.  *   The XML node for SegmentBase.
  137.  * @property {Element} segmentList
  138.  *   The XML node for SegmentList.
  139.  * @property {Element} segmentTemplate
  140.  *   The XML node for SegmentTemplate.
  141.  * @property {!Array.<string>} baseUris
  142.  *   An array of absolute base URIs for the frame.
  143.  * @property {(number|undefined)} width
  144.  *   The inherited width value.
  145.  * @property {(number|undefined)} height
  146.  *   The inherited height value.
  147.  * @property {string} contentType
  148.  *   The inherited media type.
  149.  * @property {string} mimeType
  150.  *   The inherited MIME type value.
  151.  * @property {string} codecs
  152.  *   The inherited codecs value.
  153.  * @property {(number|undefined)} frameRate
  154.  *   The inherited framerate value.
  155.  * @property {boolean} containsEmsgBoxes
  156.  *   Whether there are 'emsg' boxes.
  157.  * @property {string} id
  158.  *   The ID of the element.
  159.  */
  160. shaka.dash.DashParser.InheritanceFrame;
  163. /**
  164.  * @typedef {{
  165.  *   dynamic: boolean,
  166.  *   presentationTimeline: !shaka.media.PresentationTimeline,
  167.  *   period: ?shaka.dash.DashParser.InheritanceFrame,
  168.  *   periodInfo: ?shaka.dash.DashParser.PeriodInfo,
  169.  *   adaptationSet: ?shaka.dash.DashParser.InheritanceFrame,
  170.  *   representation: ?shaka.dash.DashParser.InheritanceFrame,
  171.  *   bandwidth: (number|undefined),
  172.  *   indexRangeWarningGiven: boolean
  173.  * }}
  174.  *
  175.  * @description
  176.  * Contains context data for the streams.
  177.  *
  178.  * @property {boolean} dynamic
  179.  *   True if the MPD is dynamic (not all segments available at once)
  180.  * @property {!shaka.media.PresentationTimeline} presentationTimeline
  181.  *   The PresentationTimeline.
  182.  * @property {?shaka.dash.DashParser.InheritanceFrame} period
  183.  *   The inheritance from the Period element.
  184.  * @property {?shaka.dash.DashParser.PeriodInfo} periodInfo
  185.  *   The Period info for the current Period.
  186.  * @property {?shaka.dash.DashParser.InheritanceFrame} adaptationSet
  187.  *   The inheritance from the AdaptationSet element.
  188.  * @property {?shaka.dash.DashParser.InheritanceFrame} representation
  189.  *   The inheritance from the Representation element.
  190.  * @property {(number|undefined)} bandwidth
  191.  *   The bandwidth of the Representation.
  192.  * @property {boolean} indexRangeWarningGiven
  193.  *   True if the warning about SegmentURL@indexRange has been printed.
  194.  */
  195. shaka.dash.DashParser.Context;
  198. /**
  199.  * @typedef {{
  200.  *   start: number,
  201.  *   duration: ?number,
  202.  *   node: !Element,
  203.  *   isLastPeriod: boolean
  204.  * }}
  205.  *
  206.  * @description
  207.  * Contains information about a Period element.
  208.  *
  209.  * @property {number} start
  210.  *   The start time of the period.
  211.  * @property {?number} duration
  212.  *   The duration of the period; or null if the duration is not given.  This
  213.  *   will be non-null for all periods except the last.
  214.  * @property {!Element} node
  215.  *   The XML Node for the Period.
  216.  * @property {boolean} isLastPeriod
  217.  *   Whether this Period is the last one in the manifest.
  218.  */
  219. shaka.dash.DashParser.PeriodInfo;
  222. /**
  223.  * @typedef {{
  224.  *   id: string,
  225.  *   contentType: ?string,
  226.  *   language: string,
  227.  *   main: boolean,
  228.  *   streams: !Array.<shakaExtern.Stream>,
  229.  *   drmInfos: !Array.<shakaExtern.DrmInfo>,
  230.  *   trickModeFor: ?string,
  231.  *   representationIds: !Array.<string>
  232.  * }}
  233.  *
  234.  * @description
  235.  * Contains information about an AdaptationSet element.
  236.  *
  237.  * @property {string} id
  238.  *   The unique ID of the adaptation set.
  239.  * @property {?string} contentType
  240.  *   The content type of the AdaptationSet.
  241.  * @property {string} language
  242.  *   The language of the AdaptationSet.
  243.  * @property {boolean} main
  244.  *   Whether the AdaptationSet has the 'main' type.
  245.  * @property {!Array.<shakaExtern.Stream>} streams
  246.  *   The streams this AdaptationSet contains.
  247.  * @property {!Array.<shakaExtern.DrmInfo>} drmInfos
  248.  *   The DRM info for the AdaptationSet.
  249.  * @property {?string} trickModeFor
  250.  *   If non-null, this AdaptationInfo represents trick mode tracks.  This
  251.  *   property is the ID of the normal AdaptationSet these tracks should be
  252.  *   associated with.
  253.  * @property {!Array.<string>} representationIds
  254.  *   An array of the IDs of the Representations this AdaptationSet contains.
  255.  */
  256. shaka.dash.DashParser.AdaptationInfo;
  259. /**
  260.  * @typedef {{
  261.  *   createSegmentIndex: shakaExtern.CreateSegmentIndexFunction,
  262.  *   findSegmentPosition: shakaExtern.FindSegmentPositionFunction,
  263.  *   getSegmentReference: shakaExtern.GetSegmentReferenceFunction
  264.  * }}
  265.  *
  266.  * @description
  267.  * Contains functions used to create and find segment references.
  268.  *
  269.  * @property {shakaExtern.CreateSegmentIndexFunction} createSegmentIndex
  270.  *   The createSegmentIndex function.
  271.  * @property {shakaExtern.FindSegmentPositionFunction} findSegmentPosition
  272.  *   The findSegmentPosition function.
  273.  * @property {shakaExtern.GetSegmentReferenceFunction} getSegmentReference
  274.  *   The getSegmentReference function.
  275.  */
  276. shaka.dash.DashParser.SegmentIndexFunctions;
  279. /**
  280.  * @typedef {{
  281.  *   createSegmentIndex: shakaExtern.CreateSegmentIndexFunction,
  282.  *   findSegmentPosition: shakaExtern.FindSegmentPositionFunction,
  283.  *   getSegmentReference: shakaExtern.GetSegmentReferenceFunction,
  284.  *   initSegmentReference: shaka.media.InitSegmentReference,
  285.  *   presentationTimeOffset: (number|undefined)
  286.  * }}
  287.  *
  288.  * @description
  289.  * Contains information about a Stream.  This is passed from the createStream
  290.  * methods.
  291.  *
  292.  * @property {shakaExtern.CreateSegmentIndexFunction} createSegmentIndex
  293.  *   The createSegmentIndex function for the stream.
  294.  * @property {shakaExtern.FindSegmentPositionFunction} findSegmentPosition
  295.  *   The findSegmentPosition function for the stream.
  296.  * @property {shakaExtern.GetSegmentReferenceFunction} getSegmentReference
  297.  *   The getSegmentReference function for the stream.
  298.  * @property {shaka.media.InitSegmentReference} initSegmentReference
  299.  *   The init segment for the stream.
  300.  * @property {(number|undefined)} presentationTimeOffset
  301.  *   The presentationTimeOffset for the stream.
  302.  */
  303. shaka.dash.DashParser.StreamInfo;
  306. /**
  307.  * @override
  308.  * @exportInterface
  309.  */
  310. shaka.dash.DashParser.prototype.configure = function(config) {
  311.   goog.asserts.assert(config.dash != null,
  312.                       'DashManifestConfiguration should not be null!');
  314.   this.config_ = config;
  315. };
  318. /**
  319.  * @override
  320.  * @exportInterface
  321.  */
  322. shaka.dash.DashParser.prototype.start = function(uri, playerInterface) {
  323.   goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  324.   this.manifestUris_ = [uri];
  325.   this.playerInterface_ = playerInterface;
  326.   return this.requestManifest_().then(function() {
  327.     if (this.playerInterface_)
  328.       this.setUpdateTimer_(0);
  329.     return this.manifest_;
  330.   }.bind(this));
  331. };
  334. /**
  335.  * @override
  336.  * @exportInterface
  337.  */
  338. shaka.dash.DashParser.prototype.stop = function() {
  339.   this.playerInterface_ = null;
  340.   this.config_ = null;
  342.   this.manifestUris_ = [];
  343.   this.manifest_ = null;
  344.   this.periodIds_ = [];
  345.   this.segmentIndexMap_ = {};
  346.   if (this.updateTimer_ != null) {
  347.     window.clearTimeout(this.updateTimer_);
  348.     this.updateTimer_ = null;
  349.   }
  351.   return Promise.resolve();
  352. };
  355. /**
  356.  * @override
  357.  * @exportInterface
  358.  */
  359. shaka.dash.DashParser.prototype.update = function() {
  360.   this.requestManifest_().catch(function(error) {
  361.     if (!this.playerInterface_) return;
  362.     this.playerInterface_.onError(error);
  363.   }.bind(this));
  364. };
  367. /**
  368.  * @override
  369.  * @exportInterface
  370.  */
  371. shaka.dash.DashParser.prototype.onExpirationUpdated = function(
  372.     sessionId, expiration) {
  373.   // No-op
  374. };
  377. /**
  378.  * Makes a network request for the manifest and parses the resulting data.
  379.  *
  380.  * @return {!Promise}
  381.  * @private
  382.  */
  383. shaka.dash.DashParser.prototype.requestManifest_ = function() {
  384.   var requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  385.   var request = shaka.net.NetworkingEngine.makeRequest(
  386.       this.manifestUris_, this.config_.retryParameters);
  387.   return this.playerInterface_.networkingEngine.request(requestType, request)
  388.       .then(function(response) {
  389.         // Detect calls to stop().
  390.         if (!this.playerInterface_)
  391.           return;
  393.         // This may throw; but it will result in a failed promise.
  394.         return this.parseManifest_(response.data, response.uri);
  395.       }.bind(this));
  396. };
  399. /**
  400.  * Parses the manifest XML.  This also handles updates and will update the
  401.  * stored manifest.
  402.  *
  403.  * @param {!ArrayBuffer} data
  404.  * @param {string} finalManifestUri The final manifest URI, which may
  405.  *   differ from this.manifestUri_ if there has been a redirect.
  406.  * @return {!Promise}
  407.  * @throws shaka.util.Error When there is a parsing error.
  408.  * @private
  409.  */
  410. shaka.dash.DashParser.prototype.parseManifest_ =
  411.     function(data, finalManifestUri) {
  412.   var Error = shaka.util.Error;
  413.   var Functional = shaka.util.Functional;
  414.   var XmlUtils = shaka.util.XmlUtils;
  415.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  417.   var string = shaka.util.StringUtils.fromUTF8(data);
  418.   var parser = new DOMParser();
  419.   var xml = null;
  420.   var mpd = null;
  422.   try {
  423.     xml = parser.parseFromString(string, 'text/xml');
  424.   } catch (exception) {}
  425.   if (xml) {
  426.     // parseFromString returns a Document object.  A Document is a Node but not
  427.     // an Element, so it cannot be used in XmlUtils (technically it can but the
  428.     // types don't match).  The |documentElement| member defines the top-level
  429.     // element in the document.
  430.     if (xml.documentElement.tagName == 'MPD')
  431.       mpd = xml.documentElement;
  432.   }
  433.   if (mpd && mpd.getElementsByTagName('parsererror').length > 0)
  434.     mpd = null; // It had a parser error in it.
  435.   if (!mpd) {
  436.     throw new Error(
  437.         Error.Severity.CRITICAL, Error.Category.MANIFEST,
  438.         Error.Code.DASH_INVALID_XML);
  439.   }
  441.   // Get any Location elements.  This will update the manifest location and
  442.   // the base URI.
  443.   /** @type {!Array.<string>} */
  444.   var manifestBaseUris = [finalManifestUri];
  445.   /** @type {!Array.<string>} */
  446.   var locations = XmlUtils.findChildren(mpd, 'Location')
  447.                       .map(XmlUtils.getContents)
  448.                       .filter(Functional.isNotNull);
  449.   if (locations.length > 0) {
  450.     this.manifestUris_ = locations;
  451.     manifestBaseUris = locations;
  452.   }
  454.   var uris = XmlUtils.findChildren(mpd, 'BaseURL').map(XmlUtils.getContents);
  455.   var baseUris = ManifestParserUtils.resolveUris(manifestBaseUris, uris);
  457.   var minBufferTime =
  458.       XmlUtils.parseAttr(mpd, 'minBufferTime', XmlUtils.parseDuration);
  459.   this.updatePeriod_ = /** @type {number} */ (XmlUtils.parseAttr(
  460.       mpd, 'minimumUpdatePeriod', XmlUtils.parseDuration, -1));
  462.   var presentationStartTime = XmlUtils.parseAttr(
  463.       mpd, 'availabilityStartTime', XmlUtils.parseDate);
  464.   var segmentAvailabilityDuration = XmlUtils.parseAttr(
  465.       mpd, 'timeShiftBufferDepth', XmlUtils.parseDuration);
  466.   var suggestedPresentationDelay = XmlUtils.parseAttr(
  467.       mpd, 'suggestedPresentationDelay', XmlUtils.parseDuration);
  468.   var maxSegmentDuration = XmlUtils.parseAttr(
  469.       mpd, 'maxSegmentDuration', XmlUtils.parseDuration);
  470.   var mpdType = mpd.getAttribute('type') || 'static';
  472.   var presentationTimeline;
  473.   if (this.manifest_) {
  474.     presentationTimeline = this.manifest_.presentationTimeline;
  475.   } else {
  476.     // DASH IOP v3.0 suggests using a default delay between minBufferTime and
  477.     // timeShiftBufferDepth.  This is literally the range of all feasible
  478.     // choices for the value.  Nothing older than timeShiftBufferDepth is still
  479.     // available, and anything less than minBufferTime will cause buffering
  480.     // issues.
  481.     //
  482.     // We have decided that our default will be 1.5 * minBufferTime, or 10s,
  483.     // whichever is larger.  This is fairly conservative.  Content providers
  484.     // should provide a suggestedPresentationDelay whenever possible to optimize
  485.     // the live streaming experience.
  486.     var defaultPresentationDelay = Math.max(
  487.         shaka.dash.DashParser.DEFAULT_SUGGESTED_PRESENTATION_DELAY_,
  488.         minBufferTime * 1.5);
  489.     var presentationDelay = suggestedPresentationDelay != null ?
  490.         suggestedPresentationDelay : defaultPresentationDelay;
  491.     presentationTimeline = new shaka.media.PresentationTimeline(
  492.         presentationStartTime, presentationDelay);
  493.   }
  495.   /** @type {shaka.dash.DashParser.Context} */
  496.   var context = {
  497.     // Don't base on updatePeriod_ since emsg boxes can cause manifest updates.
  498.     dynamic: mpdType != 'static',
  499.     presentationTimeline: presentationTimeline,
  500.     period: null,
  501.     periodInfo: null,
  502.     adaptationSet: null,
  503.     representation: null,
  504.     bandwidth: undefined,
  505.     indexRangeWarningGiven: false
  506.   };
  508.   var periodsAndDuration = this.parsePeriods_(context, baseUris, mpd);
  509.   var duration = periodsAndDuration.duration;
  510.   var periods = periodsAndDuration.periods;
  512.   presentationTimeline.setStatic(mpdType == 'static');
  513.   presentationTimeline.setDuration(duration || Infinity);
  514.   presentationTimeline.setSegmentAvailabilityDuration(
  515.       segmentAvailabilityDuration != null ?
  516.       segmentAvailabilityDuration :
  517.       Infinity);
  518.   // Use @maxSegmentDuration to override smaller, derived values.
  519.   presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
  520.   if (!COMPILED) presentationTimeline.assertIsValid();
  522.   if (this.manifest_) {
  523.     // This is a manifest update, so we're done.
  524.     return Promise.resolve();
  525.   }
  527.   // This is the first manifest parse, so we cannot return until we calculate
  528.   // the clock offset.
  529.   var timingElements = XmlUtils.findChildren(mpd, 'UTCTiming');
  531.   var isLive = presentationTimeline.isLive();
  533.   return this.parseUtcTiming_(
  534.       baseUris, timingElements, isLive).then(function(offset) {
  535.     // Detect calls to stop().
  536.     if (!this.playerInterface_)
  537.       return;
  539.     presentationTimeline.setClockOffset(offset);
  541.     this.manifest_ = {
  542.       presentationTimeline: presentationTimeline,
  543.       periods: periods,
  544.       offlineSessionIds: [],
  545.       minBufferTime: minBufferTime || 0
  546.     };
  547.   }.bind(this));
  548. };
  551. /**
  552.  * Reads and parses the periods from the manifest.  This first does some
  553.  * partial parsing so the start and duration is available when parsing children.
  554.  *
  555.  * @param {shaka.dash.DashParser.Context} context
  556.  * @param {!Array.<string>} baseUris
  557.  * @param {!Element} mpd
  558.  * @return {{periods: !Array.<shakaExtern.Period>, duration: ?number}}
  559.  * @private
  560.  */
  561. shaka.dash.DashParser.prototype.parsePeriods_ = function(
  562.     context, baseUris, mpd) {
  563.   var Functional = shaka.util.Functional;
  564.   var XmlUtils = shaka.util.XmlUtils;
  565.   var presentationDuration = XmlUtils.parseAttr(
  566.       mpd, 'mediaPresentationDuration', XmlUtils.parseDuration);
  568.   var periods = [];
  569.   var prevEnd = 0;
  570.   var periodNodes = XmlUtils.findChildren(mpd, 'Period');
  571.   for (var i = 0; i < periodNodes.length; i++) {
  572.     var elem = periodNodes[i];
  573.     var start = /** @type {number} */ (
  574.         XmlUtils.parseAttr(elem, 'start', XmlUtils.parseDuration, prevEnd));
  575.     var givenDuration =
  576.         XmlUtils.parseAttr(elem, 'duration', XmlUtils.parseDuration);
  578.     var periodDuration = null;
  579.     if (i != periodNodes.length - 1) {
  580.       // "The difference between the start time of a Period and the start time
  581.       // of the following Period is the duration of the media content
  582.       // represented by this Period."
  583.       var nextPeriod = periodNodes[i + 1];
  584.       var nextStart =
  585.           XmlUtils.parseAttr(nextPeriod, 'start', XmlUtils.parseDuration);
  586.       if (nextStart != null)
  587.         periodDuration = nextStart - start;
  588.     } else if (presentationDuration != null) {
  589.       // "The Period extends until the Period.start of the next Period, or
  590.       // until the end of the Media Presentation in the case of the last
  591.       // Period."
  592.       periodDuration = presentationDuration - start;
  593.     }
  595.     if (periodDuration && givenDuration && periodDuration != givenDuration) {
  596.       shaka.log.warning('There is a gap/overlap between Periods', elem);
  597.     }
  598.     // Only use the @duration in the MPD if we can't calculate it.  We should
  599.     // favor the @start of the following Period.  This ensures that there aren't
  600.     // gaps between Periods.
  601.     if (periodDuration == null)
  602.       periodDuration = givenDuration;
  605.     // Parse child nodes.
  606.     var info = {
  607.       start: start,
  608.       duration: periodDuration,
  609.       node: elem,
  610.       isLastPeriod: periodDuration == null || i == periodNodes.length - 1
  611.     };
  612.     var period = this.parsePeriod_(context, baseUris, info);
  613.     periods.push(period);
  615.     // If there are any new periods, call the callback and add them to the
  616.     // manifest.  If this is the first parse, it will see all of them as new.
  617.     var periodId = context.period.id;
  618.     if (this.periodIds_.every(Functional.isNotEqualFunc(periodId))) {
  619.       this.playerInterface_.filterPeriod(period);
  620.       this.periodIds_.push(periodId);
  621.       if (this.manifest_)
  622.         this.manifest_.periods.push(period);
  623.     }
  626.     if (periodDuration == null) {
  627.       if (i != periodNodes.length - 1) {
  628.         // If the duration is still null and we aren't at the end, then we will
  629.         // skip any remaining periods.
  630.         shaka.log.warning(
  631.             'Skipping Period', i + 1, 'and any subsequent Periods:', 'Period',
  632.             i + 1, 'does not have a valid start time.', periods[i + 1]);
  633.       }
  635.       // The duration is unknown, so the end is unknown.
  636.       prevEnd = null;
  637.       break;
  638.     }
  640.     prevEnd = start + periodDuration;
  641.   }
  643.   if (presentationDuration != null) {
  644.     if (prevEnd != presentationDuration) {
  645.       shaka.log.warning(
  646.           '@mediaPresentationDuration does not match the total duration of all',
  647.           'Periods.');
  648.       // Assume @mediaPresentationDuration is correct.
  649.     }
  650.     return {
  651.       periods: periods,
  652.       duration: presentationDuration
  653.     };
  654.   } else {
  655.     return {
  656.       periods: periods,
  657.       duration: prevEnd
  658.     };
  659.   }
  660. };
  663. /**
  664.  * Parses a Period XML element.  Unlike the other parse methods, this is not
  665.  * given the Node; it is given a PeriodInfo structure.  Also, partial parsing
  666.  * was done before this was called so start and duration are valid.
  667.  *
  668.  * @param {shaka.dash.DashParser.Context} context
  669.  * @param {!Array.<string>} baseUris
  670.  * @param {shaka.dash.DashParser.PeriodInfo} periodInfo
  671.  * @return {shakaExtern.Period}
  672.  * @throws shaka.util.Error When there is a parsing error.
  673.  * @private
  674.  */
  675. shaka.dash.DashParser.prototype.parsePeriod_ = function(
  676.     context, baseUris, periodInfo) {
  677.   var Functional = shaka.util.Functional;
  678.   var XmlUtils = shaka.util.XmlUtils;
  679.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  681.   context.period = this.createFrame_(periodInfo.node, null, baseUris);
  682.   context.periodInfo = periodInfo;
  684.   // If the period doesn't have an ID, give it one based on its start time.
  685.   if (!context.period.id) {
  686.     shaka.log.info(
  687.         'No Period ID given for Period with start time ' + periodInfo.start +
  688.         ',  Assigning a default');
  689.     context.period.id = '__shaka_period_' + periodInfo.start;
  690.   }
  692.   var eventStreamNodes = XmlUtils.findChildren(periodInfo.node, 'EventStream');
  693.   eventStreamNodes.forEach(
  694.       this.parseEventStream_.bind(this, periodInfo.start, periodInfo.duration));
  696.   var adaptationSetNodes =
  697.       XmlUtils.findChildren(periodInfo.node, 'AdaptationSet');
  698.   var adaptationSets = adaptationSetNodes
  699.       .map(this.parseAdaptationSet_.bind(this, context))
  700.       .filter(Functional.isNotNull);
  702.   var representationIds = adaptationSets
  703.       .map(function(as) { return as.representationIds; })
  704.       .reduce(Functional.collapseArrays, []);
  705.   var uniqueRepIds = representationIds.filter(Functional.isNotDuplicate);
  706.   if (context.dynamic && representationIds.length != uniqueRepIds.length) {
  707.     throw new shaka.util.Error(
  708.         shaka.util.Error.Severity.CRITICAL,
  709.         shaka.util.Error.Category.MANIFEST,
  710.         shaka.util.Error.Code.DASH_DUPLICATE_REPRESENTATION_ID);
  711.   }
  713.   var normalAdaptationSets = adaptationSets
  714.       .filter(function(as) { return !as.trickModeFor; });
  716.   var trickModeAdaptationSets = adaptationSets
  717.       .filter(function(as) { return as.trickModeFor; });
  719.   // Attach trick mode tracks to normal tracks.
  720.   trickModeAdaptationSets.forEach(function(trickModeSet) {
  721.     // There may be multiple trick mode streams, but we do not currently
  722.     // support that.  Just choose one.
  723.     var trickModeVideo = trickModeSet.streams[0];
  724.     var targetId = trickModeSet.trickModeFor;
  725.     normalAdaptationSets.forEach(function(normalSet) {
  726.       if (normalSet.id == targetId) {
  727.         normalSet.streams.forEach(function(stream) {
  728.           stream.trickModeVideo = trickModeVideo;
  729.         });
  730.       }
  731.     });
  732.   });
  734.   var videoSets = this.getSetsOfType_(normalAdaptationSets, ContentType.VIDEO);
  735.   var audioSets = this.getSetsOfType_(normalAdaptationSets, ContentType.AUDIO);
  737.   if (!videoSets.length && !audioSets.length) {
  738.     throw new shaka.util.Error(
  739.         shaka.util.Error.Severity.CRITICAL,
  740.         shaka.util.Error.Category.MANIFEST,
  741.         shaka.util.Error.Code.DASH_EMPTY_PERIOD);
  742.   }
  744.   // In case of audio-only or video-only content, we create an array of one item
  745.   // containing a null.  This way, the double-loop works for all kinds of
  746.   // content.
  747.   if (!audioSets.length) {
  748.     audioSets = [null];
  749.   }
  750.   if (!videoSets.length) {
  751.     videoSets = [null];
  752.   }
  754.   // TODO: Limit number of combinations. Come up with a heuristic
  755.   // to decide which audio tracks to combine with which video tracks.
  756.   var variants = [];
  757.   for (var i = 0; i < audioSets.length; i++) {
  758.     for (var j = 0; j < videoSets.length; j++) {
  759.       var audioSet = audioSets[i];
  760.       var videoSet = videoSets[j];
  761.       this.createVariants_(audioSet, videoSet, variants);
  762.     }
  763.   }
  765.   var textSets = this.getSetsOfType_(normalAdaptationSets, ContentType.TEXT);
  766.   var textStreams = [];
  767.   for (var i = 0; i < textSets.length; i++) {
  768.     textStreams.push.apply(textStreams, textSets[i].streams);
  769.   }
  771.   return {
  772.     startTime: periodInfo.start,
  773.     textStreams: textStreams,
  774.     variants: variants
  775.   };
  776. };
  779. /**
  780.  * @param {!Array.<!shaka.dash.DashParser.AdaptationInfo>} adaptationSets
  781.  * @param {string} type
  782.  * @return {!Array.<!shaka.dash.DashParser.AdaptationInfo>}
  783.  * @private
  784.  */
  785. shaka.dash.DashParser.prototype.getSetsOfType_ = function(
  786.     adaptationSets, type) {
  787.   return adaptationSets.filter(function(as) {
  788.     return as.contentType == type;
  789.   });
  790. };
  793. /**
  794.  * Combines Streams into Variants
  795.  *
  796.  * @param {?shaka.dash.DashParser.AdaptationInfo} audio
  797.  * @param {?shaka.dash.DashParser.AdaptationInfo} video
  798.  * @param {!Array.<shakaExtern.Variant>} variants New variants are pushed onto
  799.  *   this array.
  800.  * @private
  801.  */
  802. shaka.dash.DashParser.prototype.createVariants_ =
  803.     function(audio, video, variants) {
  804.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  806.   // Since both audio and video are of the same type, this assertion will catch
  807.   // certain mistakes at runtime that the compiler would miss.
  808.   goog.asserts.assert(!audio || audio.contentType == ContentType.AUDIO,
  809.                       'Audio parameter mismatch!');
  810.   goog.asserts.assert(!video || video.contentType == ContentType.VIDEO,
  811.                       'Video parameter mismatch!');
  813.   /** @type {number} */
  814.   var bandwidth;
  815.   /** @type {shakaExtern.Variant} */
  816.   var variant;
  818.   if (!audio && !video) {
  819.     return;
  820.   } else if (audio && video) {
  821.     // Audio+video variants
  822.     var DrmEngine = shaka.media.DrmEngine;
  823.     if (DrmEngine.areDrmCompatible(audio.drmInfos, video.drmInfos)) {
  824.       var drmInfos = DrmEngine.getCommonDrmInfos(audio.drmInfos,
  825.                                                  video.drmInfos);
  827.       for (var i = 0; i < audio.streams.length; i++) {
  828.         for (var j = 0; j < video.streams.length; j++) {
  829.           // Explicit cast, followed by assertion.  These should both be defined
  830.           // in the case of DASH, but the type of Stream.bandwidth allows for
  831.           // undefined in order to support HLS.
  832.           bandwidth = /** @type {number} */(
  833.               video.streams[j].bandwidth +
  834.               audio.streams[i].bandwidth);
  835.           goog.asserts.assert(bandwidth,
  836.               'Bandwidth must be defined and non-zero!');
  837.           variant = {
  838.             id: this.globalId_++,
  839.             language: audio.language,
  840.             primary: audio.main || video.main,
  841.             audio: audio.streams[i],
  842.             video: video.streams[j],
  843.             bandwidth: bandwidth,
  844.             drmInfos: drmInfos,
  845.             allowedByApplication: true,
  846.             allowedByKeySystem: true
  847.           };
  849.           variants.push(variant);
  850.         }
  851.       }
  852.     }
  853.   } else {
  854.     // Audio or video only variants
  855.     var set = audio || video;
  856.     for (var i = 0; i < set.streams.length; i++) {
  857.       // Explicit cast, followed by assertion.  These should both be defined
  858.       // in the case of DASH, but the type allows for undefined in order to
  859.       // support HLS.
  860.       bandwidth = /** @type {number} */(set.streams[i].bandwidth);
  861.       goog.asserts.assert(bandwidth,
  862.           'Bandwidth must be defined and non-zero!');
  863.       variant = {
  864.         id: this.globalId_++,
  865.         language: set.language || 'und',
  866.         primary: set.main,
  867.         audio: audio ? set.streams[i] : null,
  868.         video: video ? set.streams[i] : null,
  869.         bandwidth: bandwidth,
  870.         drmInfos: set.drmInfos,
  871.         allowedByApplication: true,
  872.         allowedByKeySystem: true
  873.       };
  875.       variants.push(variant);
  876.     }
  877.   }
  878. };
  881. /**
  882.  * Parses an AdaptationSet XML element.
  883.  *
  884.  * @param {shaka.dash.DashParser.Context} context
  885.  * @param {!Element} elem The AdaptationSet element.
  886.  * @return {?shaka.dash.DashParser.AdaptationInfo}
  887.  * @throws shaka.util.Error When there is a parsing error.
  888.  * @private
  889.  */
  890. shaka.dash.DashParser.prototype.parseAdaptationSet_ = function(context, elem) {
  891.   var XmlUtils = shaka.util.XmlUtils;
  892.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  893.   context.adaptationSet = this.createFrame_(elem, context.period, null);
  895.   var main = false;
  896.   var roles = XmlUtils.findChildren(elem, 'Role');
  898.   // Default kind for text streams is 'subtitle' if unspecified in the manifest.
  899.   var kind = undefined;
  900.   if (context.adaptationSet.contentType == ManifestParserUtils.ContentType.TEXT)
  901.     kind = ManifestParserUtils.TextStreamKind.SUBTITLE;
  903.   for (var i = 0; i < roles.length; i++) {
  904.     var scheme = roles[i].getAttribute('schemeIdUri');
  905.     if (scheme == null || scheme == 'urn:mpeg:dash:role:2011') {
  906.       // These only apply for the given scheme, but allow them to be specified
  907.       // if there is no scheme specified.
  908.       // See: DASH section 5.8.5.5
  909.       var value = roles[i].getAttribute('value');
  910.       switch (value) {
  911.         case 'main':
  912.           main = true;
  913.           break;
  914.         case 'caption':
  915.         case 'subtitle':
  916.           kind = value;
  917.           break;
  918.       }
  919.     }
  920.   }
  922.   var essentialProperties = XmlUtils.findChildren(elem, 'EssentialProperty');
  923.   // ID of real AdaptationSet if this is a trick mode set:
  924.   var trickModeFor = null;
  925.   var unrecognizedEssentialProperty = false;
  926.   essentialProperties.forEach(function(prop) {
  927.     var schemeId = prop.getAttribute('schemeIdUri');
  928.     if (schemeId == 'http://dashif.org/guidelines/trickmode') {
  929.       trickModeFor = prop.getAttribute('value');
  930.     } else {
  931.       unrecognizedEssentialProperty = true;
  932.     }
  933.   });
  935.   // According to DASH spec (2014) section 5.8.4.8, "the successful processing
  936.   // of the descriptor is essential to properly use the information in the
  937.   // parent element".  According to DASH IOP v3.3, section 3.3.4, "if the scheme
  938.   // or the value" for EssentialProperty is not recognized, "the DASH client
  939.   // shall ignore the parent element."
  940.   if (unrecognizedEssentialProperty) {
  941.     // Stop parsing this AdaptationSet and let the caller filter out the nulls.
  942.     return null;
  943.   }
  945.   var contentProtectionElems = XmlUtils.findChildren(elem, 'ContentProtection');
  946.   var contentProtection = shaka.dash.ContentProtection.parseFromAdaptationSet(
  947.       contentProtectionElems, this.config_.dash.customScheme,
  948.       this.config_.dash.ignoreDrmInfo);
  950.   var language =
  951.       shaka.util.LanguageUtils.normalize(elem.getAttribute('lang') || 'und');
  953.   // Parse Representations into Streams.
  954.   var representations = XmlUtils.findChildren(elem, 'Representation');
  955.   var streams = representations
  956.       .map(this.parseRepresentation_.bind(
  957.           this, context, contentProtection, kind, language, main))
  958.       .filter(function(s) { return !!s; });
  960.   if (streams.length == 0) {
  961.     throw new shaka.util.Error(
  962.         shaka.util.Error.Severity.CRITICAL,
  963.         shaka.util.Error.Category.MANIFEST,
  964.         shaka.util.Error.Code.DASH_EMPTY_ADAPTATION_SET);
  965.   }
  967.   if (!context.adaptationSet.contentType) {
  968.     // Guess the AdaptationSet's content type.
  969.     var mimeType = streams[0].mimeType;
  970.     var codecs = streams[0].codecs;
  971.     context.adaptationSet.contentType =
  972.         shaka.dash.DashParser.guessContentType_(mimeType, codecs);
  974.     streams.forEach(function(stream) {
  975.       stream.type = context.adaptationSet.contentType;
  976.     });
  977.   }
  979.   streams.forEach(function(stream) {
  980.     // Some DRM license providers require that we have a default
  981.     // key ID from the manifest in the wrapped license request.
  982.     // Thus, it should be put in drmInfo to be accessible to request filters.
  983.     contentProtection.drmInfos.forEach(function(drmInfo) {
  984.       if (stream.keyId) {
  985.         drmInfo.keyIds.push(stream.keyId);
  986.       }
  987.     });
  988.   });
  990.   var repIds = representations
  991.       .map(function(node) { return node.getAttribute('id'); })
  992.       .filter(shaka.util.Functional.isNotNull);
  994.   return {
  995.     id: context.adaptationSet.id || ('__fake__' + this.globalId_++),
  996.     contentType: context.adaptationSet.contentType,
  997.     language: language,
  998.     main: main,
  999.     streams: streams,
  1000.     drmInfos: contentProtection.drmInfos,
  1001.     trickModeFor: trickModeFor,
  1002.     representationIds: repIds
  1003.   };
  1004. };
  1007. /**
  1008.  * Parses a Representation XML element.
  1009.  *
  1010.  * @param {shaka.dash.DashParser.Context} context
  1011.  * @param {shaka.dash.ContentProtection.Context} contentProtection
  1012.  * @param {(string|undefined)} kind
  1013.  * @param {string} language
  1014.  * @param {boolean} isPrimary
  1015.  * @param {!Element} node
  1016.  * @return {?shakaExtern.Stream} The Stream, or null when there is a
  1017.  *   non-critical parsing error.
  1018.  * @throws shaka.util.Error When there is a parsing error.
  1019.  * @private
  1020.  */
  1021. shaka.dash.DashParser.prototype.parseRepresentation_ = function(
  1022.     context, contentProtection, kind, language, isPrimary, node) {
  1023.   var XmlUtils = shaka.util.XmlUtils;
  1024.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1026.   context.representation = this.createFrame_(node, context.adaptationSet, null);
  1027.   if (!this.verifyRepresentation_(context.representation)) {
  1028.     shaka.log.warning('Skipping Representation', context.representation);
  1029.     return null;
  1030.   }
  1032.   context.bandwidth =
  1033.       XmlUtils.parseAttr(node, 'bandwidth', XmlUtils.parsePositiveInt) ||
  1034.       undefined;
  1036.   /** @type {?shaka.dash.DashParser.StreamInfo} */
  1037.   var streamInfo;
  1038.   var requestInitSegment = this.requestInitSegment_.bind(this);
  1039.   if (context.representation.segmentBase) {
  1040.     streamInfo = shaka.dash.SegmentBase.createStream(
  1041.         context, requestInitSegment);
  1042.   } else if (context.representation.segmentList) {
  1043.     streamInfo = shaka.dash.SegmentList.createStream(
  1044.         context, this.segmentIndexMap_);
  1045.   } else if (context.representation.segmentTemplate) {
  1046.     streamInfo = shaka.dash.SegmentTemplate.createStream(
  1047.         context, requestInitSegment, this.segmentIndexMap_, !!this.manifest_);
  1048.   } else {
  1049.     goog.asserts.assert(
  1050.         context.representation.contentType == ContentType.TEXT ||
  1051.         context.representation.contentType == ContentType.APPLICATION,
  1052.         'Must have Segment* with non-text streams.');
  1054.     var baseUris = context.representation.baseUris;
  1055.     var duration = context.periodInfo.duration || 0;
  1056.     streamInfo = {
  1057.       createSegmentIndex: Promise.resolve.bind(Promise),
  1058.       findSegmentPosition:
  1059.           /** @return {?number} */ function(/** number */ time) {
  1060.             if (time >= 0 && time < duration)
  1061.               return 1;
  1062.             else
  1063.               return null;
  1064.           },
  1065.       getSegmentReference:
  1066.           /** @return {shaka.media.SegmentReference} */
  1067.           function(/** number */ ref) {
  1068.             if (ref != 1)
  1069.               return null;
  1071.             return new shaka.media.SegmentReference(
  1072.                 1, 0, duration, function() { return baseUris; }, 0, null);
  1073.           },
  1074.       initSegmentReference: null,
  1075.       presentationTimeOffset: 0
  1076.     };
  1077.   }
  1079.   var contentProtectionElems = XmlUtils.findChildren(node, 'ContentProtection');
  1080.   var keyId = shaka.dash.ContentProtection.parseFromRepresentation(
  1081.       contentProtectionElems, this.config_.dash.customScheme,
  1082.       contentProtection, this.config_.dash.ignoreDrmInfo);
  1084.   return {
  1085.     id: this.globalId_++,
  1086.     createSegmentIndex: streamInfo.createSegmentIndex,
  1087.     findSegmentPosition: streamInfo.findSegmentPosition,
  1088.     getSegmentReference: streamInfo.getSegmentReference,
  1089.     initSegmentReference: streamInfo.initSegmentReference,
  1090.     presentationTimeOffset: streamInfo.presentationTimeOffset,
  1091.     mimeType: context.representation.mimeType,
  1092.     codecs: context.representation.codecs,
  1093.     frameRate: context.representation.frameRate,
  1094.     bandwidth: context.bandwidth,
  1095.     width: context.representation.width,
  1096.     height: context.representation.height,
  1097.     kind: kind,
  1098.     encrypted: contentProtection.drmInfos.length > 0,
  1099.     keyId: keyId,
  1100.     language: language,
  1101.     type: context.adaptationSet.contentType,
  1102.     primary: isPrimary,
  1103.     trickModeVideo: null,
  1104.     containsEmsgBoxes: context.representation.containsEmsgBoxes
  1105.   };
  1106. };
  1109. /**
  1110.  * Called when the update timer ticks.
  1111.  *
  1112.  * @private
  1113.  */
  1114. shaka.dash.DashParser.prototype.onUpdate_ = function() {
  1115.   goog.asserts.assert(this.updateTimer_, 'Should only be called by timer');
  1116.   goog.asserts.assert(this.updatePeriod_ >= 0,
  1117.                       'There should be an update period');
  1119.   shaka.log.info('Updating manifest...');
  1121.   this.updateTimer_ = null;
  1122.   var startTime = Date.now();
  1124.   this.requestManifest_().then(function() {
  1125.     // Detect a call to stop()
  1126.     if (!this.playerInterface_)
  1127.       return;
  1129.     // Ensure the next update occurs within |updatePeriod_| seconds by taking
  1130.     // into account the time it took to update the manifest.
  1131.     var endTime = Date.now();
  1132.     this.setUpdateTimer_((endTime - startTime) / 1000.0);
  1133.   }.bind(this)).catch(function(error) {
  1134.     goog.asserts.assert(error instanceof shaka.util.Error,
  1135.                         'Should only receive a Shaka error');
  1137.     // Try updating again, but ensure we haven't been destroyed.
  1138.     if (this.playerInterface_) {
  1139.       // We will retry updating, so override the severity of the error.
  1140.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  1141.       this.playerInterface_.onError(error);
  1143.       this.setUpdateTimer_(0);
  1144.     }
  1145.   }.bind(this));
  1146. };
  1149. /**
  1150.  * Sets the update timer.  Does nothing if the manifest does not specify an
  1151.  * update period.
  1152.  *
  1153.  * @param {number} offset An offset, in seconds, to apply to the manifest's
  1154.  *   update period.
  1155.  * @private
  1156.  */
  1157. shaka.dash.DashParser.prototype.setUpdateTimer_ = function(offset) {
  1158.   // NOTE: An updatePeriod_ of -1 means the attribute was missing.
  1159.   // An attribute which is present and set to 0 should still result in periodic
  1160.   // updates. For more, see: https://github.com/google/shaka-player/issues/331
  1161.   if (this.updatePeriod_ < 0)
  1162.     return;
  1163.   goog.asserts.assert(this.updateTimer_ == null,
  1164.                       'Timer should not be already set');
  1166.   var period =
  1167.       Math.max(shaka.dash.DashParser.MIN_UPDATE_PERIOD_, this.updatePeriod_);
  1168.   var interval = Math.max(period - offset, 0);
  1169.   shaka.log.debug('updateInterval', interval);
  1171.   var callback = this.onUpdate_.bind(this);
  1172.   this.updateTimer_ = window.setTimeout(callback, 1000 * interval);
  1173. };
  1176. /**
  1177.  * Creates a new inheritance frame for the given element.
  1178.  *
  1179.  * @param {!Element} elem
  1180.  * @param {?shaka.dash.DashParser.InheritanceFrame} parent
  1181.  * @param {Array.<string>} baseUris
  1182.  * @return {shaka.dash.DashParser.InheritanceFrame}
  1183.  * @private
  1184.  */
  1185. shaka.dash.DashParser.prototype.createFrame_ = function(
  1186.     elem, parent, baseUris) {
  1187.   goog.asserts.assert(parent || baseUris,
  1188.                       'Must provide either parent or baseUris');
  1189.   var ManifestParserUtils = shaka.util.ManifestParserUtils;
  1190.   var XmlUtils = shaka.util.XmlUtils;
  1191.   parent = parent || /** @type {shaka.dash.DashParser.InheritanceFrame} */ ({
  1192.     contentType: '',
  1193.     mimeType: '',
  1194.     codecs: '',
  1195.     containsEmsgBoxes: false,
  1196.     frameRate: undefined
  1197.   });
  1198.   baseUris = baseUris || parent.baseUris;
  1200.   var parseNumber = XmlUtils.parseNonNegativeInt;
  1201.   var evalDivision = XmlUtils.evalDivision;
  1202.   var uris = XmlUtils.findChildren(elem, 'BaseURL').map(XmlUtils.getContents);
  1204.   var contentType = elem.getAttribute('contentType') || parent.contentType;
  1205.   var mimeType = elem.getAttribute('mimeType') || parent.mimeType;
  1206.   var codecs = elem.getAttribute('codecs') || parent.codecs;
  1207.   var frameRate =
  1208.       XmlUtils.parseAttr(elem, 'frameRate', evalDivision) || parent.frameRate;
  1209.   var containsEmsgBoxes =
  1210.       !!XmlUtils.findChildren(elem, 'InbandEventStream').length;
  1212.   if (!contentType) {
  1213.     contentType = shaka.dash.DashParser.guessContentType_(mimeType, codecs);
  1214.   }
  1216.   return {
  1217.     baseUris: ManifestParserUtils.resolveUris(baseUris, uris),
  1218.     segmentBase: XmlUtils.findChild(elem, 'SegmentBase') || parent.segmentBase,
  1219.     segmentList: XmlUtils.findChild(elem, 'SegmentList') || parent.segmentList,
  1220.     segmentTemplate:
  1221.         XmlUtils.findChild(elem, 'SegmentTemplate') || parent.segmentTemplate,
  1222.     width: XmlUtils.parseAttr(elem, 'width', parseNumber) || parent.width,
  1223.     height: XmlUtils.parseAttr(elem, 'height', parseNumber) || parent.height,
  1224.     contentType: contentType,
  1225.     mimeType: mimeType,
  1226.     codecs: codecs,
  1227.     frameRate: frameRate,
  1228.     containsEmsgBoxes: containsEmsgBoxes || parent.containsEmsgBoxes,
  1229.     id: elem.getAttribute('id')
  1230.   };
  1231. };
  1234. /**
  1235.  * Verifies that a Representation has exactly one Segment* element.  Prints
  1236.  * warnings if there is a problem.
  1237.  *
  1238.  * @param {shaka.dash.DashParser.InheritanceFrame} frame
  1239.  * @return {boolean} True if the Representation is usable; otherwise return
  1240.  *   false.
  1241.  * @private
  1242.  */
  1243. shaka.dash.DashParser.prototype.verifyRepresentation_ = function(frame) {
  1244.   var ContentType = shaka.util.ManifestParserUtils.ContentType;
  1246.   var n = 0;
  1247.   n += frame.segmentBase ? 1 : 0;
  1248.   n += frame.segmentList ? 1 : 0;
  1249.   n += frame.segmentTemplate ? 1 : 0;
  1251.   if (n == 0) {
  1252.     // TODO: extend with the list of MIME types registered to TextEngine.
  1253.     if (frame.contentType == ContentType.TEXT ||
  1254.         frame.contentType == ContentType.APPLICATION) {
  1255.       return true;
  1256.     } else {
  1257.       shaka.log.warning(
  1258.           'Representation does not contain a segment information source:',
  1259.           'the Representation must contain one of SegmentBase, SegmentList,',
  1260.           'SegmentTemplate, or explicitly indicate that it is "text".',
  1261.           frame);
  1262.       return false;
  1263.     }
  1264.   }
  1266.   if (n != 1) {
  1267.     shaka.log.warning(
  1268.         'Representation contains multiple segment information sources:',
  1269.         'the Representation should only contain one of SegmentBase,',
  1270.         'SegmentList, or SegmentTemplate.',
  1271.         frame);
  1272.     if (frame.segmentBase) {
  1273.       shaka.log.info('Using SegmentBase by default.');
  1274.       frame.segmentList = null;
  1275.       frame.segmentTemplate = null;
  1276.     } else {
  1277.       goog.asserts.assert(frame.segmentList, 'There should be a SegmentList');
  1278.       shaka.log.info('Using SegmentList by default.');
  1279.       frame.segmentTemplate = null;
  1280.     }
  1281.   }
  1283.   return true;
  1284. };
  1287. /**
  1288.  * Makes a request to the given URI and calculates the clock offset.
  1289.  *
  1290.  * @param {!Array.<string>} baseUris
  1291.  * @param {string} uri
  1292.  * @param {string} method
  1293.  * @return {!Promise.<number>}
  1294.  * @private
  1295.  */
  1296. shaka.dash.DashParser.prototype.requestForTiming_ =
  1297.     function(baseUris, uri, method) {
  1298.   var requestUris = shaka.util.ManifestParserUtils.resolveUris(baseUris, [uri]);
  1299.   var request = shaka.net.NetworkingEngine.makeRequest(
  1300.       requestUris, this.config_.retryParameters);
  1301.   request.method = method;
  1302.   var type = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  1303.   return this.playerInterface_.networkingEngine.request(type, request)
  1304.       .then(function(response) {
  1305.         var text;
  1306.         if (method == 'HEAD') {
  1307.           if (!response.headers || !response.headers['date']) return 0;
  1309.           text = response.headers['date'];
  1310.         } else {
  1311.           text = shaka.util.StringUtils.fromUTF8(response.data);
  1312.         }
  1314.         var date = Date.parse(text);
  1315.         return isNaN(date) ? 0 : (date - Date.now());
  1316.       });
  1317. };
  1320. /**
  1321.  * Parses an array of UTCTiming elements.
  1322.  *
  1323.  * @param {!Array.<string>} baseUris
  1324.  * @param {!Array.<!Element>} elems
  1325.  * @param {boolean} isLive
  1326.  * @return {!Promise.<number>}
  1327.  * @private
  1328.  */
  1329. shaka.dash.DashParser.prototype.parseUtcTiming_ =
  1330.     function(baseUris, elems, isLive) {
  1331.   var schemesAndValues = elems.map(function(elem) {
  1332.     return {
  1333.       scheme: elem.getAttribute('schemeIdUri'),
  1334.       value: elem.getAttribute('value')
  1335.     };
  1336.   });
  1338.   // If there's nothing specified in the manifest, but we have a default from
  1339.   // the config, use that.
  1340.   var clockSyncUri = this.config_.dash.clockSyncUri;
  1341.   if (isLive && !schemesAndValues.length && clockSyncUri) {
  1342.     schemesAndValues.push({
  1343.       scheme: 'urn:mpeg:dash:utc:http-head:2014',
  1344.       value: clockSyncUri
  1345.     });
  1346.   }
  1348.   var Functional = shaka.util.Functional;
  1349.   return Functional.createFallbackPromiseChain(schemesAndValues, function(sv) {
  1350.     var scheme = sv.scheme;
  1351.     var value = sv.value;
  1352.     switch (scheme) {
  1353.       // See DASH IOP Guidelines Section 4.7
  1354.       // http://goo.gl/CQFNJT
  1355.       case 'urn:mpeg:dash:utc:http-head:2014':
  1356.       // Some old ISO23009-1 drafts used 2012.
  1357.       case 'urn:mpeg:dash:utc:http-head:2012':
  1358.         return this.requestForTiming_(baseUris, value, 'HEAD');
  1359.       case 'urn:mpeg:dash:utc:http-xsdate:2014':
  1360.       case 'urn:mpeg:dash:utc:http-iso:2014':
  1361.       case 'urn:mpeg:dash:utc:http-xsdate:2012':
  1362.       case 'urn:mpeg:dash:utc:http-iso:2012':
  1363.         return this.requestForTiming_(baseUris, value, 'GET');
  1364.       case 'urn:mpeg:dash:utc:direct:2014':
  1365.       case 'urn:mpeg:dash:utc:direct:2012':
  1366.         var date = Date.parse(value);
  1367.         return isNaN(date) ? 0 : (date - Date.now());
  1369.       case 'urn:mpeg:dash:utc:http-ntp:2014':
  1370.       case 'urn:mpeg:dash:utc:ntp:2014':
  1371.       case 'urn:mpeg:dash:utc:sntp:2014':
  1372.         shaka.log.warning('NTP UTCTiming scheme is not supported');
  1373.         return Promise.reject();
  1374.       default:
  1375.         shaka.log.warning(
  1376.             'Unrecognized scheme in UTCTiming element', scheme);
  1377.         return Promise.reject();
  1378.     }
  1379.   }.bind(this)).catch(function() {
  1380.     if (isLive) {
  1381.       shaka.log.warning(
  1382.           'A UTCTiming element should always be given in live manifests! ' +
  1383.           'This content may not play on clients with bad clocks!');
  1384.     }
  1385.     return 0;
  1386.   });
  1387. };
  1390. /**
  1391.  * Parses an EventStream element.
  1392.  *
  1393.  * @param {number} periodStart
  1394.  * @param {?number} periodDuration
  1395.  * @param {!Element} elem
  1396.  * @private
  1397.  */
  1398. shaka.dash.DashParser.prototype.parseEventStream_ = function(
  1399.     periodStart, periodDuration, elem) {
  1400.   var XmlUtils = shaka.util.XmlUtils;
  1401.   var parseNumber = XmlUtils.parseNonNegativeInt;
  1403.   var schemeIdUri = elem.getAttribute('schemeIdUri') || '';
  1404.   var value = elem.getAttribute('value') || '';
  1405.   var timescale = XmlUtils.parseAttr(elem, 'timescale', parseNumber) || 1;
  1407.   XmlUtils.findChildren(elem, 'Event').forEach(function(eventNode) {
  1408.     var presentationTime =
  1409.         XmlUtils.parseAttr(eventNode, 'presentationTime', parseNumber) || 0;
  1410.     var duration = XmlUtils.parseAttr(eventNode, 'duration', parseNumber) || 0;
  1412.     var startTime = presentationTime / timescale + periodStart;
  1413.     var endTime = startTime + (duration / timescale);
  1414.     if (periodDuration != null) {
  1415.       // An event should not go past the Period, even if the manifest says so.
  1416.       // See: Dash sec. 5.10.2.1
  1417.       startTime = Math.min(startTime, periodStart + periodDuration);
  1418.       endTime = Math.min(endTime, periodStart + periodDuration);
  1419.     }
  1421.     /** @type {shakaExtern.TimelineRegionInfo} */
  1422.     var region = {
  1423.       schemeIdUri: schemeIdUri,
  1424.       value: value,
  1425.       startTime: startTime,
  1426.       endTime: endTime,
  1427.       id: eventNode.getAttribute('id') || '',
  1428.       eventElement: eventNode
  1429.     };
  1431.     this.playerInterface_.onTimelineRegionAdded(region);
  1432.   }.bind(this));
  1433. };
  1436. /**
  1437.  * Makes a network request on behalf of SegmentBase.createStream.
  1438.  *
  1439.  * @param {!Array.<string>} uris
  1440.  * @param {?number} startByte
  1441.  * @param {?number} endByte
  1442.  * @return {!Promise.<!ArrayBuffer>}
  1443.  * @private
  1444.  */
  1445. shaka.dash.DashParser.prototype.requestInitSegment_ = function(
  1446.     uris, startByte, endByte) {
  1447.   var requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1448.   var request = shaka.net.NetworkingEngine.makeRequest(
  1449.       uris, this.config_.retryParameters);
  1450.   if (startByte != null) {
  1451.     var end = (endByte != null ? endByte : '');
  1452.     request.headers['Range'] = 'bytes=' + startByte + '-' + end;
  1453.   }
  1455.   return this.playerInterface_.networkingEngine.request(requestType, request)
  1456.       .then(function(response) { return response.data; });
  1457. };
  1460. /**
  1461.  * Guess the content type based on MIME type and codecs.
  1462.  *
  1463.  * @param {string} mimeType
  1464.  * @param {string} codecs
  1465.  * @return {string}
  1466.  * @private
  1467.  */
  1468. shaka.dash.DashParser.guessContentType_ = function(mimeType, codecs) {
  1469.   var fullMimeType = shaka.util.StreamUtils.getFullMimeType(mimeType, codecs);
  1471.   if (shaka.media.TextEngine.isTypeSupported(fullMimeType)) {
  1472.     // If it's supported by TextEngine, it's definitely text.
  1473.     // We don't check MediaSourceEngine, because that would report support
  1474.     // for platform-supported video and audio types as well.
  1475.     return shaka.util.ManifestParserUtils.ContentType.TEXT;
  1476.   }
  1478.   // Otherwise, just split the MIME type.  This handles video and audio
  1479.   // types well.
  1480.   return mimeType.split('/')[0];
  1481. };
  1484. shaka.media.ManifestParser.registerParserByExtension(
  1485.     'mpd', shaka.dash.DashParser);
  1486. shaka.media.ManifestParser.registerParserByMime(
  1487.     'application/dash+xml', shaka.dash.DashParser);