Source: lib/dash/dash_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.dash.DashParser');
  9. goog.require('goog.asserts');
  10. goog.require('goog.Uri');
  11. goog.require('shaka.Deprecate');
  12. goog.require('shaka.abr.Ewma');
  13. goog.require('shaka.dash.ContentProtection');
  14. goog.require('shaka.dash.MpdUtils');
  15. goog.require('shaka.dash.SegmentBase');
  16. goog.require('shaka.dash.SegmentList');
  17. goog.require('shaka.dash.SegmentTemplate');
  18. goog.require('shaka.log');
  19. goog.require('shaka.media.Capabilities');
  20. goog.require('shaka.media.ManifestParser');
  21. goog.require('shaka.media.PresentationTimeline');
  22. goog.require('shaka.media.SegmentIndex');
  23. goog.require('shaka.media.SegmentUtils');
  24. goog.require('shaka.net.NetworkingEngine');
  25. goog.require('shaka.text.TextEngine');
  26. goog.require('shaka.util.ContentSteeringManager');
  27. goog.require('shaka.util.Error');
  28. goog.require('shaka.util.EventManager');
  29. goog.require('shaka.util.FakeEvent');
  30. goog.require('shaka.util.Functional');
  31. goog.require('shaka.util.LanguageUtils');
  32. goog.require('shaka.util.ManifestParserUtils');
  33. goog.require('shaka.util.MimeUtils');
  34. goog.require('shaka.util.Networking');
  35. goog.require('shaka.util.ObjectUtils');
  36. goog.require('shaka.util.OperationManager');
  37. goog.require('shaka.util.PeriodCombiner');
  38. goog.require('shaka.util.PlayerConfiguration');
  39. goog.require('shaka.util.StreamUtils');
  40. goog.require('shaka.util.StringUtils');
  41. goog.require('shaka.util.TimeUtils');
  42. goog.require('shaka.util.Timer');
  43. goog.require('shaka.util.TXml');
  44. goog.require('shaka.util.XmlUtils');
  47. /**
  48.  * Creates a new DASH parser.
  49.  *
  50.  * @implements {shaka.extern.ManifestParser}
  51.  * @export
  52.  */
  53. shaka.dash.DashParser = class {
  54.   /** Creates a new DASH parser. */
  55.   constructor() {
  56.     /** @private {?shaka.extern.ManifestConfiguration} */
  57.     this.config_ = null;
  59.     /** @private {?shaka.extern.ManifestParser.PlayerInterface} */
  60.     this.playerInterface_ = null;
  62.     /** @private {!Array<string>} */
  63.     this.manifestUris_ = [];
  65.     /** @private {?shaka.extern.Manifest} */
  66.     this.manifest_ = null;
  68.     /** @private {number} */
  69.     this.globalId_ = 1;
  71.     /** @private {!Array<shaka.extern.xml.Node>} */
  72.     this.patchLocationNodes_ = [];
  74.     /**
  75.      * A context of the living manifest used for processing
  76.      * Patch MPD's
  77.      * @private {!shaka.dash.DashParser.PatchContext}
  78.      */
  79.     this.manifestPatchContext_ = {
  80.       mpdId: '',
  81.       type: '',
  82.       profiles: [],
  83.       mediaPresentationDuration: null,
  84.       availabilityTimeOffset: 0,
  85.       getBaseUris: null,
  86.       publishTime: 0,
  87.     };
  89.     /**
  90.      * This is a cache is used the store a snapshot of the context
  91.      * object which is built up throughout node traversal to maintain
  92.      * a current state. This data needs to be preserved for parsing
  93.      * patches.
  94.      * The key is a combination period and representation id's.
  95.      * @private {!Map<string, !shaka.dash.DashParser.Context>}
  96.      */
  97.     this.contextCache_ = new Map();
  99.     /**
  100.      * @private {
  101.      *   !Map<string, {endTime: number, timeline: number, reps: Array<string>}>
  102.      * }
  103.      */
  104.     this.continuityCache_ = new Map();
  106.     /**
  107.      * A map of IDs to Stream objects.
  108.      * ID: Period@id,Representation@id
  109.      * e.g.: '1,23'
  110.      * @private {!Map<string, !shaka.extern.Stream>}
  111.      */
  112.     this.streamMap_ = new Map();
  114.     /**
  115.      * A map of Period IDs to Stream Map IDs.
  116.      * Use to have direct access to streamMap key.
  117.      * @private {!Map<string, !Array<string>>}
  118.      */
  119.     this.indexStreamMap_ = new Map();
  121.     /**
  122.      * A map of period ids to their durations
  123.      * @private {!Map<string, number>}
  124.      */
  125.     this.periodDurations_ = new Map();
  127.     /** @private {shaka.util.PeriodCombiner} */
  128.     this.periodCombiner_ = new shaka.util.PeriodCombiner();
  130.     /**
  131.      * The update period in seconds, or 0 for no updates.
  132.      * @private {number}
  133.      */
  134.     this.updatePeriod_ = 0;
  136.     /**
  137.      * An ewma that tracks how long updates take.
  138.      * This is to mitigate issues caused by slow parsing on embedded devices.
  139.      * @private {!shaka.abr.Ewma}
  140.      */
  141.     this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
  143.     /** @private {shaka.util.Timer} */
  144.     this.updateTimer_ = new shaka.util.Timer(() => {
  145.       if (this.mediaElement_ && !this.config_.continueLoadingWhenPaused) {
  146.         this.eventManager_.unlisten(this.mediaElement_, 'timeupdate');
  147.         if (this.mediaElement_.paused) {
  148.           this.eventManager_.listenOnce(
  149.               this.mediaElement_, 'timeupdate', () => this.onUpdate_());
  150.           return;
  151.         }
  152.       }
  153.       this.onUpdate_();
  154.     });
  156.     /** @private {!shaka.util.OperationManager} */
  157.     this.operationManager_ = new shaka.util.OperationManager();
  159.     /**
  160.      * Largest period start time seen.
  161.      * @private {?number}
  162.      */
  163.     this.largestPeriodStartTime_ = null;
  165.     /**
  166.      * Period IDs seen in previous manifest.
  167.      * @private {!Array<string>}
  168.      */
  169.     this.lastManifestUpdatePeriodIds_ = [];
  171.     /**
  172.      * The minimum of the availabilityTimeOffset values among the adaptation
  173.      * sets.
  174.      * @private {number}
  175.      */
  176.     this.minTotalAvailabilityTimeOffset_ = Infinity;
  178.     /** @private {boolean} */
  179.     this.lowLatencyMode_ = false;
  181.     /** @private {?shaka.util.ContentSteeringManager} */
  182.     this.contentSteeringManager_ = null;
  184.     /** @private {number} */
  185.     this.gapCount_ = 0;
  187.     /** @private {boolean} */
  188.     this.isLowLatency_ = false;
  190.     /** @private {shaka.util.EventManager} */
  191.     this.eventManager_ = new shaka.util.EventManager();
  193.     /** @private {HTMLMediaElement} */
  194.     this.mediaElement_ = null;
  196.     /** @private {boolean} */
  197.     this.isTransitionFromDynamicToStatic_ = false;
  199.     /** @private {string} */
  200.     this.lastManifestQueryParams_ = '';
  202.     /** @private {function():boolean} */
  203.     this.isPreloadFn_ = () => false;
  205.     /** @private {?Array<string>} */
  206.     this.lastCalculatedBaseUris_ = [];
  208.     /**
  209.      * Used to track which prft nodes have been already parsed to avoid
  210.      * duplicating work for all representations.
  211.      * @private {!Set<!shaka.extern.xml.Node>}
  212.      */
  213.     this.parsedPrftNodes_ = new Set();
  214.   }
  216.   /**
  217.    * @param {shaka.extern.ManifestConfiguration} config
  218.    * @param {(function():boolean)=} isPreloadFn
  219.    * @override
  220.    * @exportInterface
  221.    */
  222.   configure(config, isPreloadFn) {
  223.     goog.asserts.assert(config.dash != null,
  224.         'DashManifestConfiguration should not be null!');
  225.     const needFireUpdate = this.playerInterface_ &&
  226.       config.updatePeriod != this.config_.updatePeriod &&
  227.       config.updatePeriod >= 0;
  228.     this.config_ = config;
  229.     if (isPreloadFn) {
  230.       this.isPreloadFn_ = isPreloadFn;
  231.     }
  232.     if (needFireUpdate && this.manifest_ &&
  233.       this.manifest_.presentationTimeline.isLive()) {
  234.       this.updateNow_();
  235.     }
  236.     if (this.contentSteeringManager_) {
  237.       this.contentSteeringManager_.configure(this.config_);
  238.     }
  240.     if (this.periodCombiner_) {
  241.       this.periodCombiner_.setAllowMultiTypeVariants(
  242.           this.config_.dash.multiTypeVariantsAllowed &&
  243.           shaka.media.Capabilities.isChangeTypeSupported());
  244.       this.periodCombiner_.setUseStreamOnce(
  245.           this.config_.dash.useStreamOnceInPeriodFlattening);
  246.     }
  247.   }
  249.   /**
  250.    * @override
  251.    * @exportInterface
  252.    */
  253.   async start(uri, playerInterface) {
  254.     goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  255.     this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
  256.     this.manifestUris_ = [uri];
  257.     this.playerInterface_ = playerInterface;
  259.     const updateDelay = await this.requestManifest_();
  261.     if (this.playerInterface_) {
  262.       this.setUpdateTimer_(updateDelay);
  263.     }
  265.     // Make sure that the parser has not been destroyed.
  266.     if (!this.playerInterface_) {
  267.       throw new shaka.util.Error(
  268.           shaka.util.Error.Severity.CRITICAL,
  269.           shaka.util.Error.Category.PLAYER,
  270.           shaka.util.Error.Code.OPERATION_ABORTED);
  271.     }
  273.     goog.asserts.assert(this.manifest_, 'Manifest should be non-null!');
  274.     return this.manifest_;
  275.   }
  277.   /**
  278.    * @override
  279.    * @exportInterface
  280.    */
  281.   stop() {
  282.     // When the parser stops, release all segment indexes, which stops their
  283.     // timers, as well.
  284.     for (const stream of this.streamMap_.values()) {
  285.       if (stream.segmentIndex) {
  286.         stream.segmentIndex.release();
  287.       }
  288.     }
  290.     if (this.periodCombiner_) {
  291.       this.periodCombiner_.release();
  292.     }
  294.     this.playerInterface_ = null;
  295.     this.config_ = null;
  296.     this.manifestUris_ = [];
  297.     this.manifest_ = null;
  298.     this.streamMap_.clear();
  299.     this.indexStreamMap_.clear();
  300.     this.contextCache_.clear();
  301.     this.continuityCache_.clear();
  302.     this.manifestPatchContext_ = {
  303.       mpdId: '',
  304.       type: '',
  305.       profiles: [],
  306.       mediaPresentationDuration: null,
  307.       availabilityTimeOffset: 0,
  308.       getBaseUris: null,
  309.       publishTime: 0,
  310.     };
  311.     this.periodCombiner_ = null;
  313.     if (this.updateTimer_ != null) {
  314.       this.updateTimer_.stop();
  315.       this.updateTimer_ = null;
  316.     }
  318.     if (this.contentSteeringManager_) {
  319.       this.contentSteeringManager_.destroy();
  320.     }
  322.     if (this.eventManager_) {
  323.       this.eventManager_.release();
  324.       this.eventManager_ = null;
  325.     }
  326.     this.parsedPrftNodes_.clear();
  328.     return this.operationManager_.destroy();
  329.   }
  331.   /**
  332.    * @override
  333.    * @exportInterface
  334.    */
  335.   async update() {
  336.     try {
  337.       await this.requestManifest_();
  338.     } catch (error) {
  339.       if (!this.playerInterface_ || !error) {
  340.         return;
  341.       }
  342.       goog.asserts.assert(error instanceof shaka.util.Error, 'Bad error type');
  343.       this.playerInterface_.onError(error);
  344.     }
  345.   }
  347.   /**
  348.    * @override
  349.    * @exportInterface
  350.    */
  351.   onExpirationUpdated(sessionId, expiration) {
  352.     // No-op
  353.   }
  355.   /**
  356.    * @override
  357.    * @exportInterface
  358.    */
  359.   onInitialVariantChosen(variant) {
  360.     // For live it is necessary that the first time we update the manifest with
  361.     // a shorter time than indicated to take into account that the last segment
  362.     // added could be halfway, for example
  363.     if (this.manifest_ && this.manifest_.presentationTimeline.isLive()) {
  364.       const stream = variant.video || variant.audio;
  365.       if (stream && stream.segmentIndex) {
  366.         const availabilityEnd =
  367.             this.manifest_.presentationTimeline.getSegmentAvailabilityEnd();
  368.         const position = stream.segmentIndex.find(availabilityEnd);
  369.         if (position == null) {
  370.           return;
  371.         }
  372.         const reference = stream.segmentIndex.get(position);
  373.         if (!reference) {
  374.           return;
  375.         }
  376.         this.updatePeriod_ = reference.endTime - availabilityEnd;
  377.         this.setUpdateTimer_(/* offset= */ 0);
  378.       }
  379.     }
  380.   }
  382.   /**
  383.    * @override
  384.    * @exportInterface
  385.    */
  386.   banLocation(uri) {
  387.     if (this.contentSteeringManager_) {
  388.       this.contentSteeringManager_.banLocation(uri);
  389.     }
  390.   }
  392.   /**
  393.    * @override
  394.    * @exportInterface
  395.    */
  396.   setMediaElement(mediaElement) {
  397.     this.mediaElement_ = mediaElement;
  398.   }
  400.   /**
  401.    * Makes a network request for the manifest and parses the resulting data.
  402.    *
  403.    * @return {!Promise<number>} Resolves with the time it took, in seconds, to
  404.    *   fulfill the request and parse the data.
  405.    * @private
  406.    */
  407.   async requestManifest_() {
  408.     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  409.     let type = shaka.net.NetworkingEngine.AdvancedRequestType.MPD;
  410.     let rootElement = 'MPD';
  411.     const patchLocationUris = this.getPatchLocationUris_();
  412.     let manifestUris = this.manifestUris_;
  413.     if (patchLocationUris.length) {
  414.       manifestUris = patchLocationUris;
  415.       rootElement = 'Patch';
  416.       type = shaka.net.NetworkingEngine.AdvancedRequestType.MPD_PATCH;
  417.     } else if (this.manifestUris_.length > 1 && this.contentSteeringManager_) {
  418.       const locations = this.contentSteeringManager_.getLocations(
  419.           'Location', /* ignoreBaseUrls= */ true);
  420.       if (locations.length) {
  421.         manifestUris = locations;
  422.       }
  423.     }
  424.     const request = shaka.net.NetworkingEngine.makeRequest(
  425.         manifestUris, this.config_.retryParameters);
  426.     const startTime = Date.now();
  428.     const response = await this.makeNetworkRequest_(
  429.         request, requestType, {type});
  431.     // Detect calls to stop().
  432.     if (!this.playerInterface_) {
  433.       return 0;
  434.     }
  436.     // For redirections add the response uri to the first entry in the
  437.     // Manifest Uris array.
  438.     if (response.uri && response.uri != response.originalUri &&
  439.         !this.manifestUris_.includes(response.uri)) {
  440.       this.manifestUris_.unshift(response.uri);
  441.     }
  443.     const uriObj = new goog.Uri(response.uri);
  444.     this.lastManifestQueryParams_ = uriObj.getQueryData().toString();
  446.     // This may throw, but it will result in a failed promise.
  447.     await this.parseManifest_(response.data, response.uri, rootElement);
  448.     // Keep track of how long the longest manifest update took.
  449.     const endTime = Date.now();
  450.     const updateDuration = (endTime - startTime) / 1000.0;
  451.     this.averageUpdateDuration_.sample(1, updateDuration);
  453.     this.parsedPrftNodes_.clear();
  455.     // Let the caller know how long this update took.
  456.     return updateDuration;
  457.   }
  459.   /**
  460.    * Parses the manifest XML.  This also handles updates and will update the
  461.    * stored manifest.
  462.    *
  463.    * @param {BufferSource} data
  464.    * @param {string} finalManifestUri The final manifest URI, which may
  465.    *   differ from this.manifestUri_ if there has been a redirect.
  466.    * @param {string} rootElement MPD or Patch, depending on context
  467.    * @return {!Promise}
  468.    * @private
  469.    */
  470.   async parseManifest_(data, finalManifestUri, rootElement) {
  471.     let manifestData = data;
  472.     const manifestPreprocessor = this.config_.dash.manifestPreprocessor;
  473.     const defaultManifestPreprocessor =
  474.         shaka.util.PlayerConfiguration.defaultManifestPreprocessor;
  475.     if (manifestPreprocessor != defaultManifestPreprocessor) {
  476.       shaka.Deprecate.deprecateFeature(5,
  477.           'manifest.dash.manifestPreprocessor configuration',
  478.           'Please Use manifest.dash.manifestPreprocessorTXml instead.');
  479.       const mpdElement =
  480.           shaka.util.XmlUtils.parseXml(manifestData, rootElement);
  481.       if (!mpdElement) {
  482.         throw new shaka.util.Error(
  483.             shaka.util.Error.Severity.CRITICAL,
  484.             shaka.util.Error.Category.MANIFEST,
  485.             shaka.util.Error.Code.DASH_INVALID_XML,
  486.             finalManifestUri);
  487.       }
  488.       manifestPreprocessor(mpdElement);
  489.       manifestData = shaka.util.XmlUtils.toArrayBuffer(mpdElement);
  490.     }
  491.     const mpd = shaka.util.TXml.parseXml(manifestData, rootElement);
  492.     if (!mpd) {
  493.       throw new shaka.util.Error(
  494.           shaka.util.Error.Severity.CRITICAL,
  495.           shaka.util.Error.Category.MANIFEST,
  496.           shaka.util.Error.Code.DASH_INVALID_XML,
  497.           finalManifestUri);
  498.     }
  499.     const manifestPreprocessorTXml =
  500.         this.config_.dash.manifestPreprocessorTXml;
  501.     const defaultManifestPreprocessorTXml =
  502.         shaka.util.PlayerConfiguration.defaultManifestPreprocessorTXml;
  503.     if (manifestPreprocessorTXml != defaultManifestPreprocessorTXml) {
  504.       manifestPreprocessorTXml(mpd);
  505.     }
  507.     if (rootElement === 'Patch') {
  508.       return this.processPatchManifest_(mpd);
  509.     }
  511.     const disableXlinkProcessing = this.config_.dash.disableXlinkProcessing;
  512.     if (disableXlinkProcessing) {
  513.       return this.processManifest_(mpd, finalManifestUri);
  514.     }
  516.     // Process the mpd to account for xlink connections.
  517.     const failGracefully = this.config_.dash.xlinkFailGracefully;
  518.     const xlinkOperation = shaka.dash.MpdUtils.processXlinks(
  519.         mpd, this.config_.retryParameters, failGracefully, finalManifestUri,
  520.         this.playerInterface_.networkingEngine);
  521.     this.operationManager_.manage(xlinkOperation);
  522.     const finalMpd = await xlinkOperation.promise;
  523.     return this.processManifest_(finalMpd, finalManifestUri);
  524.   }
  527.   /**
  528.    * Takes a formatted MPD and converts it into a manifest.
  529.    *
  530.    * @param {!shaka.extern.xml.Node} mpd
  531.    * @param {string} finalManifestUri The final manifest URI, which may
  532.    *   differ from this.manifestUri_ if there has been a redirect.
  533.    * @return {!Promise}
  534.    * @private
  535.    */
  536.   async processManifest_(mpd, finalManifestUri) {
  537.     const TXml = shaka.util.TXml;
  539.     goog.asserts.assert(this.config_,
  540.         'Must call configure() before processManifest_()!');
  542.     if (this.contentSteeringManager_) {
  543.       this.contentSteeringManager_.clearPreviousLocations();
  544.     }
  546.     // Get any Location elements.  This will update the manifest location and
  547.     // the base URI.
  548.     /** @type {!Array<string>} */
  549.     let manifestBaseUris = [finalManifestUri];
  550.     /** @type {!Array<string>} */
  551.     const locations = [];
  552.     /** @type {!Map<string, string>} */
  553.     const locationsMapping = new Map();
  554.     const locationsObjs = TXml.findChildren(mpd, 'Location');
  555.     for (const locationsObj of locationsObjs) {
  556.       const serviceLocation = locationsObj.attributes['serviceLocation'];
  557.       const uri = TXml.getContents(locationsObj);
  558.       if (!uri) {
  559.         continue;
  560.       }
  561.       const finalUri = shaka.util.ManifestParserUtils.resolveUris(
  562.           manifestBaseUris, [uri])[0];
  563.       if (serviceLocation) {
  564.         if (this.contentSteeringManager_) {
  565.           this.contentSteeringManager_.addLocation(
  566.               'Location', serviceLocation, finalUri);
  567.         } else {
  568.           locationsMapping.set(serviceLocation, finalUri);
  569.         }
  570.       }
  571.       locations.push(finalUri);
  572.     }
  573.     if (this.contentSteeringManager_) {
  574.       const steeringLocations = this.contentSteeringManager_.getLocations(
  575.           'Location', /* ignoreBaseUrls= */ true);
  576.       if (steeringLocations.length > 0) {
  577.         this.manifestUris_ = steeringLocations;
  578.         manifestBaseUris = steeringLocations;
  579.       }
  580.     } else if (locations.length) {
  581.       this.manifestUris_ = locations;
  582.       manifestBaseUris = locations;
  583.     }
  585.     this.manifestPatchContext_.mpdId = mpd.attributes['id'] || '';
  586.     this.manifestPatchContext_.publishTime =
  587.         TXml.parseAttr(mpd, 'publishTime', TXml.parseDate) || 0;
  588.     this.patchLocationNodes_ = TXml.findChildren(mpd, 'PatchLocation');
  590.     let contentSteeringPromise = Promise.resolve();
  592.     const contentSteering = TXml.findChild(mpd, 'ContentSteering');
  593.     if (contentSteering && this.playerInterface_) {
  594.       const defaultPathwayId =
  595.           contentSteering.attributes['defaultServiceLocation'];
  596.       if (!this.contentSteeringManager_) {
  597.         this.contentSteeringManager_ =
  598.             new shaka.util.ContentSteeringManager(this.playerInterface_);
  599.         this.contentSteeringManager_.configure(this.config_);
  600.         this.contentSteeringManager_.setManifestType(
  601.             shaka.media.ManifestParser.DASH);
  602.         this.contentSteeringManager_.setBaseUris(manifestBaseUris);
  603.         this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
  604.         const uri = TXml.getContents(contentSteering);
  605.         if (uri) {
  606.           const queryBeforeStart =
  607.             TXml.parseAttr(contentSteering, 'queryBeforeStart',
  608.                 TXml.parseBoolean, /* defaultValue= */ false);
  609.           if (queryBeforeStart) {
  610.             contentSteeringPromise =
  611.                 this.contentSteeringManager_.requestInfo(uri);
  612.           } else {
  613.             this.contentSteeringManager_.requestInfo(uri);
  614.           }
  615.         }
  616.       } else {
  617.         this.contentSteeringManager_.setBaseUris(manifestBaseUris);
  618.         this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
  619.       }
  620.       for (const serviceLocation of locationsMapping.keys()) {
  621.         const uri = locationsMapping.get(serviceLocation);
  622.         this.contentSteeringManager_.addLocation(
  623.             'Location', serviceLocation, uri);
  624.       }
  625.     }
  627.     const uriObjs = TXml.findChildren(mpd, 'BaseURL');
  628.     let someLocationValid = false;
  629.     if (this.contentSteeringManager_) {
  630.       for (const uriObj of uriObjs) {
  631.         const serviceLocation = uriObj.attributes['serviceLocation'];
  632.         const uri = TXml.getContents(uriObj);
  633.         if (serviceLocation && uri) {
  634.           this.contentSteeringManager_.addLocation(
  635.               'BaseURL', serviceLocation, uri);
  636.           someLocationValid = true;
  637.         }
  638.       }
  639.     }
  640.     this.lastCalculatedBaseUris_ = null;
  641.     if (!someLocationValid || !this.contentSteeringManager_) {
  642.       const uris = uriObjs.map(TXml.getContents);
  643.       this.lastCalculatedBaseUris_ = shaka.util.ManifestParserUtils.resolveUris(
  644.           manifestBaseUris, uris);
  645.     }
  647.     const getBaseUris = () => {
  648.       if (this.contentSteeringManager_ && someLocationValid) {
  649.         return this.contentSteeringManager_.getLocations('BaseURL');
  650.       }
  651.       if (this.lastCalculatedBaseUris_) {
  652.         return this.lastCalculatedBaseUris_;
  653.       }
  654.       return [];
  655.     };
  657.     this.manifestPatchContext_.getBaseUris = getBaseUris;
  659.     let availabilityTimeOffset = 0;
  660.     if (uriObjs && uriObjs.length) {
  661.       availabilityTimeOffset = TXml.parseAttr(uriObjs[0],
  662.           'availabilityTimeOffset', TXml.parseFloat) || 0;
  663.     }
  664.     this.manifestPatchContext_.availabilityTimeOffset = availabilityTimeOffset;
  666.     this.updatePeriod_ = /** @type {number} */ (TXml.parseAttr(
  667.         mpd, 'minimumUpdatePeriod', TXml.parseDuration, -1));
  669.     const presentationStartTime = TXml.parseAttr(
  670.         mpd, 'availabilityStartTime', TXml.parseDate);
  671.     let segmentAvailabilityDuration = TXml.parseAttr(
  672.         mpd, 'timeShiftBufferDepth', TXml.parseDuration);
  674.     const ignoreSuggestedPresentationDelay =
  675.       this.config_.dash.ignoreSuggestedPresentationDelay;
  676.     let suggestedPresentationDelay = null;
  677.     if (!ignoreSuggestedPresentationDelay) {
  678.       suggestedPresentationDelay = TXml.parseAttr(
  679.           mpd, 'suggestedPresentationDelay', TXml.parseDuration);
  680.     }
  682.     const ignoreMaxSegmentDuration =
  683.         this.config_.dash.ignoreMaxSegmentDuration;
  684.     let maxSegmentDuration = null;
  685.     if (!ignoreMaxSegmentDuration) {
  686.       maxSegmentDuration = TXml.parseAttr(
  687.           mpd, 'maxSegmentDuration', TXml.parseDuration);
  688.     }
  689.     const mpdType = mpd.attributes['type'] || 'static';
  691.     if (this.manifest_ && this.manifest_.presentationTimeline) {
  692.       this.isTransitionFromDynamicToStatic_ =
  693.           this.manifest_.presentationTimeline.isLive() && mpdType == 'static';
  694.     }
  696.     this.manifestPatchContext_.type = mpdType;
  697.     /** @type {!shaka.media.PresentationTimeline} */
  698.     let presentationTimeline;
  699.     if (this.manifest_) {
  700.       presentationTimeline = this.manifest_.presentationTimeline;
  702.       // Before processing an update, evict from all segment indexes.  Some of
  703.       // them may not get updated otherwise if their corresponding Period
  704.       // element has been dropped from the manifest since the last update.
  705.       // Without this, playback will still work, but this is necessary to
  706.       // maintain conditions that we assert on for multi-Period content.
  707.       // This gives us confidence that our state is maintained correctly, and
  708.       // that the complex logic of multi-Period eviction and period-flattening
  709.       // is correct.  See also:
  710.       // https://github.com/shaka-project/shaka-player/issues/3169#issuecomment-823580634
  711.       const availabilityStart =
  712.           presentationTimeline.getSegmentAvailabilityStart();
  713.       for (const stream of this.streamMap_.values()) {
  714.         if (stream.segmentIndex) {
  715.           stream.segmentIndex.evict(availabilityStart);
  716.         }
  717.       }
  718.     } else {
  719.       const ignoreMinBufferTime = this.config_.dash.ignoreMinBufferTime;
  720.       let minBufferTime = 0;
  721.       if (!ignoreMinBufferTime) {
  722.         minBufferTime =
  723.             TXml.parseAttr(mpd, 'minBufferTime', TXml.parseDuration) || 0;
  724.       }
  725.       // DASH IOP v3.0 suggests using a default delay between minBufferTime
  726.       // and timeShiftBufferDepth.  This is literally the range of all
  727.       // feasible choices for the value.  Nothing older than
  728.       // timeShiftBufferDepth is still available, and anything less than
  729.       // minBufferTime will cause buffering issues.
  730.       let delay = 0;
  731.       if (suggestedPresentationDelay != null) {
  732.         // 1. If a suggestedPresentationDelay is provided by the manifest, that
  733.         // will be used preferentially.
  734.         // This is given a minimum bound of segmentAvailabilityDuration.
  735.         // Content providers should provide a suggestedPresentationDelay
  736.         // whenever possible to optimize the live streaming experience.
  737.         delay = Math.min(
  738.             suggestedPresentationDelay,
  739.             segmentAvailabilityDuration || Infinity);
  740.       } else if (this.config_.defaultPresentationDelay > 0) {
  741.         // 2. If the developer provides a value for
  742.         // "manifest.defaultPresentationDelay", that is used as a fallback.
  743.         delay = this.config_.defaultPresentationDelay;
  744.       } else {
  745.         // 3. Otherwise, we default to the lower of segmentAvailabilityDuration
  746.         // and 1.5 * minBufferTime. This is fairly conservative.
  747.         delay = Math.min(
  748.             minBufferTime * 1.5, segmentAvailabilityDuration || Infinity);
  749.       }
  750.       presentationTimeline = new shaka.media.PresentationTimeline(
  751.           presentationStartTime, delay, this.config_.dash.autoCorrectDrift);
  752.     }
  754.     presentationTimeline.setStatic(mpdType == 'static');
  756.     const isLive = presentationTimeline.isLive();
  758.     // If it's live, we check for an override.
  759.     if (isLive && !isNaN(this.config_.availabilityWindowOverride)) {
  760.       segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
  761.     }
  763.     // If it's null, that means segments are always available.  This is always
  764.     // the case for VOD, and sometimes the case for live.
  765.     if (segmentAvailabilityDuration == null) {
  766.       segmentAvailabilityDuration = Infinity;
  767.     }
  769.     presentationTimeline.setSegmentAvailabilityDuration(
  770.         segmentAvailabilityDuration);
  772.     const profiles = mpd.attributes['profiles'] || '';
  773.     this.manifestPatchContext_.profiles = profiles.split(',');
  775.     /** @type {shaka.dash.DashParser.Context} */
  776.     const context = {
  777.       // Don't base on updatePeriod_ since emsg boxes can cause manifest
  778.       // updates.
  779.       dynamic: mpdType != 'static',
  780.       presentationTimeline: presentationTimeline,
  781.       period: null,
  782.       periodInfo: null,
  783.       adaptationSet: null,
  784.       representation: null,
  785.       bandwidth: 0,
  786.       indexRangeWarningGiven: false,
  787.       availabilityTimeOffset: availabilityTimeOffset,
  788.       mediaPresentationDuration: null,
  789.       profiles: profiles.split(','),
  790.       roles: null,
  791.       urlParams: () => '',
  792.     };
  794.     await contentSteeringPromise;
  796.     this.gapCount_ = 0;
  797.     const periodsAndDuration = this.parsePeriods_(
  798.         context, getBaseUris, mpd, /* newPeriod= */ false);
  799.     const duration = periodsAndDuration.duration;
  800.     const periods = periodsAndDuration.periods;
  802.     if ((mpdType == 'static' && !this.isTransitionFromDynamicToStatic_) ||
  803.         !periodsAndDuration.durationDerivedFromPeriods) {
  804.       // Ignore duration calculated from Period lengths if this is dynamic.
  805.       presentationTimeline.setDuration(duration || Infinity);
  806.     }
  808.     if (this.isLowLatency_ && this.lowLatencyMode_) {
  809.       presentationTimeline.setAvailabilityTimeOffset(
  810.           this.minTotalAvailabilityTimeOffset_);
  811.     }
  813.     // Use @maxSegmentDuration to override smaller, derived values.
  814.     presentationTimeline.notifyMaxSegmentDuration(maxSegmentDuration || 1);
  815.     if (goog.DEBUG && !this.isTransitionFromDynamicToStatic_) {
  816.       presentationTimeline.assertIsValid();
  817.     }
  819.     if (this.isLowLatency_ && this.lowLatencyMode_) {
  820.       const presentationDelay = suggestedPresentationDelay != null ?
  821.           suggestedPresentationDelay : this.config_.defaultPresentationDelay;
  822.       presentationTimeline.setDelay(presentationDelay);
  823.     }
  825.     // These steps are not done on manifest update.
  826.     if (!this.manifest_) {
  827.       await this.periodCombiner_.combinePeriods(periods, context.dynamic);
  829.       this.manifest_ = {
  830.         presentationTimeline: presentationTimeline,
  831.         variants: this.periodCombiner_.getVariants(),
  832.         textStreams: this.periodCombiner_.getTextStreams(),
  833.         imageStreams: this.periodCombiner_.getImageStreams(),
  834.         offlineSessionIds: [],
  835.         sequenceMode: this.config_.dash.sequenceMode,
  836.         ignoreManifestTimestampsInSegmentsMode: false,
  837.         type: shaka.media.ManifestParser.DASH,
  838.         serviceDescription: this.parseServiceDescription_(mpd),
  839.         nextUrl: this.parseMpdChaining_(mpd),
  840.         periodCount: periods.length,
  841.         gapCount: this.gapCount_,
  842.         isLowLatency: this.isLowLatency_,
  843.         startTime: null,
  844.       };
  846.       // We only need to do clock sync when we're using presentation start
  847.       // time. This condition also excludes VOD streams.
  848.       if (presentationTimeline.usingPresentationStartTime()) {
  849.         const TXml = shaka.util.TXml;
  850.         const timingElements = TXml.findChildren(mpd, 'UTCTiming');
  851.         const offset = await this.parseUtcTiming_(getBaseUris, timingElements);
  852.         // Detect calls to stop().
  853.         if (!this.playerInterface_) {
  854.           return;
  855.         }
  856.         presentationTimeline.setClockOffset(offset);
  857.       }
  859.       // This is the first point where we have a meaningful presentation start
  860.       // time, and we need to tell PresentationTimeline that so that it can
  861.       // maintain consistency from here on.
  862.       presentationTimeline.lockStartTime();
  864.       if (this.periodCombiner_ &&
  865.           !this.manifest_.presentationTimeline.isLive()) {
  866.         this.periodCombiner_.release();
  867.       }
  868.     } else {
  869.       this.manifest_.periodCount = periods.length;
  870.       this.manifest_.gapCount = this.gapCount_;
  871.       await this.postPeriodProcessing_(periods, /* isPatchUpdate= */ false);
  872.     }
  874.     // Add text streams to correspond to closed captions.  This happens right
  875.     // after period combining, while we still have a direct reference, so that
  876.     // any new streams will appear in the period combiner.
  877.     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
  879.     this.cleanStreamMap_();
  880.     this.cleanContinuityCache_(periods);
  881.   }
  883.   /**
  884.    * Handles common procedures after processing new periods.
  885.    *
  886.    * @param {!Array<shaka.extern.Period>} periods to be appended
  887.    * @param {boolean} isPatchUpdate does call comes from mpd patch update
  888.    * @private
  889.    */
  890.   async postPeriodProcessing_(periods, isPatchUpdate) {
  891.     await this.periodCombiner_.combinePeriods(periods, true, isPatchUpdate);
  893.     // Just update the variants and text streams, which may change as periods
  894.     // are added or removed.
  895.     this.manifest_.variants = this.periodCombiner_.getVariants();
  896.     const textStreams = this.periodCombiner_.getTextStreams();
  897.     if (textStreams.length > 0) {
  898.       this.manifest_.textStreams = textStreams;
  899.     }
  900.     this.manifest_.imageStreams = this.periodCombiner_.getImageStreams();
  902.     // Re-filter the manifest.  This will check any configured restrictions on
  903.     // new variants, and will pass any new init data to DrmEngine to ensure
  904.     // that key rotation works correctly.
  905.     this.playerInterface_.filter(this.manifest_);
  906.   }
  908.   /**
  909.    * Takes a formatted Patch MPD and converts it into a manifest.
  910.    *
  911.    * @param {!shaka.extern.xml.Node} mpd
  912.    * @return {!Promise}
  913.    * @private
  914.    */
  915.   async processPatchManifest_(mpd) {
  916.     const TXml = shaka.util.TXml;
  918.     const mpdId = mpd.attributes['mpdId'];
  919.     const originalPublishTime = TXml.parseAttr(mpd, 'originalPublishTime',
  920.         TXml.parseDate);
  921.     if (!mpdId || mpdId !== this.manifestPatchContext_.mpdId ||
  922.         originalPublishTime !== this.manifestPatchContext_.publishTime) {
  923.       // Clean patch location nodes, so it will force full MPD update.
  924.       this.patchLocationNodes_ = [];
  925.       throw new shaka.util.Error(
  926.           shaka.util.Error.Severity.RECOVERABLE,
  927.           shaka.util.Error.Category.MANIFEST,
  928.           shaka.util.Error.Code.DASH_INVALID_PATCH);
  929.     }
  931.     /** @type {!Array<shaka.extern.Period>} */
  932.     const newPeriods = [];
  933.     /** @type {!Array<shaka.extern.xml.Node>} */
  934.     const periodAdditions = [];
  935.     /** @type {!Set<string>} */
  936.     const modifiedTimelines = new Set();
  938.     for (const patchNode of TXml.getChildNodes(mpd)) {
  939.       let handled = true;
  940.       const paths = TXml.parseXpath(patchNode.attributes['sel'] || '');
  941.       const node = paths[paths.length - 1];
  942.       const content = TXml.getContents(patchNode) || '';
  944.       if (node.name === 'MPD') {
  945.         if (node.attribute === 'mediaPresentationDuration') {
  946.           const content = TXml.getContents(patchNode) || '';
  947.           this.parsePatchMediaPresentationDurationChange_(content);
  948.         } else if (node.attribute === 'type') {
  949.           this.parsePatchMpdTypeChange_(content);
  950.         } else if (node.attribute === 'publishTime') {
  951.           this.manifestPatchContext_.publishTime = TXml.parseDate(content) || 0;
  952.         } else if (node.attribute === null && patchNode.tagName === 'add') {
  953.           periodAdditions.push(patchNode);
  954.         } else {
  955.           handled = false;
  956.         }
  957.       } else if (node.name === 'PatchLocation') {
  958.         this.updatePatchLocationNodes_(patchNode);
  959.       } else if (node.name === 'Period') {
  960.         if (patchNode.tagName === 'add') {
  961.           periodAdditions.push(patchNode);
  962.         } else if (patchNode.tagName === 'remove' && node.id) {
  963.           this.removePatchPeriod_(node.id);
  964.         }
  965.       } else if (node.name === 'SegmentTemplate') {
  966.         const timelines = this.modifySegmentTemplate_(patchNode);
  967.         for (const timeline of timelines) {
  968.           modifiedTimelines.add(timeline);
  969.         }
  970.       } else if (node.name === 'SegmentTimeline' || node.name === 'S') {
  971.         const timelines = this.modifyTimepoints_(patchNode);
  972.         for (const timeline of timelines) {
  973.           modifiedTimelines.add(timeline);
  974.         }
  975.       } else {
  976.         handled = false;
  977.       }
  978.       if (!handled) {
  979.         shaka.log.warning('Unhandled ' + patchNode.tagName + ' operation',
  980.             patchNode.attributes['sel']);
  981.       }
  982.     }
  984.     for (const timeline of modifiedTimelines) {
  985.       this.parsePatchSegment_(timeline);
  986.     }
  988.     // Add new periods after extending timelines, as new periods
  989.     // remove context cache of previous periods.
  990.     for (const periodAddition of periodAdditions) {
  991.       newPeriods.push(...this.parsePatchPeriod_(periodAddition));
  992.     }
  994.     if (newPeriods.length) {
  995.       this.manifest_.periodCount += newPeriods.length;
  996.       this.manifest_.gapCount = this.gapCount_;
  997.       await this.postPeriodProcessing_(newPeriods, /* isPatchUpdate= */ true);
  998.     }
  999.     if (this.manifestPatchContext_.type == 'static') {
  1000.       const duration = this.manifestPatchContext_.mediaPresentationDuration;
  1001.       this.manifest_.presentationTimeline.setDuration(duration || Infinity);
  1002.     }
  1003.   }
  1005.   /**
  1006.    * Handles manifest type changes, this transition is expected to be
  1007.    * "dynamic" to "static".
  1008.    *
  1009.    * @param {!string} mpdType
  1010.    * @private
  1011.    */
  1012.   parsePatchMpdTypeChange_(mpdType) {
  1013.     this.manifest_.presentationTimeline.setStatic(mpdType == 'static');
  1014.     this.manifestPatchContext_.type = mpdType;
  1015.     for (const context of this.contextCache_.values()) {
  1016.       context.dynamic = mpdType == 'dynamic';
  1017.     }
  1018.     if (mpdType == 'static') {
  1019.       // Manifest is no longer dynamic, so stop live updates.
  1020.       this.updatePeriod_ = -1;
  1021.     }
  1022.   }
  1024.   /**
  1025.    * @param {string} durationString
  1026.    * @private
  1027.    */
  1028.   parsePatchMediaPresentationDurationChange_(durationString) {
  1029.     const duration = shaka.util.TXml.parseDuration(durationString);
  1030.     if (duration == null) {
  1031.       return;
  1032.     }
  1033.     this.manifestPatchContext_.mediaPresentationDuration = duration;
  1034.     for (const context of this.contextCache_.values()) {
  1035.       context.mediaPresentationDuration = duration;
  1036.     }
  1037.   }
  1039.   /**
  1040.    * Ingests a full MPD period element from a patch update
  1041.    *
  1042.    * @param {!shaka.extern.xml.Node} periods
  1043.    * @private
  1044.    */
  1045.   parsePatchPeriod_(periods) {
  1046.     goog.asserts.assert(this.manifestPatchContext_.getBaseUris,
  1047.         'Must provide getBaseUris on manifestPatchContext_');
  1049.     /** @type {shaka.dash.DashParser.Context} */
  1050.     const context = {
  1051.       dynamic: this.manifestPatchContext_.type == 'dynamic',
  1052.       presentationTimeline: this.manifest_.presentationTimeline,
  1053.       period: null,
  1054.       periodInfo: null,
  1055.       adaptationSet: null,
  1056.       representation: null,
  1057.       bandwidth: 0,
  1058.       indexRangeWarningGiven: false,
  1059.       availabilityTimeOffset: this.manifestPatchContext_.availabilityTimeOffset,
  1060.       profiles: this.manifestPatchContext_.profiles,
  1061.       mediaPresentationDuration:
  1062.           this.manifestPatchContext_.mediaPresentationDuration,
  1063.       roles: null,
  1064.       urlParams: () => '',
  1065.     };
  1067.     const periodsAndDuration = this.parsePeriods_(context,
  1068.         this.manifestPatchContext_.getBaseUris, periods, /* newPeriod= */ true);
  1070.     return periodsAndDuration.periods;
  1071.   }
  1073.   /**
  1074.    * @param {string} periodId
  1075.    * @private
  1076.    */
  1077.   removePatchPeriod_(periodId) {
  1078.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  1079.     this.manifest_.periodCount--;
  1080.     for (const contextId of this.contextCache_.keys()) {
  1081.       if (contextId.startsWith(periodId)) {
  1082.         const context = this.contextCache_.get(contextId);
  1083.         SegmentTemplate.removeTimepoints(context);
  1084.         this.parsePatchSegment_(contextId);
  1085.         this.contextCache_.delete(contextId);
  1086.       }
  1087.     }
  1088.     const newPeriods = this.lastManifestUpdatePeriodIds_.filter((pID) => {
  1089.       return pID !== periodId;
  1090.     });
  1091.     this.lastManifestUpdatePeriodIds_ = newPeriods;
  1092.   }
  1094.   /**
  1095.    * @param {!Array<shaka.util.TXml.PathNode>} paths
  1096.    * @return {!Array<string>}
  1097.    * @private
  1098.    */
  1099.   getContextIdsFromPath_(paths) {
  1100.     let periodId = '';
  1101.     let adaptationSetId = '';
  1102.     let adaptationSetPosition = -1;
  1103.     let representationId = '';
  1104.     for (const node of paths) {
  1105.       if (node.name === 'Period') {
  1106.         periodId = node.id;
  1107.       } else if (node.name === 'AdaptationSet') {
  1108.         adaptationSetId = node.id;
  1109.         if (node.position !== null) {
  1110.           adaptationSetPosition = node.position;
  1111.         }
  1112.       } else if (node.name === 'Representation') {
  1113.         representationId = node.id;
  1114.       }
  1115.     }
  1117.     /** @type {!Array<string>} */
  1118.     const contextIds = [];
  1120.     if (representationId) {
  1121.       contextIds.push(periodId + ',' + representationId);
  1122.     } else {
  1123.       if (adaptationSetId) {
  1124.         for (const context of this.contextCache_.values()) {
  1125.           if (context.period.id === periodId &&
  1126.               context.adaptationSet.id === adaptationSetId &&
  1127.               context.representation.id) {
  1128.             contextIds.push(periodId + ',' + context.representation.id);
  1129.           }
  1130.         }
  1131.       } else {
  1132.         if (adaptationSetPosition > -1) {
  1133.           for (const context of this.contextCache_.values()) {
  1134.             if (context.period.id === periodId &&
  1135.                 context.adaptationSet.position === adaptationSetPosition &&
  1136.                 context.representation.id) {
  1137.               contextIds.push(periodId + ',' + context.representation.id);
  1138.             }
  1139.           }
  1140.         }
  1141.       }
  1142.     }
  1144.     return contextIds;
  1145.   }
  1147.   /**
  1148.    * Modifies SegmentTemplate based on MPD patch.
  1149.    *
  1150.    * @param {!shaka.extern.xml.Node} patchNode
  1151.    * @return {!Array<string>} context ids with updated timeline
  1152.    * @private
  1153.    */
  1154.   modifySegmentTemplate_(patchNode) {
  1155.     const TXml = shaka.util.TXml;
  1156.     const paths = TXml.parseXpath(patchNode.attributes['sel'] || '');
  1157.     const lastPath = paths[paths.length - 1];
  1158.     if (!lastPath.attribute) {
  1159.       return [];
  1160.     }
  1161.     const contextIds = this.getContextIdsFromPath_(paths);
  1162.     const content = TXml.getContents(patchNode) || '';
  1164.     for (const contextId of contextIds) {
  1165.       /** @type {shaka.dash.DashParser.Context} */
  1166.       const context = this.contextCache_.get(contextId);
  1167.       goog.asserts.assert(context && context.representation.segmentTemplate,
  1168.           'cannot modify segment template');
  1169.       TXml.modifyNodeAttribute(context.representation.segmentTemplate,
  1170.           patchNode.tagName, lastPath.attribute, content);
  1171.     }
  1172.     return contextIds;
  1173.   }
  1175.   /**
  1176.    * Ingests Patch MPD segments into timeline.
  1177.    *
  1178.    * @param {!shaka.extern.xml.Node} patchNode
  1179.    * @return {!Array<string>} context ids with updated timeline
  1180.    * @private
  1181.    */
  1182.   modifyTimepoints_(patchNode) {
  1183.     const TXml = shaka.util.TXml;
  1184.     const SegmentTemplate = shaka.dash.SegmentTemplate;
  1186.     const paths = TXml.parseXpath(patchNode.attributes['sel'] || '');
  1187.     const contextIds = this.getContextIdsFromPath_(paths);
  1189.     for (const contextId of contextIds) {
  1190.       /** @type {shaka.dash.DashParser.Context} */
  1191.       const context = this.contextCache_.get(contextId);
  1192.       SegmentTemplate.modifyTimepoints(context, patchNode);
  1193.     }
  1194.     return contextIds;
  1195.   }
  1197.   /**
  1198.    * Parses modified segments.
  1199.    *
  1200.    * @param {string} contextId
  1201.    * @private
  1202.    */
  1203.   parsePatchSegment_(contextId) {
  1204.     /** @type {shaka.dash.DashParser.Context} */
  1205.     const context = this.contextCache_.get(contextId);
  1207.     const currentStream = this.streamMap_.get(contextId);
  1208.     goog.asserts.assert(currentStream, 'stream should exist');
  1210.     if (currentStream.segmentIndex) {
  1211.       currentStream.segmentIndex.evict(
  1212.           this.manifest_.presentationTimeline.getSegmentAvailabilityStart());
  1213.     }
  1215.     try {
  1216.       const requestSegment = (uris, startByte, endByte, isInit) => {
  1217.         return this.requestSegment_(uris, startByte, endByte, isInit);
  1218.       };
  1219.       // TODO we should obtain lastSegmentNumber if possible
  1220.       const streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
  1221.           context, requestSegment, this.streamMap_, /* isUpdate= */ true,
  1222.           this.config_.dash.initialSegmentLimit, this.periodDurations_,
  1223.           context.representation.aesKey, /* lastSegmentNumber= */ null,
  1224.           /* isPatchUpdate= */ true, this.continuityCache_);
  1225.       currentStream.createSegmentIndex = async () => {
  1226.         if (!currentStream.segmentIndex) {
  1227.           currentStream.segmentIndex =
  1228.                 await streamInfo.generateSegmentIndex();
  1229.         }
  1230.       };
  1231.     } catch (error) {
  1232.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1233.       const contentType = context.representation.contentType;
  1234.       const isText = contentType == ContentType.TEXT ||
  1235.             contentType == ContentType.APPLICATION;
  1236.       const isImage = contentType == ContentType.IMAGE;
  1237.       if (!(isText || isImage) ||
  1238.             error.code != shaka.util.Error.Code.DASH_NO_SEGMENT_INFO) {
  1239.         // We will ignore any DASH_NO_SEGMENT_INFO errors for text/image
  1240.         throw error;
  1241.       }
  1242.     }
  1243.   }
  1245.   /**
  1246.    * Reads maxLatency and maxPlaybackRate properties from service
  1247.    * description element.
  1248.    *
  1249.    * @param {!shaka.extern.xml.Node} mpd
  1250.    * @return {?shaka.extern.ServiceDescription}
  1251.    * @private
  1252.    */
  1253.   parseServiceDescription_(mpd) {
  1254.     const TXml = shaka.util.TXml;
  1255.     const elem = TXml.findChild(mpd, 'ServiceDescription');
  1257.     if (!elem ) {
  1258.       return null;
  1259.     }
  1261.     const latencyNode = TXml.findChild(elem, 'Latency');
  1262.     const playbackRateNode = TXml.findChild(elem, 'PlaybackRate');
  1264.     if (!latencyNode && !playbackRateNode) {
  1265.       return null;
  1266.     }
  1268.     const description = {};
  1270.     if (latencyNode) {
  1271.       if ('target' in latencyNode.attributes) {
  1272.         description.targetLatency =
  1273.           parseInt(latencyNode.attributes['target'], 10) / 1000;
  1274.       }
  1275.       if ('max' in latencyNode.attributes) {
  1276.         description.maxLatency =
  1277.           parseInt(latencyNode.attributes['max'], 10) / 1000;
  1278.       }
  1279.       if ('min' in latencyNode.attributes) {
  1280.         description.minLatency =
  1281.           parseInt(latencyNode.attributes['min'], 10) / 1000;
  1282.       }
  1283.     }
  1285.     if (playbackRateNode) {
  1286.       if ('max' in playbackRateNode.attributes) {
  1287.         description.maxPlaybackRate =
  1288.           parseFloat(playbackRateNode.attributes['max']);
  1289.       }
  1290.       if ('min' in playbackRateNode.attributes) {
  1291.         description.minPlaybackRate =
  1292.           parseFloat(playbackRateNode.attributes['min']);
  1293.       }
  1294.     }
  1296.     return description;
  1297.   }
  1299.   /**
  1300.    * Reads chaining url.
  1301.    *
  1302.    * @param {!shaka.extern.xml.Node} mpd
  1303.    * @return {?string}
  1304.    * @private
  1305.    */
  1306.   parseMpdChaining_(mpd) {
  1307.     const TXml = shaka.util.TXml;
  1308.     const supplementalProperties =
  1309.         TXml.findChildren(mpd, 'SupplementalProperty');
  1311.     if (!supplementalProperties.length) {
  1312.       return null;
  1313.     }
  1315.     for (const prop of supplementalProperties) {
  1316.       const schemeId = prop.attributes['schemeIdUri'];
  1317.       if (schemeId == 'urn:mpeg:dash:chaining:2016') {
  1318.         return prop.attributes['value'];
  1319.       }
  1320.     }
  1322.     return null;
  1323.   }
  1325.   /**
  1326.    * Reads and parses the periods from the manifest.  This first does some
  1327.    * partial parsing so the start and duration is available when parsing
  1328.    * children.
  1329.    *
  1330.    * @param {shaka.dash.DashParser.Context} context
  1331.    * @param {function(): !Array<string>} getBaseUris
  1332.    * @param {!shaka.extern.xml.Node} mpd
  1333.    * @param {!boolean} newPeriod
  1334.    * @return {{
  1335.    *   periods: !Array<shaka.extern.Period>,
  1336.    *   duration: ?number,
  1337.    *   durationDerivedFromPeriods: boolean
  1338.    * }}
  1339.    * @private
  1340.    */
  1341.   parsePeriods_(context, getBaseUris, mpd, newPeriod) {
  1342.     const TXml = shaka.util.TXml;
  1343.     let presentationDuration = context.mediaPresentationDuration;
  1345.     if (!presentationDuration) {
  1346.       presentationDuration = TXml.parseAttr(
  1347.           mpd, 'mediaPresentationDuration', TXml.parseDuration);
  1348.       this.manifestPatchContext_.mediaPresentationDuration =
  1349.           presentationDuration;
  1350.     }
  1352.     let seekRangeStart = 0;
  1353.     if (this.manifest_ && this.manifest_.presentationTimeline &&
  1354.         this.isTransitionFromDynamicToStatic_) {
  1355.       seekRangeStart = this.manifest_.presentationTimeline.getSeekRangeStart();
  1356.     }
  1358.     const periods = [];
  1359.     let prevEnd = seekRangeStart;
  1360.     const periodNodes = TXml.findChildren(mpd, 'Period');
  1361.     for (let i = 0; i < periodNodes.length; i++) {
  1362.       const elem = periodNodes[i];
  1363.       const next = periodNodes[i + 1];
  1364.       let start = /** @type {number} */ (
  1365.         TXml.parseAttr(elem, 'start', TXml.parseDuration, prevEnd));
  1366.       const periodId = elem.attributes['id'];
  1367.       const givenDuration =
  1368.           TXml.parseAttr(elem, 'duration', TXml.parseDuration);
  1369.       start = (i == 0 && start == 0 && this.isTransitionFromDynamicToStatic_) ?
  1370.           seekRangeStart : start;
  1372.       let periodDuration = null;
  1373.       if (next) {
  1374.         // "The difference between the start time of a Period and the start time
  1375.         // of the following Period is the duration of the media content
  1376.         // represented by this Period."
  1377.         const nextStart =
  1378.             TXml.parseAttr(next, 'start', TXml.parseDuration);
  1379.         if (nextStart != null) {
  1380.           periodDuration = nextStart - start + seekRangeStart;
  1381.         }
  1382.       } else if (presentationDuration != null) {
  1383.         // "The Period extends until the Period.start of the next Period, or
  1384.         // until the end of the Media Presentation in the case of the last
  1385.         // Period."
  1386.         periodDuration = presentationDuration - start + seekRangeStart;
  1387.       }
  1389.       const threshold =
  1390.           shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS;
  1391.       if (periodDuration && givenDuration &&
  1392.           Math.abs(periodDuration - givenDuration) > threshold) {
  1393.         shaka.log.warning('There is a gap/overlap between Periods', elem);
  1395.         // This means it's a gap, the distance between period starts is
  1396.         // larger than the period's duration
  1397.         if (periodDuration > givenDuration) {
  1398.           this.gapCount_++;
  1399.         }
  1400.       }
  1401.       // Only use the @duration in the MPD if we can't calculate it.  We should
  1402.       // favor the @start of the following Period.  This ensures that there
  1403.       // aren't gaps between Periods.
  1404.       if (periodDuration == null) {
  1405.         periodDuration = givenDuration;
  1406.       }
  1408.       /**
  1409.        * This is to improve robustness when the player observes manifest with
  1410.        * past periods that are inconsistent to previous ones.
  1411.        *
  1412.        * This may happen when a CDN or proxy server switches its upstream from
  1413.        * one encoder to another redundant encoder.
  1414.        *
  1415.        * Skip periods that match all of the following criteria:
  1416.        * - Start time is earlier than latest period start time ever seen
  1417.        * - Period ID is never seen in the previous manifest
  1418.        * - Not the last period in the manifest
  1419.        *
  1420.        * Periods that meet the aforementioned criteria are considered invalid
  1421.        * and should be safe to discard.
  1422.        */
  1424.       if (this.largestPeriodStartTime_ !== null &&
  1425.         periodId !== null && start !== null &&
  1426.         start < this.largestPeriodStartTime_ &&
  1427.         !this.lastManifestUpdatePeriodIds_.includes(periodId) &&
  1428.         i + 1 != periodNodes.length) {
  1429.         shaka.log.debug(
  1430.             `Skipping Period with ID ${periodId} as its start time is smaller` +
  1431.             ' than the largest period start time that has been seen, and ID ' +
  1432.             'is unseen before');
  1433.         continue;
  1434.       }
  1437.       // Save maximum period start time if it is the last period
  1438.       if (start !== null &&
  1439.         (this.largestPeriodStartTime_ === null ||
  1440.           start > this.largestPeriodStartTime_)) {
  1441.         this.largestPeriodStartTime_ = start;
  1442.       }
  1444.       // Parse child nodes.
  1445.       const info = {
  1446.         start: start,
  1447.         duration: periodDuration,
  1448.         node: elem,
  1449.         isLastPeriod: periodDuration == null || !next,
  1450.       };
  1451.       const period = this.parsePeriod_(context, getBaseUris, info);
  1452.       periods.push(period);
  1454.       if (context.period.id && periodDuration) {
  1455.         this.periodDurations_.set(context.period.id, periodDuration);
  1456.       }
  1458.       if (periodDuration == null) {
  1459.         if (next) {
  1460.           // If the duration is still null and we aren't at the end, then we
  1461.           // will skip any remaining periods.
  1462.           shaka.log.warning(
  1463.               'Skipping Period', i + 1, 'and any subsequent Periods:', 'Period',
  1464.               i + 1, 'does not have a valid start time.', next);
  1465.         }
  1467.         // The duration is unknown, so the end is unknown.
  1468.         prevEnd = null;
  1469.         break;
  1470.       }
  1472.       prevEnd = start + periodDuration;
  1473.     } // end of period parsing loop
  1475.     if (newPeriod) {
  1476.       // append new period from the patch manifest
  1477.       for (const el of periods) {
  1478.         const periodID = el.id;
  1479.         if (!this.lastManifestUpdatePeriodIds_.includes(periodID)) {
  1480.           this.lastManifestUpdatePeriodIds_.push(periodID);
  1481.         }
  1482.       }
  1483.     } else {
  1484.       // Replace previous seen periods with the current one.
  1485.       this.lastManifestUpdatePeriodIds_ = periods.map((el) => el.id);
  1486.     }
  1488.     if (presentationDuration != null) {
  1489.       if (prevEnd != null) {
  1490.         const threshold =
  1491.             shaka.util.ManifestParserUtils.GAP_OVERLAP_TOLERANCE_SECONDS;
  1492.         const difference = prevEnd - seekRangeStart - presentationDuration;
  1493.         if (Math.abs(difference) > threshold) {
  1494.           shaka.log.warning(
  1495.               '@mediaPresentationDuration does not match the total duration ',
  1496.               'of all Periods.');
  1497.           // Assume @mediaPresentationDuration is correct.
  1498.         }
  1499.       }
  1500.       return {
  1501.         periods: periods,
  1502.         duration: presentationDuration + seekRangeStart,
  1503.         durationDerivedFromPeriods: false,
  1504.       };
  1505.     } else {
  1506.       return {
  1507.         periods: periods,
  1508.         duration: prevEnd,
  1509.         durationDerivedFromPeriods: true,
  1510.       };
  1511.     }
  1512.   }
  1514.   /**
  1515.    * Clean StreamMap Object to remove reference of deleted Stream Object
  1516.    * @private
  1517.    */
  1518.   cleanStreamMap_() {
  1519.     const oldPeriodIds = Array.from(this.indexStreamMap_.keys());
  1520.     const diffPeriodsIDs = oldPeriodIds.filter((pId) => {
  1521.       return !this.lastManifestUpdatePeriodIds_.includes(pId);
  1522.     });
  1523.     for (const pId of diffPeriodsIDs) {
  1524.       let shouldDeleteIndex = true;
  1525.       for (const contextId of this.indexStreamMap_.get(pId)) {
  1526.         const stream = this.streamMap_.get(contextId);
  1527.         if (!stream) {
  1528.           continue;
  1529.         }
  1530.         if (stream.segmentIndex && !stream.segmentIndex.isEmpty()) {
  1531.           shouldDeleteIndex = false;
  1532.           continue;
  1533.         }
  1534.         if (this.periodCombiner_) {
  1535.           this.periodCombiner_.deleteStream(stream, pId);
  1536.         }
  1537.         this.streamMap_.delete(contextId);
  1538.       }
  1539.       if (shouldDeleteIndex) {
  1540.         this.indexStreamMap_.delete(pId);
  1541.       }
  1542.     }
  1543.   }
  1545.   /**
  1546.    * Clean continuityCache Object to remove reference of removed periods.
  1547.    * This should end up running after the current manifest has been processed
  1548.    * so that it can use previous periods to calculate the continuity of the new
  1549.    * periods.
  1550.    * @param {!Array<shaka.extern.Period>} periods
  1551.    * @private
  1552.    */
  1553.   cleanContinuityCache_(periods) {
  1554.     const activePeriodId = new Set(periods.map((p) => p.id));
  1555.     for (const key of this.continuityCache_.keys()) {
  1556.       if (!activePeriodId.has(key)) {
  1557.         this.continuityCache_.delete(key);
  1558.       }
  1559.     }
  1560.   }
  1562.   /**
  1563.    * Parses a Period XML element.  Unlike the other parse methods, this is not
  1564.    * given the Node; it is given a PeriodInfo structure.  Also, partial parsing
  1565.    * was done before this was called so start and duration are valid.
  1566.    *
  1567.    * @param {shaka.dash.DashParser.Context} context
  1568.    * @param {function(): !Array<string>} getBaseUris
  1569.    * @param {shaka.dash.DashParser.PeriodInfo} periodInfo
  1570.    * @return {shaka.extern.Period}
  1571.    * @private
  1572.    */
  1573.   parsePeriod_(context, getBaseUris, periodInfo) {
  1574.     const Functional = shaka.util.Functional;
  1575.     const TXml = shaka.util.TXml;
  1576.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1578.     goog.asserts.assert(periodInfo.node, 'periodInfo.node should exist');
  1579.     context.period = this.createFrame_(periodInfo.node, null, getBaseUris);
  1580.     context.periodInfo = periodInfo;
  1581.     context.period.availabilityTimeOffset = context.availabilityTimeOffset;
  1583.     // If the period doesn't have an ID, give it one based on its start time.
  1584.     if (!context.period.id) {
  1585.       shaka.log.info(
  1586.           'No Period ID given for Period with start time ' + periodInfo.start +
  1587.           ',  Assigning a default');
  1588.       context.period.id = '__shaka_period_' + periodInfo.start;
  1589.     }
  1591.     const eventStreamNodes =
  1592.         TXml.findChildren(periodInfo.node, 'EventStream');
  1593.     const availabilityStart =
  1594.         context.presentationTimeline.getSegmentAvailabilityStart();
  1596.     for (const node of eventStreamNodes) {
  1597.       this.parseEventStream_(
  1598.           periodInfo.start, periodInfo.duration, node, availabilityStart);
  1599.     }
  1602.     const supplementalProperties =
  1603.         TXml.findChildren(periodInfo.node, 'SupplementalProperty');
  1604.     for (const prop of supplementalProperties) {
  1605.       const schemeId = prop.attributes['schemeIdUri'];
  1606.       if (schemeId == 'urn:mpeg:dash:urlparam:2014') {
  1607.         const urlParams = this.getURLParametersFunction_(prop);
  1608.         if (urlParams) {
  1609.           context.urlParams = urlParams;
  1610.         }
  1611.       }
  1612.     }
  1614.     const adaptationSets =
  1615.         TXml.findChildren(periodInfo.node, 'AdaptationSet')
  1616.             .map((node, position) =>
  1617.               this.parseAdaptationSet_(context, position, node))
  1618.             .filter(Functional.isNotNull);
  1620.     // For dynamic manifests, we use rep IDs internally, and they must be
  1621.     // unique.
  1622.     if (context.dynamic) {
  1623.       const ids = [];
  1624.       for (const set of adaptationSets) {
  1625.         for (const id of set.representationIds) {
  1626.           ids.push(id);
  1627.         }
  1628.       }
  1630.       const uniqueIds = new Set(ids);
  1632.       if (ids.length != uniqueIds.size) {
  1633.         throw new shaka.util.Error(
  1634.             shaka.util.Error.Severity.CRITICAL,
  1635.             shaka.util.Error.Category.MANIFEST,
  1636.             shaka.util.Error.Code.DASH_DUPLICATE_REPRESENTATION_ID);
  1637.       }
  1638.     }
  1640.     /** @type {!Map<string, shaka.extern.Stream>} */
  1641.     const dependencyStreamMap = new Map();
  1642.     for (const adaptationSet of adaptationSets) {
  1643.       for (const [dependencyId, stream] of adaptationSet.dependencyStreamMap) {
  1644.         dependencyStreamMap.set(dependencyId, stream);
  1645.       }
  1646.     }
  1648.     if (dependencyStreamMap.size) {
  1649.       let duplicateAdaptationSets = null;
  1650.       for (const adaptationSet of adaptationSets) {
  1651.         const streamsWithDependencyStream = [];
  1652.         for (const stream of adaptationSet.streams) {
  1653.           if (dependencyStreamMap.has(stream.originalId)) {
  1654.             if (!duplicateAdaptationSets) {
  1655.               duplicateAdaptationSets =
  1656.                   TXml.findChildren(periodInfo.node, 'AdaptationSet')
  1657.                       .map((node, position) =>
  1658.                         this.parseAdaptationSet_(context, position, node))
  1659.                       .filter(Functional.isNotNull);
  1660.             }
  1661.             for (const duplicateAdaptationSet of duplicateAdaptationSets) {
  1662.               const newStream = duplicateAdaptationSet.streams.find(
  1663.                   (s) => s.originalId == stream.originalId);
  1664.               if (newStream) {
  1665.                 newStream.dependencyStream =
  1666.                     dependencyStreamMap.get(newStream.originalId);
  1667.                 newStream.originalId += newStream.dependencyStream.originalId;
  1668.                 streamsWithDependencyStream.push(newStream);
  1669.               }
  1670.             }
  1671.           }
  1672.         }
  1673.         if (streamsWithDependencyStream.length) {
  1674.           adaptationSet.streams.push(...streamsWithDependencyStream);
  1675.         }
  1676.       }
  1677.     }
  1679.     const normalAdaptationSets = adaptationSets
  1680.         .filter((as) => { return !as.trickModeFor; });
  1682.     const trickModeAdaptationSets = adaptationSets
  1683.         .filter((as) => { return as.trickModeFor; });
  1685.     // Attach trick mode tracks to normal tracks.
  1686.     if (!this.config_.disableIFrames) {
  1687.       for (const trickModeSet of trickModeAdaptationSets) {
  1688.         const targetIds = trickModeSet.trickModeFor.split(' ');
  1689.         for (const normalSet of normalAdaptationSets) {
  1690.           if (targetIds.includes(normalSet.id)) {
  1691.             for (const stream of normalSet.streams) {
  1692.               shaka.util.StreamUtils.setBetterIFrameStream(
  1693.                   stream, trickModeSet.streams);
  1694.             }
  1695.           }
  1696.         }
  1697.       }
  1698.     }
  1700.     const audioStreams = this.getStreamsFromSets_(
  1701.         this.config_.disableAudio,
  1702.         normalAdaptationSets,
  1703.         ContentType.AUDIO);
  1704.     const videoStreams = this.getStreamsFromSets_(
  1705.         this.config_.disableVideo,
  1706.         normalAdaptationSets,
  1707.         ContentType.VIDEO);
  1708.     const textStreams = this.getStreamsFromSets_(
  1709.         this.config_.disableText,
  1710.         normalAdaptationSets,
  1711.         ContentType.TEXT);
  1712.     const imageStreams = this.getStreamsFromSets_(
  1713.         this.config_.disableThumbnails,
  1714.         normalAdaptationSets,
  1715.         ContentType.IMAGE);
  1717.     if (videoStreams.length === 0 && audioStreams.length === 0) {
  1718.       throw new shaka.util.Error(
  1719.           shaka.util.Error.Severity.CRITICAL,
  1720.           shaka.util.Error.Category.MANIFEST,
  1721.           shaka.util.Error.Code.DASH_EMPTY_PERIOD,
  1722.       );
  1723.     }
  1725.     return {
  1726.       id: context.period.id,
  1727.       audioStreams,
  1728.       videoStreams,
  1729.       textStreams,
  1730.       imageStreams,
  1731.     };
  1732.   }
  1734.   /**
  1735.    * Gets the streams from the given sets or returns an empty array if disabled
  1736.    * or no streams are found.
  1737.    * @param {boolean} disabled
  1738.    * @param {!Array<!shaka.dash.DashParser.AdaptationInfo>} adaptationSets
  1739.    * @param {string} contentType
  1740.    * @private
  1741.    */
  1742.   getStreamsFromSets_(disabled, adaptationSets, contentType) {
  1743.     if (disabled || !adaptationSets.length) {
  1744.       return [];
  1745.     }
  1747.     return adaptationSets.reduce((all, part) => {
  1748.       if (part.contentType != contentType) {
  1749.         return all;
  1750.       }
  1752.       all.push(...part.streams);
  1753.       return all;
  1754.     }, []);
  1755.   }
  1757.   /**
  1758.    * Parses an AdaptationSet XML element.
  1759.    *
  1760.    * @param {shaka.dash.DashParser.Context} context
  1761.    * @param {number} position
  1762.    * @param {!shaka.extern.xml.Node} elem The AdaptationSet element.
  1763.    * @return {?shaka.dash.DashParser.AdaptationInfo}
  1764.    * @private
  1765.    */
  1766.   parseAdaptationSet_(context, position, elem) {
  1767.     const TXml = shaka.util.TXml;
  1768.     const Functional = shaka.util.Functional;
  1769.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  1770.     const ContentType = ManifestParserUtils.ContentType;
  1771.     const ContentProtection = shaka.dash.ContentProtection;
  1773.     context.adaptationSet = this.createFrame_(elem, context.period, null);
  1774.     context.adaptationSet.position = position;
  1776.     let main = false;
  1777.     const roleElements = TXml.findChildren(elem, 'Role');
  1778.     const roleValues = roleElements.map((role) => {
  1779.       return role.attributes['value'];
  1780.     }).filter(Functional.isNotNull);
  1782.     // Default kind for text streams is 'subtitle' if unspecified in the
  1783.     // manifest.
  1784.     let kind = undefined;
  1785.     const isText = context.adaptationSet.contentType == ContentType.TEXT;
  1786.     if (isText) {
  1787.       kind = ManifestParserUtils.TextStreamKind.SUBTITLE;
  1788.     }
  1790.     for (const roleElement of roleElements) {
  1791.       const scheme = roleElement.attributes['schemeIdUri'];
  1792.       if (scheme == null || scheme == 'urn:mpeg:dash:role:2011') {
  1793.         // These only apply for the given scheme, but allow them to be specified
  1794.         // if there is no scheme specified.
  1795.         // See: DASH section 5.8.5.5
  1796.         const value = roleElement.attributes['value'];
  1797.         switch (value) {
  1798.           case 'main':
  1799.             main = true;
  1800.             break;
  1801.           case 'caption':
  1802.           case 'subtitle':
  1803.             kind = value;
  1804.             break;
  1805.         }
  1806.       }
  1807.     }
  1809.     // Parallel for HLS VIDEO-RANGE as defined in DASH-IF IOP v4.3 6.2.5.1.
  1810.     let videoRange;
  1812.     let colorGamut;
  1814.     // Ref. https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf
  1815.     // If signaled, a Supplemental or Essential Property descriptor
  1816.     // shall be used, with the schemeIdUri set to
  1817.     // urn:mpeg:mpegB:cicp:<Parameter> as defined in
  1818.     // ISO/IEC 23001-8 [49] and <Parameter> one of the
  1819.     // following: ColourPrimaries, TransferCharacteristics,
  1820.     // or MatrixCoefficients.
  1821.     const scheme = 'urn:mpeg:mpegB:cicp';
  1822.     const transferCharacteristicsScheme = `${scheme}:TransferCharacteristics`;
  1823.     const colourPrimariesScheme = `${scheme}:ColourPrimaries`;
  1824.     const matrixCoefficientsScheme = `${scheme}:MatrixCoefficients`;
  1826.     const getVideoRangeFromTransferCharacteristicCICP = (cicp) => {
  1827.       switch (cicp) {
  1828.         case 1:
  1829.         case 6:
  1830.         case 13:
  1831.         case 14:
  1832.         case 15:
  1833.           return 'SDR';
  1834.         case 16:
  1835.           return 'PQ';
  1836.         case 18:
  1837.           return 'HLG';
  1838.       }
  1839.       return undefined;
  1840.     };
  1842.     const getColorGamutFromColourPrimariesCICP = (cicp) => {
  1843.       switch (cicp) {
  1844.         case 1:
  1845.         case 5:
  1846.         case 6:
  1847.         case 7:
  1848.           return 'srgb';
  1849.         case 9:
  1850.           return 'rec2020';
  1851.         case 11:
  1852.         case 12:
  1853.           return 'p3';
  1854.       }
  1855.       return undefined;
  1856.     };
  1858.     const parseFont = (prop) => {
  1859.       const fontFamily = prop.attributes['dvb:fontFamily'];
  1860.       const fontUrl = prop.attributes['dvb:url'];
  1861.       if (fontFamily && fontUrl) {
  1862.         const uris = shaka.util.ManifestParserUtils.resolveUris(
  1863.             context.adaptationSet.getBaseUris(), [fontUrl],
  1864.             context.urlParams());
  1865.         this.playerInterface_.addFont(fontFamily, uris[0]);
  1866.       }
  1867.     };
  1869.     const essentialProperties =
  1870.         TXml.findChildren(elem, 'EssentialProperty');
  1871.     // ID of real AdaptationSet if this is a trick mode set:
  1872.     let trickModeFor = null;
  1873.     let isFastSwitching = false;
  1874.     let adaptationSetUrlParams = null;
  1875.     let unrecognizedEssentialProperty = false;
  1876.     for (const prop of essentialProperties) {
  1877.       const schemeId = prop.attributes['schemeIdUri'];
  1878.       if (schemeId == 'http://dashif.org/guidelines/trickmode') {
  1879.         trickModeFor = prop.attributes['value'];
  1880.       } else if (schemeId == transferCharacteristicsScheme) {
  1881.         videoRange = getVideoRangeFromTransferCharacteristicCICP(
  1882.             parseInt(prop.attributes['value'], 10),
  1883.         );
  1884.       } else if (schemeId == colourPrimariesScheme) {
  1885.         colorGamut = getColorGamutFromColourPrimariesCICP(
  1886.             parseInt(prop.attributes['value'], 10),
  1887.         );
  1888.       } else if (schemeId == matrixCoefficientsScheme) {
  1889.         continue;
  1890.       } else if (schemeId == 'urn:mpeg:dash:ssr:2023' &&
  1891.           this.config_.dash.enableFastSwitching) {
  1892.         isFastSwitching = true;
  1893.       } else if (schemeId == 'urn:dvb:dash:fontdownload:2014') {
  1894.         parseFont(prop);
  1895.       } else if (schemeId == 'urn:mpeg:dash:urlparam:2014') {
  1896.         adaptationSetUrlParams = this.getURLParametersFunction_(prop);
  1897.         if (!adaptationSetUrlParams) {
  1898.           unrecognizedEssentialProperty = true;
  1899.         }
  1900.       } else {
  1901.         unrecognizedEssentialProperty = true;
  1902.       }
  1903.     }
  1905.     // According to DASH spec (2014) section 5.8.4.8, "the successful processing
  1906.     // of the descriptor is essential to properly use the information in the
  1907.     // parent element".  According to DASH IOP v3.3, section 3.3.4, "if the
  1908.     // scheme or the value" for EssentialProperty is not recognized, "the DASH
  1909.     // client shall ignore the parent element."
  1910.     if (unrecognizedEssentialProperty) {
  1911.       // Stop parsing this AdaptationSet and let the caller filter out the
  1912.       // nulls.
  1913.       return null;
  1914.     }
  1916.     let lastSegmentNumber = null;
  1918.     const supplementalProperties =
  1919.         TXml.findChildren(elem, 'SupplementalProperty');
  1920.     for (const prop of supplementalProperties) {
  1921.       const schemeId = prop.attributes['schemeIdUri'];
  1922.       if (schemeId == 'http://dashif.org/guidelines/last-segment-number') {
  1923.         lastSegmentNumber = parseInt(prop.attributes['value'], 10) - 1;
  1924.       } else if (schemeId == transferCharacteristicsScheme) {
  1925.         videoRange = getVideoRangeFromTransferCharacteristicCICP(
  1926.             parseInt(prop.attributes['value'], 10),
  1927.         );
  1928.       } else if (schemeId == colourPrimariesScheme) {
  1929.         colorGamut = getColorGamutFromColourPrimariesCICP(
  1930.             parseInt(prop.attributes['value'], 10),
  1931.         );
  1932.       } else if (schemeId == 'urn:dvb:dash:fontdownload:2014') {
  1933.         parseFont(prop);
  1934.       } else if (schemeId == 'urn:mpeg:dash:urlparam:2014') {
  1935.         adaptationSetUrlParams = this.getURLParametersFunction_(prop);
  1936.       }
  1937.     }
  1939.     if (adaptationSetUrlParams) {
  1940.       context.urlParams = adaptationSetUrlParams;
  1941.     }
  1943.     const accessibilities = TXml.findChildren(elem, 'Accessibility');
  1944.     const LanguageUtils = shaka.util.LanguageUtils;
  1945.     const closedCaptions = new Map();
  1946.     /** @type {?shaka.media.ManifestParser.AccessibilityPurpose} */
  1947.     let accessibilityPurpose;
  1948.     for (const prop of accessibilities) {
  1949.       const schemeId = prop.attributes['schemeIdUri'];
  1950.       const value = prop.attributes['value'];
  1951.       if (schemeId == 'urn:scte:dash:cc:cea-608:2015' &&
  1952.           !this.config_.disableText) {
  1953.         let channelId = 1;
  1954.         if (value != null) {
  1955.           const channelAssignments = value.split(';');
  1956.           for (const captionStr of channelAssignments) {
  1957.             let channel;
  1958.             let language;
  1959.             // Some closed caption descriptions have channel number and
  1960.             // language ("CC1=eng") others may only have language ("eng,spa").
  1961.             if (!captionStr.includes('=')) {
  1962.               // When the channel assignments are not explicitly provided and
  1963.               // there are only 2 values provided, it is highly likely that the
  1964.               // assignments are CC1 and CC3 (most commonly used CC streams).
  1965.               // Otherwise, cycle through all channels arbitrarily (CC1 - CC4)
  1966.               // in order of provided langs.
  1967.               channel = `CC${channelId}`;
  1968.               if (channelAssignments.length == 2) {
  1969.                 channelId += 2;
  1970.               } else {
  1971.                 channelId ++;
  1972.               }
  1973.               language = captionStr;
  1974.             } else {
  1975.               const channelAndLanguage = captionStr.split('=');
  1976.               // The channel info can be '1' or 'CC1'.
  1977.               // If the channel info only has channel number(like '1'), add 'CC'
  1978.               // as prefix so that it can be a full channel id (like 'CC1').
  1979.               channel = channelAndLanguage[0].startsWith('CC') ?
  1980.                   channelAndLanguage[0] : `CC${channelAndLanguage[0]}`;
  1982.               // 3 letters (ISO 639-2).  In b/187442669, we saw a blank string
  1983.               // (CC2=;CC3=), so default to "und" (the code for "undetermined").
  1984.               language = channelAndLanguage[1] || 'und';
  1985.             }
  1986.             closedCaptions.set(channel, LanguageUtils.normalize(language));
  1987.           }
  1988.         } else {
  1989.           // If channel and language information has not been provided, assign
  1990.           // 'CC1' as channel id and 'und' as language info.
  1991.           closedCaptions.set('CC1', 'und');
  1992.         }
  1993.       } else if (schemeId == 'urn:scte:dash:cc:cea-708:2015' &&
  1994.           !this.config_.disableText) {
  1995.         let serviceNumber = 1;
  1996.         if (value != null) {
  1997.           for (const captionStr of value.split(';')) {
  1998.             let service;
  1999.             let language;
  2000.             // Similar to CEA-608, it is possible that service # assignments
  2001.             // are not explicitly provided e.g. "eng;deu;swe" In this case,
  2002.             // we just cycle through the services for each language one by one.
  2003.             if (!captionStr.includes('=')) {
  2004.               service = `svc${serviceNumber}`;
  2005.               serviceNumber ++;
  2006.               language = captionStr;
  2007.             } else {
  2008.             // Otherwise, CEA-708 caption values take the form "
  2009.             // 1=lang:eng;2=lang:deu" i.e. serviceNumber=lang:threeLetterCode.
  2010.               const serviceAndLanguage = captionStr.split('=');
  2011.               service = `svc${serviceAndLanguage[0]}`;
  2013.               // The language info can be different formats, lang:eng',
  2014.               // or 'lang:eng,war:1,er:1'. Extract the language info.
  2015.               language = serviceAndLanguage[1].split(',')[0].split(':').pop();
  2016.             }
  2017.             closedCaptions.set(service, LanguageUtils.normalize(language));
  2018.           }
  2019.         } else {
  2020.           // If service and language information has not been provided, assign
  2021.           // 'svc1' as service number and 'und' as language info.
  2022.           closedCaptions.set('svc1', 'und');
  2023.         }
  2024.       } else if (schemeId == 'urn:mpeg:dash:role:2011') {
  2025.         // See DASH IOP 3.9.2 Table 4.
  2026.         if (value != null) {
  2027.           roleValues.push(value);
  2028.           if (value == 'captions') {
  2029.             kind = ManifestParserUtils.TextStreamKind.CLOSED_CAPTION;
  2030.           }
  2031.         }
  2032.       } else if (schemeId == 'urn:tva:metadata:cs:AudioPurposeCS:2007') {
  2033.         // See DASH DVB Document A168 Rev.6 Table 5.
  2034.         if (value == '1') {
  2035.           accessibilityPurpose =
  2036.               shaka.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED;
  2037.         } else if (value == '2') {
  2038.           accessibilityPurpose =
  2039.               shaka.media.ManifestParser.AccessibilityPurpose.HARD_OF_HEARING;
  2040.         } else if (value == '9') {
  2041.           accessibilityPurpose =
  2042.               shaka.media.ManifestParser.AccessibilityPurpose.SPOKEN_SUBTITLES;
  2043.         }
  2044.       }
  2045.     }
  2047.     const contentProtectionElements =
  2048.         TXml.findChildren(elem, 'ContentProtection');
  2049.     const contentProtection = ContentProtection.parseFromAdaptationSet(
  2050.         contentProtectionElements,
  2051.         this.config_.ignoreDrmInfo,
  2052.         this.config_.dash.keySystemsByURI);
  2054.     // We us contentProtectionElements instead of drmInfos as the latter is
  2055.     // not populated yet, and we need the encrypted flag for the upcoming
  2056.     // parseRepresentation that will set the encrypted flag to the init seg.
  2057.     context.adaptationSet.encrypted = contentProtectionElements.length > 0;
  2059.     const language = shaka.util.LanguageUtils.normalize(
  2060.         context.adaptationSet.language || 'und');
  2062.     const label = context.adaptationSet.label;
  2064.     /** @type {!Map<string, shaka.extern.Stream>} */
  2065.     const dependencyStreamMap = new Map();
  2067.     // Parse Representations into Streams.
  2068.     const representations = TXml.findChildren(elem, 'Representation');
  2069.     if (!this.config_.ignoreSupplementalCodecs) {
  2070.       const supplementalRepresentations = [];
  2071.       for (const rep of representations) {
  2072.         const supplementalCodecs = TXml.getAttributeNS(
  2073.             rep, shaka.dash.DashParser.SCTE214_, 'supplementalCodecs');
  2074.         if (supplementalCodecs) {
  2075.           // Duplicate representations with their supplementalCodecs
  2076.           const obj = shaka.util.ObjectUtils.cloneObject(rep);
  2077.           obj.attributes['codecs'] = supplementalCodecs.split(' ').join(',');
  2078.           if (obj.attributes['id']) {
  2079.             obj.attributes['supplementalId'] =
  2080.                 obj.attributes['id'] + '_supplementalCodecs';
  2081.           }
  2082.           supplementalRepresentations.push(obj);
  2083.         }
  2084.       }
  2085.       representations.push(...supplementalRepresentations);
  2086.     }
  2087.     const streams = representations.map((representation) => {
  2088.       const parsedRepresentation = this.parseRepresentation_(context,
  2089.           contentProtection, kind, language, label, main, roleValues,
  2090.           closedCaptions, representation, accessibilityPurpose,
  2091.           lastSegmentNumber);
  2092.       if (parsedRepresentation) {
  2093.         parsedRepresentation.hdr = parsedRepresentation.hdr || videoRange;
  2094.         parsedRepresentation.colorGamut =
  2095.             parsedRepresentation.colorGamut || colorGamut;
  2096.         parsedRepresentation.fastSwitching = isFastSwitching;
  2097.         const dependencyId = representation.attributes['dependencyId'];
  2098.         if (dependencyId) {
  2099.           parsedRepresentation.baseOriginalId = dependencyId;
  2100.           dependencyStreamMap.set(dependencyId, parsedRepresentation);
  2101.           return null;
  2102.         }
  2103.       }
  2104.       return parsedRepresentation;
  2105.     }).filter((s) => !!s);
  2107.     if (streams.length == 0 && dependencyStreamMap.size == 0) {
  2108.       const isImage = context.adaptationSet.contentType == ContentType.IMAGE;
  2109.       // Ignore empty AdaptationSets if ignoreEmptyAdaptationSet is true
  2110.       // or they are for text/image content.
  2111.       if (this.config_.dash.ignoreEmptyAdaptationSet || isText || isImage) {
  2112.         return null;
  2113.       }
  2114.       throw new shaka.util.Error(
  2115.           shaka.util.Error.Severity.CRITICAL,
  2116.           shaka.util.Error.Category.MANIFEST,
  2117.           shaka.util.Error.Code.DASH_EMPTY_ADAPTATION_SET);
  2118.     }
  2120.     // If AdaptationSet's type is unknown or is ambiguously "application",
  2121.     // guess based on the information in the first stream.  If the attributes
  2122.     // mimeType and codecs are split across levels, they will both be inherited
  2123.     // down to the stream level by this point, so the stream will have all the
  2124.     // necessary information.
  2125.     if (!context.adaptationSet.contentType ||
  2126.         context.adaptationSet.contentType == ContentType.APPLICATION) {
  2127.       const mimeType = streams[0].mimeType;
  2128.       const codecs = streams[0].codecs;
  2129.       context.adaptationSet.contentType =
  2130.           shaka.dash.DashParser.guessContentType_(mimeType, codecs);
  2132.       for (const stream of streams) {
  2133.         stream.type = context.adaptationSet.contentType;
  2134.       }
  2135.     }
  2137.     const adaptationId = context.adaptationSet.id ||
  2138.         ('__fake__' + this.globalId_++);
  2140.     for (const stream of streams) {
  2141.       // Some DRM license providers require that we have a default
  2142.       // key ID from the manifest in the wrapped license request.
  2143.       // Thus, it should be put in drmInfo to be accessible to request filters.
  2144.       for (const drmInfo of contentProtection.drmInfos) {
  2145.         drmInfo.keyIds = drmInfo.keyIds && stream.keyIds ?
  2146.             new Set([...drmInfo.keyIds, ...stream.keyIds]) :
  2147.             drmInfo.keyIds || stream.keyIds;
  2148.       }
  2149.       stream.groupId = adaptationId;
  2150.     }
  2152.     const repIds = representations
  2153.         .map((node) => {
  2154.           return node.attributes['supplementalId'] || node.attributes['id'];
  2155.         }).filter(shaka.util.Functional.isNotNull);
  2157.     return {
  2158.       id: adaptationId,
  2159.       contentType: context.adaptationSet.contentType,
  2160.       language: language,
  2161.       main: main,
  2162.       streams: streams,
  2163.       drmInfos: contentProtection.drmInfos,
  2164.       trickModeFor: trickModeFor,
  2165.       representationIds: repIds,
  2166.       dependencyStreamMap,
  2167.     };
  2168.   }
  2170.   /**
  2171.    * @param {!shaka.extern.xml.Node} elem
  2172.    * @return {?function():string}
  2173.    * @private
  2174.    */
  2175.   getURLParametersFunction_(elem) {
  2176.     const TXml = shaka.util.TXml;
  2177.     const urlQueryInfo = TXml.findChildNS(
  2178.         elem, shaka.dash.DashParser.UP_NAMESPACE_, 'UrlQueryInfo');
  2179.     if (urlQueryInfo && TXml.parseAttr(urlQueryInfo, 'useMPDUrlQuery',
  2180.         TXml.parseBoolean, /* defaultValue= */ false)) {
  2181.       const queryTemplate = urlQueryInfo.attributes['queryTemplate'];
  2182.       if (queryTemplate) {
  2183.         return () => {
  2184.           if (queryTemplate == '$querypart$') {
  2185.             return this.lastManifestQueryParams_;
  2186.           }
  2187.           const parameters = queryTemplate.split('&').map((param) => {
  2188.             if (param == '$querypart$') {
  2189.               return this.lastManifestQueryParams_;
  2190.             } else {
  2191.               const regex = /\$query:(.*?)\$/g;
  2192.               const parts = regex.exec(param);
  2193.               if (parts && parts.length == 2) {
  2194.                 const paramName = parts[1];
  2195.                 const queryData =
  2196.                     new goog.Uri.QueryData(this.lastManifestQueryParams_);
  2197.                 const value = queryData.get(paramName);
  2198.                 if (value.length) {
  2199.                   return paramName + '=' + value[0];
  2200.                 }
  2201.               }
  2202.               return param;
  2203.             }
  2204.           });
  2205.           return parameters.join('&');
  2206.         };
  2207.       }
  2208.     }
  2209.     return null;
  2210.   }
  2212.   /**
  2213.    * Parses a Representation XML element.
  2214.    *
  2215.    * @param {shaka.dash.DashParser.Context} context
  2216.    * @param {shaka.dash.ContentProtection.Context} contentProtection
  2217.    * @param {(string|undefined)} kind
  2218.    * @param {string} language
  2219.    * @param {?string} label
  2220.    * @param {boolean} isPrimary
  2221.    * @param {!Array<string>} roles
  2222.    * @param {Map<string, string>} closedCaptions
  2223.    * @param {!shaka.extern.xml.Node} node
  2224.    * @param {?shaka.media.ManifestParser.AccessibilityPurpose
  2225.    *        } accessibilityPurpose
  2226.    * @param {?number} lastSegmentNumber
  2227.    *
  2228.    * @return {?shaka.extern.Stream} The Stream, or null when there is a
  2229.    *   non-critical parsing error.
  2230.    * @private
  2231.    */
  2232.   parseRepresentation_(context, contentProtection, kind, language, label,
  2233.       isPrimary, roles, closedCaptions, node, accessibilityPurpose,
  2234.       lastSegmentNumber) {
  2235.     const TXml = shaka.util.TXml;
  2236.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2238.     context.representation =
  2239.         this.createFrame_(node, context.adaptationSet, null);
  2241.     const representationId = context.representation.id;
  2243.     this.minTotalAvailabilityTimeOffset_ =
  2244.         Math.min(this.minTotalAvailabilityTimeOffset_,
  2245.             context.representation.availabilityTimeOffset);
  2247.     this.isLowLatency_ = this.minTotalAvailabilityTimeOffset_ > 0;
  2249.     if (!this.verifyRepresentation_(context.representation)) {
  2250.       shaka.log.warning('Skipping Representation', context.representation);
  2251.       return null;
  2252.     }
  2253.     const periodStart = context.periodInfo.start;
  2255.     // NOTE: bandwidth is a mandatory attribute according to the spec, and zero
  2256.     // does not make sense in the DASH spec's bandwidth formulas.
  2257.     // In some content, however, the attribute is missing or zero.
  2258.     // To avoid NaN at the variant level on broken content, fall back to zero.
  2259.     // https://github.com/shaka-project/shaka-player/issues/938#issuecomment-317278180
  2260.     context.bandwidth =
  2261.         TXml.parseAttr(node, 'bandwidth', TXml.parsePositiveInt) || 0;
  2263.     context.roles = roles;
  2265.     const supplementalPropertyElements =
  2266.         TXml.findChildren(node, 'SupplementalProperty');
  2267.     const essentialPropertyElements =
  2268.         TXml.findChildren(node, 'EssentialProperty');
  2269.     const contentProtectionElements =
  2270.         TXml.findChildren(node, 'ContentProtection');
  2272.     let representationUrlParams = null;
  2273.     let urlParamsElement = essentialPropertyElements.find((element) => {
  2274.       const schemeId = element.attributes['schemeIdUri'];
  2275.       return schemeId == 'urn:mpeg:dash:urlparam:2014';
  2276.     });
  2277.     if (urlParamsElement) {
  2278.       representationUrlParams =
  2279.           this.getURLParametersFunction_(urlParamsElement);
  2280.     } else {
  2281.       urlParamsElement = supplementalPropertyElements.find((element) => {
  2282.         const schemeId = element.attributes['schemeIdUri'];
  2283.         return schemeId == 'urn:mpeg:dash:urlparam:2014';
  2284.       });
  2285.       if (urlParamsElement) {
  2286.         representationUrlParams =
  2287.             this.getURLParametersFunction_(urlParamsElement);
  2288.       }
  2289.     }
  2291.     if (representationUrlParams) {
  2292.       context.urlParams = representationUrlParams;
  2293.     }
  2295.     /** @type {?shaka.dash.DashParser.StreamInfo} */
  2296.     let streamInfo;
  2298.     const contentType = context.representation.contentType;
  2299.     const isText = contentType == ContentType.TEXT ||
  2300.                    contentType == ContentType.APPLICATION;
  2301.     const isImage = contentType == ContentType.IMAGE;
  2303.     if (contentProtectionElements.length) {
  2304.       context.adaptationSet.encrypted = true;
  2305.     }
  2307.     try {
  2308.       /** @type {shaka.extern.aesKey|undefined} */
  2309.       let aesKey = undefined;
  2310.       if (contentProtection.aes128Info) {
  2311.         const getBaseUris = context.representation.getBaseUris;
  2312.         const urlParams = context.urlParams;
  2313.         const uris = shaka.util.ManifestParserUtils.resolveUris(
  2314.             getBaseUris(), [contentProtection.aes128Info.keyUri], urlParams());
  2315.         const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  2316.         const request = shaka.net.NetworkingEngine.makeRequest(
  2317.             uris, this.config_.retryParameters);
  2319.         aesKey = {
  2320.           bitsKey: 128,
  2321.           blockCipherMode: 'CBC',
  2322.           iv: contentProtection.aes128Info.iv,
  2323.           firstMediaSequenceNumber: 0,
  2324.         };
  2326.         // Don't download the key object until the segment is parsed, to
  2327.         // avoid a startup delay for long manifests with lots of keys.
  2328.         aesKey.fetchKey = async () => {
  2329.           const keyResponse =
  2330.               await this.makeNetworkRequest_(request, requestType);
  2332.           // keyResponse.status is undefined when URI is
  2333.           // "data:text/plain;base64,"
  2334.           if (!keyResponse.data || keyResponse.data.byteLength != 16) {
  2335.             throw new shaka.util.Error(
  2336.                 shaka.util.Error.Severity.CRITICAL,
  2337.                 shaka.util.Error.Category.MANIFEST,
  2338.                 shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
  2339.           }
  2341.           const algorithm = {
  2342.             name: 'AES-CBC',
  2343.           };
  2344.           aesKey.cryptoKey = await window.crypto.subtle.importKey(
  2345.               'raw', keyResponse.data, algorithm, true, ['decrypt']);
  2346.           aesKey.fetchKey = undefined; // No longer needed.
  2347.         };
  2348.       }
  2349.       context.representation.aesKey = aesKey;
  2351.       const requestSegment = (uris, startByte, endByte, isInit) => {
  2352.         return this.requestSegment_(uris, startByte, endByte, isInit);
  2353.       };
  2354.       if (context.representation.segmentBase) {
  2355.         streamInfo = shaka.dash.SegmentBase.createStreamInfo(
  2356.             context, requestSegment, aesKey);
  2357.       } else if (context.representation.segmentList) {
  2358.         streamInfo = shaka.dash.SegmentList.createStreamInfo(
  2359.             context, this.streamMap_, aesKey);
  2360.       } else if (context.representation.segmentTemplate) {
  2361.         const hasManifest = !!this.manifest_;
  2363.         streamInfo = shaka.dash.SegmentTemplate.createStreamInfo(
  2364.             context, requestSegment, this.streamMap_, hasManifest,
  2365.             this.config_.dash.initialSegmentLimit, this.periodDurations_,
  2366.             aesKey, lastSegmentNumber, /* isPatchUpdate= */ false,
  2367.             this.continuityCache_);
  2368.       } else {
  2369.         goog.asserts.assert(isText,
  2370.             'Must have Segment* with non-text streams.');
  2372.         const duration = context.periodInfo.duration || 0;
  2373.         const getBaseUris = context.representation.getBaseUris;
  2374.         const mimeType = context.representation.mimeType;
  2375.         const codecs = context.representation.codecs;
  2376.         streamInfo = {
  2377.           endTime: -1,
  2378.           timeline: -1,
  2379.           generateSegmentIndex: () => {
  2380.             const segmentIndex = shaka.media.SegmentIndex.forSingleSegment(
  2381.                 periodStart, duration, getBaseUris());
  2382.             segmentIndex.forEachTopLevelReference((ref) => {
  2383.               ref.mimeType = mimeType;
  2384.               ref.codecs = codecs;
  2385.             });
  2386.             return Promise.resolve(segmentIndex);
  2387.           },
  2388.           timescale: 1,
  2389.         };
  2390.       }
  2391.     } catch (error) {
  2392.       if ((isText || isImage) &&
  2393.           error.code == shaka.util.Error.Code.DASH_NO_SEGMENT_INFO) {
  2394.         // We will ignore any DASH_NO_SEGMENT_INFO errors for text/image
  2395.         // streams.
  2396.         return null;
  2397.       }
  2399.       // For anything else, re-throw.
  2400.       throw error;
  2401.     }
  2403.     const keyId = shaka.dash.ContentProtection.parseFromRepresentation(
  2404.         contentProtectionElements, contentProtection,
  2405.         this.config_.ignoreDrmInfo,
  2406.         this.config_.dash.keySystemsByURI);
  2407.     const keyIds = new Set(keyId ? [keyId] : []);
  2409.     // Detect the presence of E-AC3 JOC audio content, using DD+JOC signaling.
  2410.     // See: ETSI TS 103 420 V1.2.1 (2018-10)
  2411.     const hasJoc = supplementalPropertyElements.some((element) => {
  2412.       const expectedUri = 'tag:dolby.com,2018:dash:EC3_ExtensionType:2018';
  2413.       const expectedValue = 'JOC';
  2414.       return element.attributes['schemeIdUri'] == expectedUri &&
  2415.           element.attributes['value'] == expectedValue;
  2416.     });
  2417.     let spatialAudio = false;
  2418.     if (hasJoc) {
  2419.       spatialAudio = true;
  2420.     }
  2422.     let forced = false;
  2423.     if (isText) {
  2424.       // See: https://github.com/shaka-project/shaka-player/issues/2122 and
  2425.       // https://github.com/Dash-Industry-Forum/DASH-IF-IOP/issues/165
  2426.       forced = roles.includes('forced_subtitle') ||
  2427.           roles.includes('forced-subtitle');
  2428.     }
  2430.     let tilesLayout;
  2431.     if (isImage) {
  2432.       const thumbnailTileElem = essentialPropertyElements.find((element) => {
  2433.         const expectedUris = [
  2434.           'http://dashif.org/thumbnail_tile',
  2435.           'http://dashif.org/guidelines/thumbnail_tile',
  2436.         ];
  2437.         return expectedUris.includes(element.attributes['schemeIdUri']);
  2438.       });
  2439.       if (thumbnailTileElem) {
  2440.         tilesLayout = thumbnailTileElem.attributes['value'];
  2441.       }
  2442.       // Filter image adaptation sets that has no tilesLayout.
  2443.       if (!tilesLayout) {
  2444.         return null;
  2445.       }
  2446.     }
  2448.     let hdr;
  2449.     const profiles = context.profiles;
  2450.     const codecs = context.representation.codecs;
  2452.     const hevcHDR = 'http://dashif.org/guidelines/dash-if-uhd#hevc-hdr-pq10';
  2453.     if (profiles.includes(hevcHDR) && (codecs.includes('hvc1.2.4.L153.B0') ||
  2454.         codecs.includes('hev1.2.4.L153.B0'))) {
  2455.       hdr = 'PQ';
  2456.     }
  2458.     const contextId = context.representation.id ?
  2459.         context.period.id + ',' + context.representation.id : '';
  2461.     if (this.patchLocationNodes_.length && representationId) {
  2462.       this.contextCache_.set(`${context.period.id},${representationId}`,
  2463.           this.cloneContext_(context));
  2464.     }
  2466.     if (context.representation.producerReferenceTime) {
  2467.       this.parseProducerReferenceTime_(
  2468.           context.representation.producerReferenceTime,
  2469.           streamInfo,
  2470.           context.presentationTimeline);
  2471.     }
  2473.     if (streamInfo.endTime != -1 &&
  2474.       context.period.id != null &&
  2475.       context.representation.id != null) {
  2476.       const cache = this.continuityCache_.get(context.period.id);
  2477.       if (cache) {
  2478.         cache.endTime = streamInfo.endTime;
  2479.         if (!cache.reps.includes(context.representation.id)) {
  2480.           cache.reps.push(context.representation.id);
  2481.         }
  2482.         this.continuityCache_.set(context.period.id, cache);
  2483.       } else {
  2484.         const cache = {
  2485.           endTime: streamInfo.endTime,
  2486.           timeline: streamInfo.timeline,
  2487.           reps: [context.representation.id],
  2488.         };
  2489.         this.continuityCache_.set(context.period.id, cache);
  2490.       }
  2491.     }
  2493.     /** @type {shaka.extern.Stream} */
  2494.     let stream;
  2496.     if (contextId && this.streamMap_.has(contextId)) {
  2497.       stream = this.streamMap_.get(contextId);
  2498.     } else {
  2499.       stream = {
  2500.         id: this.globalId_++,
  2501.         originalId: context.representation.id,
  2502.         groupId: null,
  2503.         createSegmentIndex: () => Promise.resolve(),
  2504.         closeSegmentIndex: () => {
  2505.           if (stream.segmentIndex) {
  2506.             stream.segmentIndex.release();
  2507.             stream.segmentIndex = null;
  2508.           }
  2509.         },
  2510.         segmentIndex: null,
  2511.         mimeType: context.representation.mimeType,
  2512.         codecs,
  2513.         frameRate: context.representation.frameRate,
  2514.         pixelAspectRatio: context.representation.pixelAspectRatio,
  2515.         bandwidth: context.bandwidth,
  2516.         width: context.representation.width,
  2517.         height: context.representation.height,
  2518.         kind,
  2519.         encrypted: contentProtection.drmInfos.length > 0,
  2520.         drmInfos: contentProtection.drmInfos,
  2521.         keyIds,
  2522.         language,
  2523.         originalLanguage: context.adaptationSet.language,
  2524.         label,
  2525.         type: context.adaptationSet.contentType,
  2526.         primary: isPrimary,
  2527.         trickModeVideo: null,
  2528.         dependencyStream: null,
  2529.         emsgSchemeIdUris:
  2530.             context.representation.emsgSchemeIdUris,
  2531.         roles,
  2532.         forced,
  2533.         channelsCount: context.representation.numChannels,
  2534.         audioSamplingRate: context.representation.audioSamplingRate,
  2535.         spatialAudio,
  2536.         closedCaptions,
  2537.         hdr,
  2538.         colorGamut: undefined,
  2539.         videoLayout: undefined,
  2540.         tilesLayout,
  2541.         accessibilityPurpose,
  2542.         external: false,
  2543.         fastSwitching: false,
  2544.         fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
  2545.             context.representation.mimeType, context.representation.codecs)]),
  2546.         isAudioMuxedInVideo: false,
  2547.         baseOriginalId: null,
  2548.       };
  2549.     }
  2551.     stream.createSegmentIndex = async () => {
  2552.       if (!stream.segmentIndex) {
  2553.         stream.segmentIndex = await streamInfo.generateSegmentIndex();
  2554.       }
  2555.     };
  2557.     if (contextId && context.dynamic && !this.streamMap_.has(contextId)) {
  2558.       const periodId = context.period.id || '';
  2559.       if (!this.indexStreamMap_.has(periodId)) {
  2560.         this.indexStreamMap_.set(periodId, []);
  2561.       }
  2562.       this.streamMap_.set(contextId, stream);
  2563.       this.indexStreamMap_.get(periodId).push(contextId);
  2564.     }
  2566.     return stream;
  2567.   }
  2569.   /**
  2570.    * @param {!shaka.extern.xml.Node} prftNode
  2571.    * @param {!shaka.dash.DashParser.StreamInfo} streamInfo
  2572.    * @param {!shaka.media.PresentationTimeline} presentationTimeline
  2573.    * @private
  2574.    */
  2575.   parseProducerReferenceTime_(prftNode, streamInfo, presentationTimeline) {
  2576.     const TXml = shaka.util.TXml;
  2578.     if (this.parsedPrftNodes_.has(prftNode)) {
  2579.       return;
  2580.     }
  2582.     this.parsedPrftNodes_.add(prftNode);
  2583.     const presentationTime = TXml.parseAttr(
  2584.         prftNode, 'presentationTime', TXml.parseNonNegativeInt) || 0;
  2585.     const utcTiming = TXml.findChild(prftNode, 'UTCTiming');
  2586.     let wallClockTime;
  2587.     const parseAsNtp = !utcTiming || !utcTiming.attributes['schemeIdUri'] ||
  2588.         shaka.dash.DashParser.isNtpScheme_(utcTiming.attributes['schemeIdUri']);
  2589.     if (parseAsNtp) {
  2590.       const ntpTimestamp = TXml.parseAttr(
  2591.           prftNode, 'wallClockTime', TXml.parseNonNegativeInt) || 0;
  2592.       wallClockTime = shaka.util.TimeUtils.convertNtp(ntpTimestamp);
  2593.     } else {
  2594.       wallClockTime = (TXml.parseAttr(
  2595.           prftNode, 'wallClockTime', TXml.parseDate) || 0) * 1000;
  2596.     }
  2597.     const programStartDate = new Date(wallClockTime -
  2598.       (presentationTime / streamInfo.timescale) * 1000);
  2599.     const programStartTime = programStartDate.getTime() / 1000;
  2600.     if (!isNaN(programStartTime)) {
  2601.       if (!presentationTimeline.isStartTimeLocked()) {
  2602.         presentationTimeline.setInitialProgramDateTime(programStartTime);
  2603.       }
  2604.       /** @type {shaka.extern.ProducerReferenceTime} */
  2605.       const prftInfo = {
  2606.         wallClockTime,
  2607.         programStartDate,
  2608.       };
  2609.       const eventName = shaka.util.FakeEvent.EventName.Prft;
  2610.       const data = (new Map()).set('detail', prftInfo);
  2611.       const event = new shaka.util.FakeEvent(eventName, data);
  2612.       this.playerInterface_.onEvent(event);
  2613.     }
  2614.   }
  2616.   /**
  2617.    * Clone context and remove xml document references.
  2618.    *
  2619.    * @param {!shaka.dash.DashParser.Context} context
  2620.    * @return {!shaka.dash.DashParser.Context}
  2621.    * @private
  2622.    */
  2623.   cloneContext_(context) {
  2624.     /**
  2625.      * @param {?shaka.dash.DashParser.InheritanceFrame} frame
  2626.      * @return {?shaka.dash.DashParser.InheritanceFrame}
  2627.      */
  2628.     const cloneFrame = (frame) => {
  2629.       if (!frame) {
  2630.         return null;
  2631.       }
  2632.       const clone = shaka.util.ObjectUtils.shallowCloneObject(frame);
  2633.       clone.segmentBase = null;
  2634.       clone.segmentList = null;
  2635.       clone.segmentTemplate = shaka.util.TXml.cloneNode(clone.segmentTemplate);
  2636.       clone.producerReferenceTime = null;
  2637.       return clone;
  2638.     };
  2639.     const contextClone = shaka.util.ObjectUtils.shallowCloneObject(context);
  2640.     contextClone.period = cloneFrame(contextClone.period);
  2641.     contextClone.adaptationSet = cloneFrame(contextClone.adaptationSet);
  2642.     contextClone.representation = cloneFrame(contextClone.representation);
  2644.     if (contextClone.periodInfo) {
  2645.       contextClone.periodInfo =
  2646.         shaka.util.ObjectUtils.shallowCloneObject(contextClone.periodInfo);
  2647.       contextClone.periodInfo.node = null;
  2648.     }
  2650.     return contextClone;
  2651.   }
  2653.   /**
  2654.    * Called when the update timer ticks.
  2655.    *
  2656.    * @return {!Promise}
  2657.    * @private
  2658.    */
  2659.   async onUpdate_() {
  2660.     goog.asserts.assert(this.updatePeriod_ >= 0,
  2661.         'There should be an update period');
  2663.     shaka.log.info('Updating manifest...');
  2665.     // Default the update delay to 0 seconds so that if there is an error we can
  2666.     // try again right away.
  2667.     let updateDelay = 0;
  2669.     try {
  2670.       updateDelay = await this.requestManifest_();
  2671.     } catch (error) {
  2672.       goog.asserts.assert(error instanceof shaka.util.Error,
  2673.           'Should only receive a Shaka error');
  2675.       // Try updating again, but ensure we haven't been destroyed.
  2676.       if (this.playerInterface_) {
  2677.         if (this.config_.raiseFatalErrorOnManifestUpdateRequestFailure) {
  2678.           this.playerInterface_.onError(error);
  2679.           return;
  2680.         }
  2681.         // We will retry updating, so override the severity of the error.
  2682.         error.severity = shaka.util.Error.Severity.RECOVERABLE;
  2683.         this.playerInterface_.onError(error);
  2684.       }
  2685.     }
  2687.     // Detect a call to stop()
  2688.     if (!this.playerInterface_) {
  2689.       return;
  2690.     }
  2692.     this.playerInterface_.onManifestUpdated();
  2694.     this.setUpdateTimer_(updateDelay);
  2695.   }
  2697.   /**
  2698.    * Update now the manifest
  2699.    *
  2700.    * @private
  2701.    */
  2702.   updateNow_() {
  2703.     this.updateTimer_.tickNow();
  2704.   }
  2706.   /**
  2707.    * Sets the update timer.  Does nothing if the manifest does not specify an
  2708.    * update period.
  2709.    *
  2710.    * @param {number} offset An offset, in seconds, to apply to the manifest's
  2711.    *   update period.
  2712.    * @private
  2713.    */
  2714.   setUpdateTimer_(offset) {
  2715.     // NOTE: An updatePeriod_ of -1 means the attribute was missing.
  2716.     // An attribute which is present and set to 0 should still result in
  2717.     // periodic updates.  For more, see:
  2718.     // https://github.com/Dash-Industry-Forum/Guidelines-TimingModel/issues/48
  2719.     if (this.updatePeriod_ < 0) {
  2720.       return;
  2721.     }
  2722.     let updateTime = this.updatePeriod_;
  2723.     if (this.config_.updatePeriod >= 0) {
  2724.       updateTime = this.config_.updatePeriod;
  2725.     }
  2727.     const finalDelay = Math.max(
  2728.         updateTime - offset,
  2729.         this.averageUpdateDuration_.getEstimate());
  2731.     // We do not run the timer as repeating because part of update is async and
  2732.     // we need schedule the update after it finished.
  2733.     this.updateTimer_.tickAfter(/* seconds= */ finalDelay);
  2734.   }
  2736.   /**
  2737.    * Creates a new inheritance frame for the given element.
  2738.    *
  2739.    * @param {!shaka.extern.xml.Node} elem
  2740.    * @param {?shaka.dash.DashParser.InheritanceFrame} parent
  2741.    * @param {?function(): !Array<string>} getBaseUris
  2742.    * @return {shaka.dash.DashParser.InheritanceFrame}
  2743.    * @private
  2744.    */
  2745.   createFrame_(elem, parent, getBaseUris) {
  2746.     goog.asserts.assert(parent || getBaseUris,
  2747.         'Must provide either parent or getBaseUris');
  2748.     const SegmentUtils = shaka.media.SegmentUtils;
  2749.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  2750.     const TXml = shaka.util.TXml;
  2751.     parent = parent || /** @type {shaka.dash.DashParser.InheritanceFrame} */ ({
  2752.       contentType: '',
  2753.       mimeType: '',
  2754.       codecs: '',
  2755.       emsgSchemeIdUris: [],
  2756.       frameRate: undefined,
  2757.       pixelAspectRatio: undefined,
  2758.       numChannels: null,
  2759.       audioSamplingRate: null,
  2760.       availabilityTimeOffset: 0,
  2761.       segmentSequenceCadence: 0,
  2762.       encrypted: false,
  2763.     });
  2764.     getBaseUris = getBaseUris || parent.getBaseUris;
  2766.     const parseNumber = TXml.parseNonNegativeInt;
  2767.     const evalDivision = TXml.evalDivision;
  2769.     const id = elem.attributes['id'];
  2770.     const supplementalId = elem.attributes['supplementalId'];
  2771.     const uriObjs = TXml.findChildren(elem, 'BaseURL');
  2772.     let calculatedBaseUris;
  2773.     let someLocationValid = false;
  2774.     if (this.contentSteeringManager_) {
  2775.       for (const uriObj of uriObjs) {
  2776.         const serviceLocation = uriObj.attributes['serviceLocation'];
  2777.         const uri = TXml.getContents(uriObj);
  2778.         if (serviceLocation && uri) {
  2779.           this.contentSteeringManager_.addLocation(
  2780.               id, serviceLocation, uri);
  2781.           someLocationValid = true;
  2782.         }
  2783.       }
  2784.     }
  2785.     if (!someLocationValid || !this.contentSteeringManager_) {
  2786.       calculatedBaseUris = uriObjs.map(TXml.getContents);
  2787.     }
  2789.     const getFrameUris = () => {
  2790.       if (!uriObjs.length) {
  2791.         return [];
  2792.       }
  2793.       if (this.contentSteeringManager_ && someLocationValid) {
  2794.         return this.contentSteeringManager_.getLocations(id);
  2795.       }
  2796.       if (calculatedBaseUris) {
  2797.         return calculatedBaseUris;
  2798.       }
  2799.       return [];
  2800.     };
  2802.     let contentType = elem.attributes['contentType'] || parent.contentType;
  2803.     const mimeType = elem.attributes['mimeType'] || parent.mimeType;
  2804.     const allCodecs = [
  2805.       elem.attributes['codecs'] || parent.codecs,
  2806.     ];
  2807.     const codecs = SegmentUtils.codecsFiltering(allCodecs).join(',');
  2808.     const frameRate =
  2809.         TXml.parseAttr(elem, 'frameRate', evalDivision) || parent.frameRate;
  2810.     const pixelAspectRatio =
  2811.         elem.attributes['sar'] || parent.pixelAspectRatio;
  2812.     const emsgSchemeIdUris = this.emsgSchemeIdUris_(
  2813.         TXml.findChildren(elem, 'InbandEventStream'),
  2814.         parent.emsgSchemeIdUris);
  2815.     const audioChannelConfigs =
  2816.         TXml.findChildren(elem, 'AudioChannelConfiguration');
  2817.     const numChannels =
  2818.         this.parseAudioChannels_(audioChannelConfigs) || parent.numChannels;
  2819.     const audioSamplingRate =
  2820.         TXml.parseAttr(elem, 'audioSamplingRate', parseNumber) ||
  2821.         parent.audioSamplingRate;
  2823.     if (!contentType) {
  2824.       contentType = shaka.dash.DashParser.guessContentType_(mimeType, codecs);
  2825.     }
  2827.     const segmentBase = TXml.findChild(elem, 'SegmentBase');
  2828.     const segmentTemplate = TXml.findChild(elem, 'SegmentTemplate');
  2830.     // The availabilityTimeOffset is the sum of all @availabilityTimeOffset
  2831.     // values that apply to the adaptation set, via BaseURL, SegmentBase,
  2832.     // or SegmentTemplate elements.
  2833.     const segmentBaseAto = segmentBase ?
  2834.         (TXml.parseAttr(segmentBase, 'availabilityTimeOffset',
  2835.             TXml.parseFloat) || 0) : 0;
  2836.     const segmentTemplateAto = segmentTemplate ?
  2837.         (TXml.parseAttr(segmentTemplate, 'availabilityTimeOffset',
  2838.             TXml.parseFloat) || 0) : 0;
  2839.     const baseUriAto = uriObjs && uriObjs.length ?
  2840.         (TXml.parseAttr(uriObjs[0], 'availabilityTimeOffset',
  2841.             TXml.parseFloat) || 0) : 0;
  2843.     const availabilityTimeOffset = parent.availabilityTimeOffset + baseUriAto +
  2844.         segmentBaseAto + segmentTemplateAto;
  2846.     let segmentSequenceCadence = null;
  2847.     const segmentSequenceProperties =
  2848.         TXml.findChild(elem, 'SegmentSequenceProperties');
  2849.     if (segmentSequenceProperties) {
  2850.       const sap = TXml.findChild(segmentSequenceProperties, 'SAP');
  2851.       if (sap) {
  2852.         segmentSequenceCadence = TXml.parseAttr(sap, 'cadence',
  2853.             TXml.parseInt);
  2854.       }
  2855.     }
  2857.     // This attribute is currently non-standard, but it is supported by Kaltura.
  2858.     let label = elem.attributes['label'];
  2860.     // See DASH IOP 4.3 here https://dashif.org/docs/DASH-IF-IOP-v4.3.pdf (page 35)
  2861.     const labelElements = TXml.findChildren(elem, 'Label');
  2862.     if (labelElements && labelElements.length) {
  2863.       // NOTE: Right now only one label field is supported.
  2864.       const firstLabelElement = labelElements[0];
  2865.       if (TXml.getTextContents(firstLabelElement)) {
  2866.         label = TXml.getTextContents(firstLabelElement);
  2867.       }
  2868.     }
  2870.     return {
  2871.       getBaseUris:
  2872.           () => ManifestParserUtils.resolveUris(getBaseUris(), getFrameUris()),
  2873.       segmentBase: segmentBase || parent.segmentBase,
  2874.       segmentList:
  2875.           TXml.findChild(elem, 'SegmentList') || parent.segmentList,
  2876.       segmentTemplate: segmentTemplate || parent.segmentTemplate,
  2877.       producerReferenceTime: TXml.findChild(elem, 'ProducerReferenceTime') ||
  2878.         parent.producerReferenceTime,
  2879.       width: TXml.parseAttr(elem, 'width', parseNumber) || parent.width,
  2880.       height: TXml.parseAttr(elem, 'height', parseNumber) || parent.height,
  2881.       contentType: contentType,
  2882.       mimeType: mimeType,
  2883.       codecs: codecs,
  2884.       frameRate: frameRate,
  2885.       pixelAspectRatio: pixelAspectRatio,
  2886.       emsgSchemeIdUris: emsgSchemeIdUris,
  2887.       id: supplementalId || id,
  2888.       originalId: id,
  2889.       language: elem.attributes['lang'],
  2890.       numChannels: numChannels,
  2891.       audioSamplingRate: audioSamplingRate,
  2892.       availabilityTimeOffset: availabilityTimeOffset,
  2893.       initialization: null,
  2894.       segmentSequenceCadence:
  2895.           segmentSequenceCadence || parent.segmentSequenceCadence,
  2896.       label: label || null,
  2897.       encrypted: false,
  2898.     };
  2899.   }
  2901.   /**
  2902.    * Returns a new array of InbandEventStream schemeIdUri containing the union
  2903.    * of the ones parsed from inBandEventStreams and the ones provided in
  2904.    * emsgSchemeIdUris.
  2905.    *
  2906.    * @param {!Array<!shaka.extern.xml.Node>} inBandEventStreams
  2907.    *     Array of InbandEventStream
  2908.    *     elements to parse and add to the returned array.
  2909.    * @param {!Array<string>} emsgSchemeIdUris Array of parsed
  2910.    *     InbandEventStream schemeIdUri attributes to add to the returned array.
  2911.    * @return {!Array<string>} schemeIdUris Array of parsed
  2912.    *     InbandEventStream schemeIdUri attributes.
  2913.    * @private
  2914.    */
  2915.   emsgSchemeIdUris_(inBandEventStreams, emsgSchemeIdUris) {
  2916.     const schemeIdUris = emsgSchemeIdUris.slice();
  2917.     for (const event of inBandEventStreams) {
  2918.       const schemeIdUri = event.attributes['schemeIdUri'];
  2919.       if (!schemeIdUris.includes(schemeIdUri)) {
  2920.         schemeIdUris.push(schemeIdUri);
  2921.       }
  2922.     }
  2923.     return schemeIdUris;
  2924.   }
  2926.   /**
  2927.    * @param {!Array<!shaka.extern.xml.Node>} audioChannelConfigs An array of
  2928.    *   AudioChannelConfiguration elements.
  2929.    * @return {?number} The number of audio channels, or null if unknown.
  2930.    * @private
  2931.    */
  2932.   parseAudioChannels_(audioChannelConfigs) {
  2933.     for (const elem of audioChannelConfigs) {
  2934.       const scheme = elem.attributes['schemeIdUri'];
  2935.       if (!scheme) {
  2936.         continue;
  2937.       }
  2939.       const value = elem.attributes['value'];
  2940.       if (!value) {
  2941.         continue;
  2942.       }
  2944.       switch (scheme) {
  2945.         case 'urn:mpeg:dash:outputChannelPositionList:2012':
  2946.           // A space-separated list of speaker positions, so the number of
  2947.           // channels is the length of this list.
  2948.           return value.trim().split(/ +/).length;
  2950.         case 'urn:mpeg:dash:23003:3:audio_channel_configuration:2011':
  2951.         case 'urn:dts:dash:audio_channel_configuration:2012': {
  2952.           // As far as we can tell, this is a number of channels.
  2953.           const intValue = parseInt(value, 10);
  2954.           if (!intValue) {  // 0 or NaN
  2955.             shaka.log.warning('Channel parsing failure! ' +
  2956.                           'Ignoring scheme and value', scheme, value);
  2957.             continue;
  2958.           }
  2959.           return intValue;
  2960.         }
  2962.         case 'tag:dolby.com,2015:dash:audio_channel_configuration:2015': {
  2963.           // ETSI TS 103 190-2 v1.2.1, Annex G.3
  2964.           // LSB-to-MSB order
  2965.           const channelCountMapping =
  2966.             [2, 1, 2, 2, 2, 2, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1, 2, 2];
  2967.           const hexValue = parseInt(value, 16);
  2968.           if (!hexValue) {  // 0 or NaN
  2969.             shaka.log.warning('Channel parsing failure! ' +
  2970.                           'Ignoring scheme and value', scheme, value);
  2971.             continue;
  2972.           }
  2973.           let numBits = 0;
  2974.           for (let i = 0; i < channelCountMapping.length; i++) {
  2975.             if (hexValue & (1<<i)) {
  2976.               numBits += channelCountMapping[i];
  2977.             }
  2978.           }
  2979.           if (numBits) {
  2980.             return numBits;
  2981.           }
  2982.           continue;
  2983.         }
  2985.         case 'tag:dolby.com,2014:dash:audio_channel_configuration:2011':
  2986.         case 'urn:dolby:dash:audio_channel_configuration:2011': {
  2987.           // Defined by https://ott.dolby.com/OnDelKits/DDP/Dolby_Digital_Plus_Online_Delivery_Kit_v1.5/Documentation/Content_Creation/SDM/help_files/topics/ddp_mpeg_dash_c_mpd_auchlconfig.html
  2988.           // keep list in order of the spec; reverse for LSB-to-MSB order
  2989.           const channelCountMapping =
  2990.             [1, 1, 1, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1, 2, 1, 1].reverse();
  2991.           const hexValue = parseInt(value, 16);
  2992.           if (!hexValue) {  // 0 or NaN
  2993.             shaka.log.warning('Channel parsing failure! ' +
  2994.                           'Ignoring scheme and value', scheme, value);
  2995.             continue;
  2996.           }
  2997.           let numBits = 0;
  2998.           for (let i = 0; i < channelCountMapping.length; i++) {
  2999.             if (hexValue & (1<<i)) {
  3000.               numBits += channelCountMapping[i];
  3001.             }
  3002.           }
  3003.           if (numBits) {
  3004.             return numBits;
  3005.           }
  3006.           continue;
  3007.         }
  3009.         // Defined by https://dashif.org/identifiers/audio_source_metadata/ and clause 8.2, in ISO/IEC 23001-8.
  3010.         case 'urn:mpeg:mpegB:cicp:ChannelConfiguration': {
  3011.           const noValue = 0;
  3012.           const channelCountMapping = [
  3013.             noValue, 1, 2, 3, 4, 5, 6, 8, 2, 3, /* 0--9 */
  3014.             4, 7, 8, 24, 8, 12, 10, 12, 14, 12, /* 10--19 */
  3015.             14, /* 20 */
  3016.           ];
  3017.           const intValue = parseInt(value, 10);
  3018.           if (!intValue) {  // 0 or NaN
  3019.             shaka.log.warning('Channel parsing failure! ' +
  3020.                           'Ignoring scheme and value', scheme, value);
  3021.             continue;
  3022.           }
  3023.           if (intValue > noValue && intValue < channelCountMapping.length) {
  3024.             return channelCountMapping[intValue];
  3025.           }
  3026.           continue;
  3027.         }
  3029.         default:
  3030.           shaka.log.warning(
  3031.               'Unrecognized audio channel scheme:', scheme, value);
  3032.           continue;
  3033.       }
  3034.     }
  3036.     return null;
  3037.   }
  3039.   /**
  3040.    * Verifies that a Representation has exactly one Segment* element.  Prints
  3041.    * warnings if there is a problem.
  3042.    *
  3043.    * @param {shaka.dash.DashParser.InheritanceFrame} frame
  3044.    * @return {boolean} True if the Representation is usable; otherwise return
  3045.    *   false.
  3046.    * @private
  3047.    */
  3048.   verifyRepresentation_(frame) {
  3049.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  3051.     let n = 0;
  3052.     n += frame.segmentBase ? 1 : 0;
  3053.     n += frame.segmentList ? 1 : 0;
  3054.     n += frame.segmentTemplate ? 1 : 0;
  3056.     if (n == 0) {
  3057.       // TODO: Extend with the list of MIME types registered to TextEngine.
  3058.       if (frame.contentType == ContentType.TEXT ||
  3059.           frame.contentType == ContentType.APPLICATION) {
  3060.         return true;
  3061.       } else {
  3062.         shaka.log.warning(
  3063.             'Representation does not contain a segment information source:',
  3064.             'the Representation must contain one of SegmentBase, SegmentList,',
  3065.             'SegmentTemplate, or explicitly indicate that it is "text".',
  3066.             frame);
  3067.         return false;
  3068.       }
  3069.     }
  3071.     if (n != 1) {
  3072.       shaka.log.warning(
  3073.           'Representation contains multiple segment information sources:',
  3074.           'the Representation should only contain one of SegmentBase,',
  3075.           'SegmentList, or SegmentTemplate.',
  3076.           frame);
  3077.       if (frame.segmentBase) {
  3078.         shaka.log.info('Using SegmentBase by default.');
  3079.         frame.segmentList = null;
  3080.         frame.segmentTemplate = null;
  3081.       } else {
  3082.         goog.asserts.assert(frame.segmentList, 'There should be a SegmentList');
  3083.         shaka.log.info('Using SegmentList by default.');
  3084.         frame.segmentTemplate = null;
  3085.       }
  3086.     }
  3088.     return true;
  3089.   }
  3091.   /**
  3092.    * Makes a request to the given URI and calculates the clock offset.
  3093.    *
  3094.    * @param {function(): !Array<string>} getBaseUris
  3095.    * @param {string} uri
  3096.    * @param {string} method
  3097.    * @return {!Promise<number>}
  3098.    * @private
  3099.    */
  3100.   async requestForTiming_(getBaseUris, uri, method) {
  3101.     const uris = [shaka.util.StringUtils.htmlUnescape(uri)];
  3102.     const requestUris =
  3103.         shaka.util.ManifestParserUtils.resolveUris(getBaseUris(), uris);
  3104.     const request = shaka.net.NetworkingEngine.makeRequest(
  3105.         requestUris, this.config_.retryParameters);
  3106.     request.method = method;
  3107.     const type = shaka.net.NetworkingEngine.RequestType.TIMING;
  3109.     const operation =
  3110.     this.playerInterface_.networkingEngine.request(
  3111.         type, request, {isPreload: this.isPreloadFn_()});
  3112.     this.operationManager_.manage(operation);
  3114.     const response = await operation.promise;
  3115.     let text;
  3116.     if (method == 'HEAD') {
  3117.       if (!response.headers || !response.headers['date']) {
  3118.         shaka.log.warning('UTC timing response is missing',
  3119.             'expected date header');
  3120.         return 0;
  3121.       }
  3122.       text = response.headers['date'];
  3123.     } else {
  3124.       text = shaka.util.StringUtils.fromUTF8(response.data);
  3125.     }
  3126.     const date = Date.parse(text);
  3127.     if (isNaN(date)) {
  3128.       shaka.log.warning('Unable to parse date from UTC timing response');
  3129.       return 0;
  3130.     }
  3131.     return (date - Date.now());
  3132.   }
  3134.   /**
  3135.    * Parses an array of UTCTiming elements.
  3136.    *
  3137.    * @param {function(): !Array<string>} getBaseUris
  3138.    * @param {!Array<!shaka.extern.xml.Node>} elements
  3139.    * @return {!Promise<number>}
  3140.    * @private
  3141.    */
  3142.   async parseUtcTiming_(getBaseUris, elements) {
  3143.     const schemesAndValues = elements.map((elem) => {
  3144.       return {
  3145.         scheme: elem.attributes['schemeIdUri'],
  3146.         value: elem.attributes['value'],
  3147.       };
  3148.     });
  3150.     // If there's nothing specified in the manifest, but we have a default from
  3151.     // the config, use that.
  3152.     const clockSyncUri = this.config_.dash.clockSyncUri;
  3153.     if (!schemesAndValues.length && clockSyncUri) {
  3154.       schemesAndValues.push({
  3155.         scheme: 'urn:mpeg:dash:utc:http-head:2014',
  3156.         value: clockSyncUri,
  3157.       });
  3158.     }
  3160.     for (const sv of schemesAndValues) {
  3161.       try {
  3162.         const scheme = sv.scheme;
  3163.         const value = sv.value;
  3164.         switch (scheme) {
  3165.           // See DASH IOP Guidelines Section 4.7
  3166.           // https://bit.ly/DashIop3-2
  3167.           // Some old ISO23009-1 drafts used 2012.
  3168.           case 'urn:mpeg:dash:utc:http-head:2014':
  3169.           case 'urn:mpeg:dash:utc:http-head:2012':
  3170.             // eslint-disable-next-line no-await-in-loop
  3171.             return await this.requestForTiming_(getBaseUris, value, 'HEAD');
  3172.           case 'urn:mpeg:dash:utc:http-xsdate:2014':
  3173.           case 'urn:mpeg:dash:utc:http-iso:2014':
  3174.           case 'urn:mpeg:dash:utc:http-xsdate:2012':
  3175.           case 'urn:mpeg:dash:utc:http-iso:2012':
  3176.             // eslint-disable-next-line no-await-in-loop
  3177.             return await this.requestForTiming_(getBaseUris, value, 'GET');
  3178.           case 'urn:mpeg:dash:utc:direct:2014':
  3179.           case 'urn:mpeg:dash:utc:direct:2012': {
  3180.             const date = Date.parse(value);
  3181.             return isNaN(date) ? 0 : (date - Date.now());
  3182.           }
  3184.           case 'urn:mpeg:dash:utc:http-ntp:2014':
  3185.           case 'urn:mpeg:dash:utc:ntp:2014':
  3186.           case 'urn:mpeg:dash:utc:sntp:2014':
  3187.             shaka.log.alwaysWarn('NTP UTCTiming scheme is not supported');
  3188.             break;
  3189.           default:
  3190.             shaka.log.alwaysWarn(
  3191.                 'Unrecognized scheme in UTCTiming element', scheme);
  3192.             break;
  3193.         }
  3194.       } catch (e) {
  3195.         shaka.log.warning('Error fetching time from UTCTiming elem', e.message);
  3196.       }
  3197.     }
  3199.     shaka.log.alwaysWarn(
  3200.         'A UTCTiming element should always be given in live manifests! ' +
  3201.         'This content may not play on clients with bad clocks!');
  3202.     return 0;
  3203.   }
  3205.   /**
  3206.    * Parses an EventStream element.
  3207.    *
  3208.    * @param {number} periodStart
  3209.    * @param {?number} periodDuration
  3210.    * @param {!shaka.extern.xml.Node} elem
  3211.    * @param {number} availabilityStart
  3212.    * @private
  3213.    */
  3214.   parseEventStream_(periodStart, periodDuration, elem, availabilityStart) {
  3215.     const TXml = shaka.util.TXml;
  3216.     const parseNumber = shaka.util.TXml.parseNonNegativeInt;
  3218.     const schemeIdUri = elem.attributes['schemeIdUri'] || '';
  3219.     const value = elem.attributes['value'] || '';
  3220.     const timescale = TXml.parseAttr(elem, 'timescale', parseNumber) || 1;
  3221.     const presentationTimeOffset =
  3222.       TXml.parseAttr(elem, 'presentationTimeOffset', parseNumber) || 0;
  3224.     for (const eventNode of TXml.findChildren(elem, 'Event')) {
  3225.       const presentationTime =
  3226.           TXml.parseAttr(eventNode, 'presentationTime', parseNumber) || 0;
  3227.       const duration =
  3228.           TXml.parseAttr(eventNode, 'duration', parseNumber) || 0;
  3230.       // Ensure start time won't be lower than period start.
  3231.       let startTime = Math.max(
  3232.           (presentationTime - presentationTimeOffset) / timescale + periodStart,
  3233.           periodStart);
  3234.       let endTime = startTime + (duration / timescale);
  3235.       if (periodDuration != null) {
  3236.         // An event should not go past the Period, even if the manifest says so.
  3237.         // See: Dash sec. 5.10.2.1
  3238.         startTime = Math.min(startTime, periodStart + periodDuration);
  3239.         endTime = Math.min(endTime, periodStart + periodDuration);
  3240.       }
  3242.       // Don't add unavailable regions to the timeline.
  3243.       if (endTime < availabilityStart) {
  3244.         continue;
  3245.       }
  3247.       /** @type {shaka.extern.TimelineRegionInfo} */
  3248.       const region = {
  3249.         schemeIdUri: schemeIdUri,
  3250.         value: value,
  3251.         startTime: startTime,
  3252.         endTime: endTime,
  3253.         id: eventNode.attributes['id'] || '',
  3254.         timescale: timescale,
  3255.         eventElement: TXml.txmlNodeToDomElement(eventNode),
  3256.         eventNode: TXml.cloneNode(eventNode),
  3257.       };
  3259.       this.playerInterface_.onTimelineRegionAdded(region);
  3260.     }
  3261.   }
  3263.   /**
  3264.    * Makes a network request on behalf of SegmentBase.createStreamInfo.
  3265.    *
  3266.    * @param {!Array<string>} uris
  3267.    * @param {?number} startByte
  3268.    * @param {?number} endByte
  3269.    * @param {boolean} isInit
  3270.    * @return {!Promise<BufferSource>}
  3271.    * @private
  3272.    */
  3273.   async requestSegment_(uris, startByte, endByte, isInit) {
  3274.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  3275.     const type = isInit ?
  3276.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT :
  3277.         shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
  3279.     const request = shaka.util.Networking.createSegmentRequest(
  3280.         uris,
  3281.         startByte,
  3282.         endByte,
  3283.         this.config_.retryParameters);
  3285.     const response = await this.makeNetworkRequest_(
  3286.         request, requestType, {type});
  3287.     return response.data;
  3288.   }
  3290.   /**
  3291.    * Guess the content type based on MIME type and codecs.
  3292.    *
  3293.    * @param {string} mimeType
  3294.    * @param {string} codecs
  3295.    * @return {string}
  3296.    * @private
  3297.    */
  3298.   static guessContentType_(mimeType, codecs) {
  3299.     const fullMimeType = shaka.util.MimeUtils.getFullType(mimeType, codecs);
  3301.     if (shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
  3302.       // If it's supported by TextEngine, it's definitely text.
  3303.       // We don't check MediaSourceEngine, because that would report support
  3304.       // for platform-supported video and audio types as well.
  3305.       return shaka.util.ManifestParserUtils.ContentType.TEXT;
  3306.     }
  3308.     // Otherwise, just split the MIME type.  This handles video and audio
  3309.     // types well.
  3310.     return mimeType.split('/')[0];
  3311.   }
  3314.   /**
  3315.    * Create a networking request. This will manage the request using the
  3316.    * parser's operation manager.
  3317.    *
  3318.    * @param {shaka.extern.Request} request
  3319.    * @param {shaka.net.NetworkingEngine.RequestType} type
  3320.    * @param {shaka.extern.RequestContext=} context
  3321.    * @return {!Promise<shaka.extern.Response>}
  3322.    * @private
  3323.    */
  3324.   makeNetworkRequest_(request, type, context) {
  3325.     if (!context) {
  3326.       context = {};
  3327.     }
  3328.     context.isPreload = this.isPreloadFn_();
  3329.     const op = this.playerInterface_.networkingEngine.request(
  3330.         type, request, context);
  3331.     this.operationManager_.manage(op);
  3332.     return op.promise;
  3333.   }
  3335.   /**
  3336.    * @param {!shaka.extern.xml.Node} patchNode
  3337.    * @private
  3338.    */
  3339.   updatePatchLocationNodes_(patchNode) {
  3340.     const TXml = shaka.util.TXml;
  3341.     TXml.modifyNodes(this.patchLocationNodes_, patchNode);
  3342.   }
  3344.   /**
  3345.    * @return {!Array<string>}
  3346.    * @private
  3347.    */
  3348.   getPatchLocationUris_() {
  3349.     const TXml = shaka.util.TXml;
  3350.     const mpdId = this.manifestPatchContext_.mpdId;
  3351.     const publishTime = this.manifestPatchContext_.publishTime;
  3352.     if (!mpdId || !publishTime || !this.patchLocationNodes_.length) {
  3353.       return [];
  3354.     }
  3355.     const now = Date.now() / 1000;
  3356.     const patchLocations = this.patchLocationNodes_.filter((patchLocation) => {
  3357.       const ttl = TXml.parseNonNegativeInt(patchLocation.attributes['ttl']);
  3358.       return !ttl || publishTime + ttl > now;
  3359.     })
  3360.         .map(TXml.getContents)
  3361.         .filter(shaka.util.Functional.isNotNull);
  3363.     if (!patchLocations.length) {
  3364.       return [];
  3365.     }
  3366.     return shaka.util.ManifestParserUtils.resolveUris(
  3367.         this.manifestUris_, patchLocations);
  3368.   }
  3370.   /**
  3371.    * @param {string} scheme
  3372.    * @return {boolean}
  3373.    * @private
  3374.    */
  3375.   static isNtpScheme_(scheme) {
  3376.     return scheme === 'urn:mpeg:dash:utc:http-ntp:2014' ||
  3377.         scheme === 'urn:mpeg:dash:utc:ntp:2014' ||
  3378.         scheme === 'urn:mpeg:dash:utc:sntp:2014';
  3379.   }
  3380. };
  3382. /**
  3383.  * @typedef {{
  3384.  *   mpdId: string,
  3385.  *   type: string,
  3386.  *   mediaPresentationDuration: ?number,
  3387.  *   profiles: !Array<string>,
  3388.  *   availabilityTimeOffset: number,
  3389.  *   getBaseUris: ?function():!Array<string>,
  3390.  *   publishTime: number
  3391.  * }}
  3392.  *
  3393.  * @property {string} mpdId
  3394.  *   ID of the original MPD file.
  3395.  * @property {string} type
  3396.  *   Specifies the type of the dash manifest i.e. "static"
  3397.  * @property {?number} mediaPresentationDuration
  3398.  *   Media presentation duration, or null if unknown.
  3399.  * @property {!Array<string>} profiles
  3400.  *   Profiles of DASH are defined to enable interoperability and the
  3401.  *   signaling of the use of features.
  3402.  * @property {number} availabilityTimeOffset
  3403.  *   Specifies the total availabilityTimeOffset of the segment.
  3404.  * @property {?function():!Array<string>} getBaseUris
  3405.  *   An array of absolute base URIs.
  3406.  * @property {number} publishTime
  3407.  *   Time when manifest has been published, in seconds.
  3408.  */
  3409. shaka.dash.DashParser.PatchContext;
  3412. /**
  3413.  * @const {string}
  3414.  * @private
  3415.  */
  3416. shaka.dash.DashParser.SCTE214_ = 'urn:scte:dash:scte214-extensions';
  3419. /**
  3420.  * @const {string}
  3421.  * @private
  3422.  */
  3423. shaka.dash.DashParser.UP_NAMESPACE_ = 'urn:mpeg:dash:schema:urlparam:2014';
  3426. /**
  3427.  * @typedef {
  3428.  *   function(!Array<string>, ?number, ?number, boolean):
  3429.  *     !Promise<BufferSource>
  3430.  * }
  3431.  */
  3432. shaka.dash.DashParser.RequestSegmentCallback;
  3435. /**
  3436.  * @typedef {{
  3437.  *   segmentBase: ?shaka.extern.xml.Node,
  3438.  *   segmentList: ?shaka.extern.xml.Node,
  3439.  *   segmentTemplate: ?shaka.extern.xml.Node,
  3440.  *   producerReferenceTime: ?shaka.extern.xml.Node,
  3441.  *   getBaseUris: function():!Array<string>,
  3442.  *   width: (number|undefined),
  3443.  *   height: (number|undefined),
  3444.  *   contentType: string,
  3445.  *   mimeType: string,
  3446.  *   codecs: string,
  3447.  *   frameRate: (number|undefined),
  3448.  *   pixelAspectRatio: (string|undefined),
  3449.  *   emsgSchemeIdUris: !Array<string>,
  3450.  *   id: ?string,
  3451.  *   originalId: ?string,
  3452.  *   position: (number|undefined),
  3453.  *   language: ?string,
  3454.  *   numChannels: ?number,
  3455.  *   audioSamplingRate: ?number,
  3456.  *   availabilityTimeOffset: number,
  3457.  *   initialization: ?string,
  3458.  *   aesKey: (shaka.extern.aesKey|undefined),
  3459.  *   segmentSequenceCadence: number,
  3460.  *   label: ?string,
  3461.  *   encrypted: boolean
  3462.  * }}
  3463.  *
  3464.  * @description
  3465.  * A collection of elements and properties which are inherited across levels
  3466.  * of a DASH manifest.
  3467.  *
  3468.  * @property {?shaka.extern.xml.Node} segmentBase
  3469.  *   The XML node for SegmentBase.
  3470.  * @property {?shaka.extern.xml.Node} segmentList
  3471.  *   The XML node for SegmentList.
  3472.  * @property {?shaka.extern.xml.Node} segmentTemplate
  3473.  *   The XML node for SegmentTemplate.
  3474.  * @property {?shaka.extern.xml.Node} producerReferenceTime
  3475.  *  The XML node for ProducerReferenceTime.
  3476.  * @property {function():!Array<string>} getBaseUris
  3477.  *   Function than returns an array of absolute base URIs for the frame.
  3478.  * @property {(number|undefined)} width
  3479.  *   The inherited width value.
  3480.  * @property {(number|undefined)} height
  3481.  *   The inherited height value.
  3482.  * @property {string} contentType
  3483.  *   The inherited media type.
  3484.  * @property {string} mimeType
  3485.  *   The inherited MIME type value.
  3486.  * @property {string} codecs
  3487.  *   The inherited codecs value.
  3488.  * @property {(number|undefined)} frameRate
  3489.  *   The inherited framerate value.
  3490.  * @property {(string|undefined)} pixelAspectRatio
  3491.  *   The inherited pixel aspect ratio value.
  3492.  * @property {!Array<string>} emsgSchemeIdUris
  3493.  *   emsg registered schemeIdUris.
  3494.  * @property {?string} id
  3495.  *   The ID of the element.
  3496.  * @property {?string} originalId
  3497.  *   The original ID of the element.
  3498.  * @property {number|undefined} position
  3499.  *   Position of the element used for indexing in case of no id
  3500.  * @property {?string} language
  3501.  *   The original language of the element.
  3502.  * @property {?number} numChannels
  3503.  *   The number of audio channels, or null if unknown.
  3504.  * @property {?number} audioSamplingRate
  3505.  *   Specifies the maximum sampling rate of the content, or null if unknown.
  3506.  * @property {number} availabilityTimeOffset
  3507.  *   Specifies the total availabilityTimeOffset of the segment, or 0 if unknown.
  3508.  * @property {?string} initialization
  3509.  *   Specifies the file where the init segment is located, or null.
  3510.  * @property {(shaka.extern.aesKey|undefined)} aesKey
  3511.  *   AES-128 Content protection key
  3512.  * @property {number} segmentSequenceCadence
  3513.  *   Specifies the cadence of independent segments in Segment Sequence
  3514.  *   Representation.
  3515.  * @property {?string} label
  3516.  *   Label or null if unknown.
  3517.  * @property {boolean} encrypted
  3518.  *   Specifies is encrypted or not.
  3519.  */
  3520. shaka.dash.DashParser.InheritanceFrame;
  3523. /**
  3524.  * @typedef {{
  3525.  *   dynamic: boolean,
  3526.  *   presentationTimeline: !shaka.media.PresentationTimeline,
  3527.  *   period: ?shaka.dash.DashParser.InheritanceFrame,
  3528.  *   periodInfo: ?shaka.dash.DashParser.PeriodInfo,
  3529.  *   adaptationSet: ?shaka.dash.DashParser.InheritanceFrame,
  3530.  *   representation: ?shaka.dash.DashParser.InheritanceFrame,
  3531.  *   bandwidth: number,
  3532.  *   indexRangeWarningGiven: boolean,
  3533.  *   availabilityTimeOffset: number,
  3534.  *   mediaPresentationDuration: ?number,
  3535.  *   profiles: !Array<string>,
  3536.  *   roles: ?Array<string>,
  3537.  *   urlParams: function():string
  3538.  * }}
  3539.  *
  3540.  * @description
  3541.  * Contains context data for the streams.  This is designed to be
  3542.  * shallow-copyable, so the parser must overwrite (not modify) each key as the
  3543.  * parser moves through the manifest and the parsing context changes.
  3544.  *
  3545.  * @property {boolean} dynamic
  3546.  *   True if the MPD is dynamic (not all segments available at once)
  3547.  * @property {!shaka.media.PresentationTimeline} presentationTimeline
  3548.  *   The PresentationTimeline.
  3549.  * @property {?shaka.dash.DashParser.InheritanceFrame} period
  3550.  *   The inheritance from the Period element.
  3551.  * @property {?shaka.dash.DashParser.PeriodInfo} periodInfo
  3552.  *   The Period info for the current Period.
  3553.  * @property {?shaka.dash.DashParser.InheritanceFrame} adaptationSet
  3554.  *   The inheritance from the AdaptationSet element.
  3555.  * @property {?shaka.dash.DashParser.InheritanceFrame} representation
  3556.  *   The inheritance from the Representation element.
  3557.  * @property {number} bandwidth
  3558.  *   The bandwidth of the Representation, or zero if missing.
  3559.  * @property {boolean} indexRangeWarningGiven
  3560.  *   True if the warning about SegmentURL@indexRange has been printed.
  3561.  * @property {number} availabilityTimeOffset
  3562.  *   The sum of the availabilityTimeOffset values that apply to the element.
  3563.  * @property {!Array<string>} profiles
  3564.  *   Profiles of DASH are defined to enable interoperability and the signaling
  3565.  *   of the use of features.
  3566.  * @property {?number} mediaPresentationDuration
  3567.  *   Media presentation duration, or null if unknown.
  3568.  * @property {function():string} urlParams
  3569.  *   The query params for the segments.
  3570.  */
  3571. shaka.dash.DashParser.Context;
  3574. /**
  3575.  * @typedef {{
  3576.  *   start: number,
  3577.  *   duration: ?number,
  3578.  *   node: ?shaka.extern.xml.Node,
  3579.  *   isLastPeriod: boolean
  3580.  * }}
  3581.  *
  3582.  * @description
  3583.  * Contains information about a Period element.
  3584.  *
  3585.  * @property {number} start
  3586.  *   The start time of the period.
  3587.  * @property {?number} duration
  3588.  *   The duration of the period; or null if the duration is not given.  This
  3589.  *   will be non-null for all periods except the last.
  3590.  * @property {?shaka.extern.xml.Node} node
  3591.  *   The XML Node for the Period.
  3592.  * @property {boolean} isLastPeriod
  3593.  *   Whether this Period is the last one in the manifest.
  3594.  */
  3595. shaka.dash.DashParser.PeriodInfo;
  3598. /**
  3599.  * @typedef {{
  3600.  *   id: string,
  3601.  *   contentType: ?string,
  3602.  *   language: string,
  3603.  *   main: boolean,
  3604.  *   streams: !Array<shaka.extern.Stream>,
  3605.  *   drmInfos: !Array<shaka.extern.DrmInfo>,
  3606.  *   trickModeFor: ?string,
  3607.  *   representationIds: !Array<string>,
  3608.  *   dependencyStreamMap: !Map<string, shaka.extern.Stream>
  3609.  * }}
  3610.  *
  3611.  * @description
  3612.  * Contains information about an AdaptationSet element.
  3613.  *
  3614.  * @property {string} id
  3615.  *   The unique ID of the adaptation set.
  3616.  * @property {?string} contentType
  3617.  *   The content type of the AdaptationSet.
  3618.  * @property {string} language
  3619.  *   The language of the AdaptationSet.
  3620.  * @property {boolean} main
  3621.  *   Whether the AdaptationSet has the 'main' type.
  3622.  * @property {!Array<shaka.extern.Stream>} streams
  3623.  *   The streams this AdaptationSet contains.
  3624.  * @property {!Array<shaka.extern.DrmInfo>} drmInfos
  3625.  *   The DRM info for the AdaptationSet.
  3626.  * @property {?string} trickModeFor
  3627.  *   If non-null, this AdaptationInfo represents trick mode tracks.  This
  3628.  *   property is the ID of the normal AdaptationSet these tracks should be
  3629.  *   associated with.
  3630.  * @property {!Array<string>} representationIds
  3631.  *   An array of the IDs of the Representations this AdaptationSet contains.
  3632.  * @property {!Map<string, string>} dependencyStreamMap
  3633.  *   A map of dependencyStream
  3634.  */
  3635. shaka.dash.DashParser.AdaptationInfo;
  3638. /**
  3639.  * @typedef {function(): !Promise<shaka.media.SegmentIndex>}
  3640.  * @description
  3641.  * An async function which generates and returns a SegmentIndex.
  3642.  */
  3643. shaka.dash.DashParser.GenerateSegmentIndexFunction;
  3646. /**
  3647.  * @typedef {{
  3648.  *   timeline: number,
  3649.  *   endTime: number,
  3650.  *   generateSegmentIndex: shaka.dash.DashParser.GenerateSegmentIndexFunction,
  3651.  *   timescale: number
  3652.  * }}
  3653.  *
  3654.  * @description
  3655.  * Contains information about a Stream. This is passed from the createStreamInfo
  3656.  * methods.
  3657.  *
  3658.  * @property {number} timeline
  3659.  *    The continuity timeline, if it has one.
  3660.  * @property {number} endTime
  3661.  *    The current timeline's end time, if it has one.
  3662.  * @property {shaka.dash.DashParser.GenerateSegmentIndexFunction
  3663.  *           } generateSegmentIndex
  3664.  *   An async function to create the SegmentIndex for the stream.
  3665.  * @property {number} timescale
  3666.  *  The timescale of the stream.
  3667.  */
  3668. shaka.dash.DashParser.StreamInfo;
  3671. shaka.media.ManifestParser.registerParserByMime(
  3672.     'application/dash+xml', () => new shaka.dash.DashParser());
  3673. shaka.media.ManifestParser.registerParserByMime(
  3674.     'video/vnd.mpeg.dash.mpd', () => new shaka.dash.DashParser());