Source: lib/hls/hls_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  8. goog.provide('shaka.hls.HlsParser');
  10. goog.require('goog.Uri');
  11. goog.require('goog.asserts');
  12. goog.require('shaka.abr.Ewma');
  13. goog.require('shaka.drm.DrmUtils');
  14. goog.require('shaka.drm.FairPlay');
  15. goog.require('shaka.drm.PlayReady');
  16. goog.require('shaka.hls.Attribute');
  17. goog.require('shaka.hls.ManifestTextParser');
  18. goog.require('shaka.hls.Playlist');
  19. goog.require('shaka.hls.PlaylistType');
  20. goog.require('shaka.hls.Tag');
  21. goog.require('shaka.hls.Utils');
  22. goog.require('shaka.log');
  23. goog.require('shaka.media.InitSegmentReference');
  24. goog.require('shaka.media.ManifestParser');
  25. goog.require('shaka.media.PresentationTimeline');
  26. goog.require('shaka.media.QualityObserver');
  27. goog.require('shaka.media.SegmentIndex');
  28. goog.require('shaka.media.SegmentReference');
  29. goog.require('shaka.media.SegmentUtils');
  30. goog.require('shaka.net.DataUriPlugin');
  31. goog.require('shaka.net.NetworkingEngine');
  32. goog.require('shaka.net.NetworkingEngine.PendingRequest');
  33. goog.require('shaka.util.ArrayUtils');
  34. goog.require('shaka.util.BufferUtils');
  35. goog.require('shaka.util.ContentSteeringManager');
  36. goog.require('shaka.util.Error');
  37. goog.require('shaka.util.EventManager');
  38. goog.require('shaka.util.FakeEvent');
  39. goog.require('shaka.util.LanguageUtils');
  40. goog.require('shaka.util.ManifestParserUtils');
  41. goog.require('shaka.util.MimeUtils');
  42. goog.require('shaka.util.Networking');
  43. goog.require('shaka.util.OperationManager');
  44. goog.require('shaka.util.Pssh');
  45. goog.require('shaka.util.Timer');
  46. goog.require('shaka.util.TsParser');
  47. goog.require('shaka.util.TXml');
  48. goog.require('shaka.util.StreamUtils');
  49. goog.require('shaka.util.Uint8ArrayUtils');
  50. goog.requireType('shaka.hls.Segment');
  53. /**
  54.  * HLS parser.
  55.  *
  56.  * @implements {shaka.extern.ManifestParser}
  57.  * @export
  58.  */
  59. shaka.hls.HlsParser = class {
  60.   /**
  61.    * Creates an Hls Parser object.
  62.    */
  63.   constructor() {
  64.     /** @private {?shaka.extern.ManifestParser.PlayerInterface} */
  65.     this.playerInterface_ = null;
  67.     /** @private {?shaka.extern.ManifestConfiguration} */
  68.     this.config_ = null;
  70.     /** @private {number} */
  71.     this.globalId_ = 1;
  73.     /** @private {!Map<string, string>} */
  74.     this.globalVariables_ = new Map();
  76.     /**
  77.      * A map from group id to stream infos created from the media tags.
  78.      * @private {!Map<string, !Array<?shaka.hls.HlsParser.StreamInfo>>}
  79.      */
  80.     this.groupIdToStreamInfosMap_ = new Map();
  82.     /**
  83.      * For media playlist lazy-loading to work in livestreams, we have to assume
  84.      * that each stream of a type (video, audio, etc) has the same mappings of
  85.      * sequence number to start time.
  86.      * This map stores those relationships.
  87.      * Only used during livestreams; we do not assume that VOD content is
  88.      * aligned in that way.
  89.      * @private {!Map<string, !Map<number, number>>}
  90.      */
  91.     this.mediaSequenceToStartTimeByType_ = new Map();
  93.     // Set initial maps.
  94.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  95.     this.mediaSequenceToStartTimeByType_.set(ContentType.VIDEO, new Map());
  96.     this.mediaSequenceToStartTimeByType_.set(ContentType.AUDIO, new Map());
  97.     this.mediaSequenceToStartTimeByType_.set(ContentType.TEXT, new Map());
  98.     this.mediaSequenceToStartTimeByType_.set(ContentType.IMAGE, new Map());
  100.     /** @private {!Map<string, shaka.hls.HlsParser.DrmParser_>} */
  101.     this.keyFormatsToDrmParsers_ = new Map()
  102.         .set('com.apple.streamingkeydelivery',
  103.             (tag, type, ref) => this.fairplayDrmParser_(tag, type, ref))
  104.         .set('urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
  105.             (tag, type, ref) => this.widevineDrmParser_(tag, type, ref))
  106.         .set('com.microsoft.playready',
  107.             (tag, type, ref) => this.playreadyDrmParser_(tag, type, ref))
  108.         .set('urn:uuid:3d5e6d35-9b9a-41e8-b843-dd3c6e72c42c',
  109.             (tag, type, ref) => this.wiseplayDrmParser_(tag, type, ref));
  111.     /**
  112.      * The values are strings of the form "<VIDEO URI> - <AUDIO URI>",
  113.      * where the URIs are the verbatim media playlist URIs as they appeared in
  114.      * the master playlist.
  115.      *
  116.      * Used to avoid duplicates that vary only in their text stream.
  117.      *
  118.      * @private {!Set<string>}
  119.      */
  120.     this.variantUriSet_ = new Set();
  122.     /**
  123.      * A map from (verbatim) media playlist URI to stream infos representing the
  124.      * playlists.
  125.      *
  126.      * On update, used to iterate through and update from media playlists.
  127.      *
  128.      * On initial parse, used to iterate through and determine minimum
  129.      * timestamps, offsets, and to handle TS rollover.
  130.      *
  131.      * During parsing, used to avoid duplicates in the async methods
  132.      * createStreamInfoFromMediaTags_, createStreamInfoFromImageTag_ and
  133.      * createStreamInfoFromVariantTags_.
  134.      *
  135.      * @private {!Map<string, shaka.hls.HlsParser.StreamInfo>}
  136.      */
  137.     this.uriToStreamInfosMap_ = new Map();
  139.     /** @private {?shaka.media.PresentationTimeline} */
  140.     this.presentationTimeline_ = null;
  142.     /**
  143.      * The master playlist URI, after redirects.
  144.      *
  145.      * @private {string}
  146.      */
  147.     this.masterPlaylistUri_ = '';
  149.     /** @private {shaka.hls.ManifestTextParser} */
  150.     this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
  152.     /**
  153.      * The minimum sequence number for generated segments, when ignoring
  154.      * EXT-X-PROGRAM-DATE-TIME.
  155.      *
  156.      * @private {number}
  157.      */
  158.     this.minSequenceNumber_ = -1;
  160.     /**
  161.      * The lowest time value for any of the streams, as defined by the
  162.      * EXT-X-PROGRAM-DATE-TIME value. Measured in seconds since January 1, 1970.
  163.      *
  164.      * @private {number}
  165.      */
  166.     this.lowestSyncTime_ = Infinity;
  168.     /**
  169.      * Flag to indicate if any of the media playlists use
  170.      * EXT-X-PROGRAM-DATE-TIME.
  171.      *
  172.      * @private {boolean}
  173.      */
  174.     this.usesProgramDateTime_ = false;
  176.     /**
  177.      * Whether the streams have previously been "finalized"; that is to say,
  178.      * whether we have loaded enough streams to know information about the asset
  179.      * such as timing information, live status, etc.
  180.      *
  181.      * @private {boolean}
  182.      */
  183.     this.streamsFinalized_ = false;
  185.     /**
  186.      * Whether the manifest informs about the codec to use.
  187.      *
  188.      * @private
  189.      */
  190.     this.codecInfoInManifest_ = false;
  192.     /**
  193.      * This timer is used to trigger the start of a manifest update. A manifest
  194.      * update is async. Once the update is finished, the timer will be restarted
  195.      * to trigger the next update. The timer will only be started if the content
  196.      * is live content.
  197.      *
  198.      * @private {shaka.util.Timer}
  199.      */
  200.     this.updatePlaylistTimer_ = new shaka.util.Timer(() => {
  201.       if (this.mediaElement_ && !this.config_.continueLoadingWhenPaused) {
  202.         this.eventManager_.unlisten(this.mediaElement_, 'timeupdate');
  203.         if (this.mediaElement_.paused) {
  204.           this.eventManager_.listenOnce(
  205.               this.mediaElement_, 'timeupdate', () => this.onUpdate_());
  206.           return;
  207.         }
  208.       }
  209.       this.onUpdate_();
  210.     });
  212.     /** @private {shaka.hls.HlsParser.PresentationType_} */
  213.     this.presentationType_ = shaka.hls.HlsParser.PresentationType_.VOD;
  215.     /** @private {?shaka.extern.Manifest} */
  216.     this.manifest_ = null;
  218.     /** @private {number} */
  219.     this.maxTargetDuration_ = 0;
  221.     /** @private {number} */
  222.     this.lastTargetDuration_ = Infinity;
  224.     /**
  225.      * Partial segments target duration.
  226.      * @private {number}
  227.      */
  228.     this.partialTargetDuration_ = 0;
  230.     /** @private {number} */
  231.     this.presentationDelay_ = 0;
  233.     /** @private {number} */
  234.     this.lowLatencyPresentationDelay_ = 0;
  236.     /** @private {shaka.util.OperationManager} */
  237.     this.operationManager_ = new shaka.util.OperationManager();
  239.     /**
  240.      * A map from closed captions' group id, to a map of closed captions info.
  241.      * {group id -> {closed captions channel id -> language}}
  242.      * @private {Map<string, Map<string, string>>}
  243.      */
  244.     this.groupIdToClosedCaptionsMap_ = new Map();
  246.     /** @private {Map<string, string>} */
  247.     this.groupIdToCodecsMap_ = new Map();
  249.     /**
  250.      * A cache mapping EXT-X-MAP tag info to the InitSegmentReference created
  251.      * from the tag.
  252.      * The key is a string combining the EXT-X-MAP tag's absolute uri, and
  253.      * its BYTERANGE if available.
  254.      * @private {!Map<string, !shaka.media.InitSegmentReference>}
  255.      */
  256.     this.mapTagToInitSegmentRefMap_ = new Map();
  258.     /** @private {Map<string, !shaka.extern.aesKey>} */
  259.     this.aesKeyInfoMap_ = new Map();
  261.     /** @private {Map<string, !Promise<shaka.extern.Response>>} */
  262.     this.aesKeyMap_ = new Map();
  264.     /** @private {Map<string, !Promise<shaka.extern.Response>>} */
  265.     this.identityKeyMap_ = new Map();
  267.     /** @private {Map<!shaka.media.InitSegmentReference, ?string>} */
  268.     this.initSegmentToKidMap_ = new Map();
  270.     /** @private {boolean} */
  271.     this.lowLatencyMode_ = false;
  273.     /** @private {boolean} */
  274.     this.lowLatencyByterangeOptimization_ = false;
  276.     /**
  277.      * An ewma that tracks how long updates take.
  278.      * This is to mitigate issues caused by slow parsing on embedded devices.
  279.      * @private {!shaka.abr.Ewma}
  280.      */
  281.     this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
  283.     /** @private {?shaka.util.ContentSteeringManager} */
  284.     this.contentSteeringManager_ = null;
  286.     /** @private {boolean} */
  287.     this.needsClosedCaptionsDetection_ = true;
  289.     /** @private {Set<string>} */
  290.     this.dateRangeIdsEmitted_ = new Set();
  292.     /** @private {shaka.util.EventManager} */
  293.     this.eventManager_ = new shaka.util.EventManager();
  295.     /** @private {HTMLMediaElement} */
  296.     this.mediaElement_ = null;
  298.     /** @private {?number} */
  299.     this.startTime_ = null;
  301.     /** @private {function():boolean} */
  302.     this.isPreloadFn_ = () => false;
  303.   }
  306.   /**
  307.    * @param {shaka.extern.ManifestConfiguration} config
  308.    * @param {(function():boolean)=} isPreloadFn
  309.    * @override
  310.    * @exportInterface
  311.    */
  312.   configure(config, isPreloadFn) {
  313.     const needFireUpdate = this.playerInterface_ &&
  314.       config.updatePeriod != this.config_.updatePeriod &&
  315.       config.updatePeriod >= 0;
  316.     this.config_ = config;
  317.     if (isPreloadFn) {
  318.       this.isPreloadFn_ = isPreloadFn;
  319.     }
  321.     if (this.contentSteeringManager_) {
  322.       this.contentSteeringManager_.configure(this.config_);
  323.     }
  325.     if (needFireUpdate && this.manifest_ &&
  326.       this.manifest_.presentationTimeline.isLive()) {
  327.       this.updatePlaylistTimer_.tickNow();
  328.     }
  329.   }
  331.   /**
  332.    * @override
  333.    * @exportInterface
  334.    */
  335.   async start(uri, playerInterface) {
  336.     goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  337.     this.playerInterface_ = playerInterface;
  338.     this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
  340.     const response = await this.requestManifest_([uri]).promise;
  342.     // Record the master playlist URI after redirects.
  343.     this.masterPlaylistUri_ = response.uri;
  345.     goog.asserts.assert(response.data, 'Response data should be non-null!');
  346.     await this.parseManifest_(response.data);
  348.     goog.asserts.assert(this.manifest_, 'Manifest should be non-null');
  349.     return this.manifest_;
  350.   }
  352.   /**
  353.    * @override
  354.    * @exportInterface
  355.    */
  356.   stop() {
  357.     // Make sure we don't update the manifest again. Even if the timer is not
  358.     // running, this is safe to call.
  359.     if (this.updatePlaylistTimer_) {
  360.       this.updatePlaylistTimer_.stop();
  361.       this.updatePlaylistTimer_ = null;
  362.     }
  364.     /** @type {!Array<!Promise>} */
  365.     const pending = [];
  367.     if (this.operationManager_) {
  368.       pending.push(this.operationManager_.destroy());
  369.       this.operationManager_ = null;
  370.     }
  372.     this.playerInterface_ = null;
  373.     this.config_ = null;
  374.     this.variantUriSet_.clear();
  375.     this.manifest_ = null;
  376.     this.uriToStreamInfosMap_.clear();
  377.     this.groupIdToStreamInfosMap_.clear();
  378.     this.groupIdToCodecsMap_.clear();
  379.     this.globalVariables_.clear();
  380.     this.mapTagToInitSegmentRefMap_.clear();
  381.     this.aesKeyInfoMap_.clear();
  382.     this.aesKeyMap_.clear();
  383.     this.identityKeyMap_.clear();
  384.     this.initSegmentToKidMap_.clear();
  385.     this.dateRangeIdsEmitted_.clear();
  387.     if (this.contentSteeringManager_) {
  388.       this.contentSteeringManager_.destroy();
  389.     }
  391.     if (this.eventManager_) {
  392.       this.eventManager_.release();
  393.       this.eventManager_ = null;
  394.     }
  396.     return Promise.all(pending);
  397.   }
  399.   /**
  400.    * @override
  401.    * @exportInterface
  402.    */
  403.   async update() {
  404.     if (!this.isLive_()) {
  405.       return;
  406.     }
  408.     /** @type {!Array<!Promise>} */
  409.     const updates = [];
  410.     const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  412.     // This is necessary to calculate correctly the update time.
  413.     this.lastTargetDuration_ = Infinity;
  414.     this.manifest_.gapCount = 0;
  416.     // Only update active streams.
  417.     const activeStreamInfos = streamInfos.filter((s) => s.stream.segmentIndex);
  418.     for (const streamInfo of activeStreamInfos) {
  419.       updates.push(this.updateStream_(streamInfo));
  420.     }
  421.     await Promise.all(updates);
  423.     // Now that streams have been updated, notify the presentation timeline.
  424.     this.notifySegmentsForStreams_(activeStreamInfos.map((s) => s.stream));
  426.     // If any hasEndList is false, the stream is still live.
  427.     const stillLive = activeStreamInfos.some((s) => s.hasEndList == false);
  428.     if (activeStreamInfos.length && !stillLive) {
  429.       // Convert the presentation to VOD and set the duration.
  430.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  431.       this.setPresentationType_(PresentationType.VOD);
  433.       // The duration is the minimum of the end times of all active streams.
  434.       // Non-active streams are not guaranteed to have useful maxTimestamp
  435.       // values, due to the lazy-loading system, so they are ignored.
  436.       const maxTimestamps = activeStreamInfos.map((s) => s.maxTimestamp);
  437.       // The duration is the minimum of the end times of all streams.
  438.       this.presentationTimeline_.setDuration(Math.min(...maxTimestamps));
  439.       this.playerInterface_.updateDuration();
  440.     }
  441.     if (stillLive) {
  442.       this.determineDuration_();
  443.     }
  444.     // Check if any playlist does not have the first reference (due to a
  445.     // problem in the live encoder for example), and disable the stream if
  446.     // necessary.
  447.     for (const streamInfo of activeStreamInfos) {
  448.       if (!streamInfo.stream.isAudioMuxedInVideo &&
  449.           streamInfo.stream.segmentIndex &&
  450.           !streamInfo.stream.segmentIndex.earliestReference()) {
  451.         this.playerInterface_.disableStream(streamInfo.stream);
  452.       }
  453.     }
  454.   }
  456.   /**
  457.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  458.    * @return {!Map<number, number>}
  459.    * @private
  460.    */
  461.   getMediaSequenceToStartTimeFor_(streamInfo) {
  462.     if (this.isLive_()) {
  463.       return this.mediaSequenceToStartTimeByType_.get(streamInfo.type);
  464.     } else {
  465.       return streamInfo.mediaSequenceToStartTime;
  466.     }
  467.   }
  469.   /**
  470.    * Updates a stream.
  471.    *
  472.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  473.    * @return {!Promise}
  474.    * @private
  475.    */
  476.   async updateStream_(streamInfo) {
  477.     if (streamInfo.stream.isAudioMuxedInVideo) {
  478.       return;
  479.     }
  480.     const manifestUris = [];
  481.     for (const uri of streamInfo.getUris()) {
  482.       const uriObj = new goog.Uri(uri);
  483.       const queryData = uriObj.getQueryData();
  484.       if (streamInfo.canBlockReload) {
  485.         if (streamInfo.nextMediaSequence >= 0) {
  486.           // Indicates that the server must hold the request until a Playlist
  487.           // contains a Media Segment with Media Sequence
  488.           queryData.add('_HLS_msn', String(streamInfo.nextMediaSequence));
  489.         }
  490.         if (streamInfo.nextPart >= 0) {
  491.           // Indicates, in combination with _HLS_msn, that the server must hold
  492.           // the request until a Playlist contains Partial Segment N of Media
  493.           // Sequence Number M or later.
  494.           queryData.add('_HLS_part', String(streamInfo.nextPart));
  495.         }
  496.       }
  497.       if (streamInfo.canSkipSegments) {
  498.         // Enable delta updates. This will replace older segments with
  499.         // 'EXT-X-SKIP' tag in the media playlist.
  500.         queryData.add('_HLS_skip', 'YES');
  501.       }
  502.       if (queryData.getCount()) {
  503.         uriObj.setQueryData(queryData.toDecodedString());
  504.       }
  505.       manifestUris.push(uriObj.toString());
  506.     }
  507.     let response;
  508.     try {
  509.       response = await this.requestManifest_(
  510.           manifestUris, /* isPlaylist= */ true).promise;
  511.     } catch (e) {
  512.       if (this.playerInterface_) {
  513.         this.playerInterface_.disableStream(streamInfo.stream);
  514.       }
  515.       throw e;
  516.     }
  517.     if (!streamInfo.stream.segmentIndex) {
  518.       // The stream was closed since the update was first requested.
  519.       return;
  520.     }
  522.     /** @type {shaka.hls.Playlist} */
  523.     const playlist = this.manifestTextParser_.parsePlaylist(response.data);
  525.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  526.       throw new shaka.util.Error(
  527.           shaka.util.Error.Severity.CRITICAL,
  528.           shaka.util.Error.Category.MANIFEST,
  529.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  530.     }
  532.     // Record the final URI after redirects.
  533.     const responseUri = response.uri;
  534.     if (responseUri != response.originalUri &&
  535.         !streamInfo.getUris().includes(responseUri)) {
  536.       streamInfo.redirectUris.push(responseUri);
  537.     }
  539.     /** @type {!Array<!shaka.hls.Tag>} */
  540.     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  541.         'EXT-X-DEFINE');
  543.     const mediaVariables = this.parseMediaVariables_(
  544.         variablesTags, responseUri);
  546.     const stream = streamInfo.stream;
  548.     const mediaSequenceToStartTime =
  549.         this.getMediaSequenceToStartTimeFor_(streamInfo);
  550.     const {keyIds, drmInfos, encrypted, aesEncrypted} =
  551.         await this.parseDrmInfo_(playlist, stream.mimeType,
  552.             streamInfo.getUris, mediaVariables);
  554.     if (!stream.encrypted && encrypted && !aesEncrypted) {
  555.       stream.encrypted = true;
  556.     }
  558.     const keysAreEqual =
  559.       (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
  561.     if (!keysAreEqual(stream.keyIds, keyIds)) {
  562.       stream.keyIds = keyIds;
  563.       stream.drmInfos = drmInfos;
  564.       this.playerInterface_.newDrmInfo(stream);
  565.     }
  567.     const {segments, bandwidth} = this.createSegments_(
  568.         playlist, mediaSequenceToStartTime, mediaVariables,
  569.         streamInfo.getUris, streamInfo.type);
  570.     if (bandwidth) {
  571.       stream.bandwidth = bandwidth;
  572.     }
  574.     const qualityInfo =
  575.         shaka.media.QualityObserver.createQualityInfo(stream);
  576.     for (const segment of segments) {
  577.       if (segment.initSegmentReference) {
  578.         segment.initSegmentReference.mediaQuality = qualityInfo;
  579.       }
  580.     }
  582.     stream.segmentIndex.mergeAndEvict(
  583.         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
  584.     if (segments.length) {
  585.       const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  586.           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  587.       const skipTag = shaka.hls.Utils.getFirstTagWithName(
  588.           playlist.tags, 'EXT-X-SKIP');
  589.       const skippedSegments =
  590.           skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
  591.       const {nextMediaSequence, nextPart} =
  592.           this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
  593.       streamInfo.nextMediaSequence = nextMediaSequence + skippedSegments;
  594.       streamInfo.nextPart = nextPart;
  595.       const playlistStartTime = mediaSequenceToStartTime.get(
  596.           mediaSequenceNumber);
  597.       stream.segmentIndex.evict(playlistStartTime);
  598.     }
  599.     const oldSegment = stream.segmentIndex.earliestReference();
  600.     if (oldSegment) {
  601.       streamInfo.minTimestamp = oldSegment.startTime;
  603.       const newestSegment = segments[segments.length - 1];
  604.       goog.asserts.assert(newestSegment, 'Should have segments!');
  606.       streamInfo.maxTimestamp = newestSegment.endTime;
  607.     }
  609.     // Once the last segment has been added to the playlist,
  610.     // #EXT-X-ENDLIST tag will be appended.
  611.     // If that happened, treat the rest of the EVENT presentation as VOD.
  612.     const endListTag =
  613.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  615.     if (endListTag) {
  616.       // Flag this for later.  We don't convert the whole presentation into VOD
  617.       // until we've seen the ENDLIST tag for all active playlists.
  618.       streamInfo.hasEndList = true;
  619.     }
  621.     this.determineLastTargetDuration_(playlist);
  623.     this.processDateRangeTags_(
  624.         playlist.tags, stream.type, mediaVariables, streamInfo.getUris);
  625.   }
  628.   /**
  629.    * @override
  630.    * @exportInterface
  631.    */
  632.   onExpirationUpdated(sessionId, expiration) {
  633.     // No-op
  634.   }
  636.   /**
  637.    * @override
  638.    * @exportInterface
  639.    */
  640.   onInitialVariantChosen(variant) {
  641.     // No-op
  642.   }
  644.   /**
  645.    * @override
  646.    * @exportInterface
  647.    */
  648.   banLocation(uri) {
  649.     if (this.contentSteeringManager_) {
  650.       this.contentSteeringManager_.banLocation(uri);
  651.     }
  652.   }
  654.   /**
  655.    * @override
  656.    * @exportInterface
  657.    */
  658.   setMediaElement(mediaElement) {
  659.     this.mediaElement_ = mediaElement;
  660.   }
  662.   /**
  663.    * Align the streams by sequence number by dropping early segments.  Then
  664.    * offset the streams to begin at presentation time 0.
  665.    * @param {!Array<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  666.    * @param {boolean=} force
  667.    * @private
  668.    */
  669.   syncStreamsWithSequenceNumber_(streamInfos, force = false) {
  670.     // We assume that, when this is first called, we have enough info to
  671.     // determine how to use the program date times (e.g. we have both a video
  672.     // and an audio, and all other videos and audios match those).
  673.     // Thus, we only need to calculate this once.
  674.     const updateMinSequenceNumber = this.minSequenceNumber_ == -1;
  675.     // Sync using media sequence number.  Find the highest starting sequence
  676.     // number among all streams.  Later, we will drop any references to
  677.     // earlier segments in other streams, then offset everything back to 0.
  678.     for (const streamInfo of streamInfos) {
  679.       const segmentIndex = streamInfo.stream.segmentIndex;
  680.       goog.asserts.assert(segmentIndex,
  681.           'Only loaded streams should be synced');
  682.       const mediaSequenceToStartTime =
  683.           this.getMediaSequenceToStartTimeFor_(streamInfo);
  684.       const segment0 = segmentIndex.earliestReference();
  685.       if (segment0) {
  686.         // This looks inefficient, but iteration order is insertion order.
  687.         // So the very first entry should be the one we want.
  688.         // We assert that this holds true so that we are alerted by debug
  689.         // builds and tests if it changes.  We still do a loop, though, so
  690.         // that the code functions correctly in production no matter what.
  691.         if (goog.DEBUG) {
  692.           const firstSequenceStartTime =
  693.               mediaSequenceToStartTime.values().next().value;
  694.           if (firstSequenceStartTime != segment0.startTime) {
  695.             shaka.log.warning(
  696.                 'Sequence number map is not ordered as expected!');
  697.           }
  698.         }
  699.         for (const [sequence, start] of mediaSequenceToStartTime) {
  700.           if (start == segment0.startTime) {
  701.             if (updateMinSequenceNumber) {
  702.               this.minSequenceNumber_ = Math.max(
  703.                   this.minSequenceNumber_, sequence);
  704.             }
  705.             // Even if we already have decided on a value for
  706.             // |this.minSequenceNumber_|, we still need to determine the first
  707.             // sequence number for the stream, to offset it in the code below.
  708.             streamInfo.firstSequenceNumber = sequence;
  709.             break;
  710.           }
  711.         }
  712.       }
  713.     }
  715.     if (this.minSequenceNumber_ < 0) {
  716.       // Nothing to sync.
  717.       return;
  718.     }
  720.     shaka.log.debug('Syncing HLS streams against base sequence number:',
  721.         this.minSequenceNumber_);
  723.     for (const streamInfo of streamInfos) {
  724.       if (!this.ignoreManifestProgramDateTimeFor_(streamInfo.type) && !force) {
  725.         continue;
  726.       }
  727.       const segmentIndex = streamInfo.stream.segmentIndex;
  728.       if (segmentIndex) {
  729.         // Drop any earlier references.
  730.         const numSegmentsToDrop =
  731.             this.minSequenceNumber_ - streamInfo.firstSequenceNumber;
  732.         if (numSegmentsToDrop > 0) {
  733.           segmentIndex.dropFirstReferences(numSegmentsToDrop);
  735.           // Now adjust timestamps back to begin at 0.
  736.           const segmentN = segmentIndex.earliestReference();
  737.           if (segmentN) {
  738.             const streamOffset = -segmentN.startTime;
  739.             // Modify all SegmentReferences equally.
  740.             streamInfo.stream.segmentIndex.offset(streamOffset);
  741.             // Update other parts of streamInfo the same way.
  742.             this.offsetStreamInfo_(streamInfo, streamOffset);
  743.           }
  744.         }
  745.       }
  746.     }
  747.   }
  749.   /**
  750.    * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
  751.    * segments.  Also normalizes segment times so that the earliest segment in
  752.    * any stream is at time 0.
  753.    * @param {!Array<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  754.    * @private
  755.    */
  756.   syncStreamsWithProgramDateTime_(streamInfos) {
  757.     // We assume that, when this is first called, we have enough info to
  758.     // determine how to use the program date times (e.g. we have both a video
  759.     // and an audio, and all other videos and audios match those).
  760.     // Thus, we only need to calculate this once.
  761.     if (this.lowestSyncTime_ == Infinity) {
  762.       for (const streamInfo of streamInfos) {
  763.         const segmentIndex = streamInfo.stream.segmentIndex;
  764.         goog.asserts.assert(segmentIndex,
  765.             'Only loaded streams should be synced');
  766.         const segment0 = segmentIndex.earliestReference();
  767.         if (segment0 != null && segment0.syncTime != null) {
  768.           this.lowestSyncTime_ =
  769.               Math.min(this.lowestSyncTime_, segment0.syncTime);
  770.         }
  771.       }
  772.     }
  774.     const lowestSyncTime = this.lowestSyncTime_;
  775.     if (lowestSyncTime == Infinity) {
  776.       // Nothing to sync.
  777.       return;
  778.     }
  780.     shaka.log.debug('Syncing HLS streams against base time:', lowestSyncTime);
  782.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  783.       if (this.ignoreManifestProgramDateTimeFor_(streamInfo.type)) {
  784.         continue;
  785.       }
  786.       const segmentIndex = streamInfo.stream.segmentIndex;
  787.       if (segmentIndex != null) {
  788.         // A segment's startTime should be based on its syncTime vs the lowest
  789.         // syncTime across all streams.  The earliest segment sync time from
  790.         // any stream will become presentation time 0.  If two streams start
  791.         // e.g. 6 seconds apart in syncTime, then their first segments will
  792.         // also start 6 seconds apart in presentation time.
  794.         const segment0 = segmentIndex.earliestReference();
  795.         if (!segment0) {
  796.           continue;
  797.         }
  798.         if (segment0.syncTime == null) {
  799.           shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
  800.               streamInfo.getUris(),
  801.               'Expect AV sync issues!');
  802.         } else {
  803.           // Stream metadata are offset by a fixed amount based on the
  804.           // first segment.
  805.           const segment0TargetTime = segment0.syncTime - lowestSyncTime;
  806.           const streamOffset = segment0TargetTime - segment0.startTime;
  807.           this.offsetStreamInfo_(streamInfo, streamOffset);
  809.           // This is computed across all segments separately to manage
  810.           // accumulated drift in durations.
  811.           for (const segment of segmentIndex) {
  812.             segment.syncAgainst(lowestSyncTime);
  813.           }
  814.         }
  815.       }
  816.     }
  817.   }
  819.   /**
  820.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  821.    * @param {number} offset
  822.    * @private
  823.    */
  824.   offsetStreamInfo_(streamInfo, offset) {
  825.     // Due to float compute issue we can have some millisecond issue.
  826.     // We don't apply the offset if it's the case.
  827.     if (Math.abs(offset) < 0.001) {
  828.       return;
  829.     }
  830.     // Adjust our accounting of the minimum timestamp.
  831.     streamInfo.minTimestamp += offset;
  833.     // Adjust our accounting of the maximum timestamp.
  834.     streamInfo.maxTimestamp += offset;
  835.     goog.asserts.assert(streamInfo.maxTimestamp >= 0,
  836.         'Negative maxTimestamp after adjustment!');
  838.     // Update our map from sequence number to start time.
  839.     const mediaSequenceToStartTime =
  840.         this.getMediaSequenceToStartTimeFor_(streamInfo);
  841.     for (const [key, value] of mediaSequenceToStartTime) {
  842.       mediaSequenceToStartTime.set(key, value + offset);
  843.     }
  845.     shaka.log.debug('Offset', offset, 'applied to',
  846.         streamInfo.getUris());
  847.   }
  849.   /**
  850.    * Parses the manifest.
  851.    *
  852.    * @param {BufferSource} data
  853.    * @return {!Promise}
  854.    * @private
  855.    */
  856.   async parseManifest_(data) {
  857.     const Utils = shaka.hls.Utils;
  858.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  860.     goog.asserts.assert(this.masterPlaylistUri_,
  861.         'Master playlist URI must be set before calling parseManifest_!');
  863.     const playlist = this.manifestTextParser_.parsePlaylist(data);
  865.     /** @type {!Array<!shaka.hls.Tag>} */
  866.     const variablesTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-DEFINE');
  868.     /** @type {!Array<!shaka.extern.Variant>} */
  869.     let variants = [];
  870.     /** @type {!Array<!shaka.extern.Stream>} */
  871.     let textStreams = [];
  872.     /** @type {!Array<!shaka.extern.Stream>} */
  873.     let imageStreams = [];
  875.     // This assert is our own sanity check.
  876.     goog.asserts.assert(this.presentationTimeline_ == null,
  877.         'Presentation timeline created early!');
  878.     // We don't know if the presentation is VOD or live until we parse at least
  879.     // one media playlist, so make a VOD-style presentation timeline for now
  880.     // and change the type later if we discover this is live.
  881.     // Since the player will load the first variant chosen early in the process,
  882.     // there isn't a window during playback where the live-ness is unknown.
  883.     this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  884.         /* presentationStartTime= */ null, /* delay= */ 0);
  885.     this.presentationTimeline_.setStatic(true);
  887.     const getUris = () => {
  888.       return [this.masterPlaylistUri_];
  889.     };
  891.     /** @type {?string} */
  892.     let mediaPlaylistType = null;
  894.     /** @type {!Map<string, string>} */
  895.     let mediaVariables = new Map();
  897.     // Parsing a media playlist results in a single-variant stream.
  898.     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
  899.       this.needsClosedCaptionsDetection_ = false;
  901.       /** @type {!Array<!shaka.hls.Tag>} */
  902.       const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  903.           'EXT-X-DEFINE');
  905.       mediaVariables = this.parseMediaVariables_(
  906.           variablesTags, this.masterPlaylistUri_);
  908.       // By default we assume it is video, but in a later step the correct type
  909.       // is obtained.
  910.       mediaPlaylistType = ContentType.VIDEO;
  912.       // These values can be obtained later so these default values are good.
  913.       const codecs = '';
  914.       const languageValue = '';
  915.       const channelsCount = null;
  916.       const sampleRate = null;
  917.       const closedCaptions = new Map();
  918.       const spatialAudio = false;
  919.       const characteristics = null;
  920.       const forced = false; // Only relevant for text.
  921.       const primary = true; // This is the only stream!
  922.       const name = 'Media Playlist';
  924.       // Make the stream info, with those values.
  925.       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
  926.           this.globalId_++, mediaVariables, playlist, getUris, codecs,
  927.           mediaPlaylistType, languageValue, primary, name, channelsCount,
  928.           closedCaptions, characteristics, forced, sampleRate, spatialAudio);
  929.       this.uriToStreamInfosMap_.set(this.masterPlaylistUri_, streamInfo);
  932.       if (streamInfo.stream) {
  933.         const qualityInfo =
  934.             shaka.media.QualityObserver.createQualityInfo(streamInfo.stream);
  935.         streamInfo.stream.segmentIndex.forEachTopLevelReference(
  936.             (reference) => {
  937.               if (reference.initSegmentReference) {
  938.                 reference.initSegmentReference.mediaQuality = qualityInfo;
  939.               }
  940.             });
  941.       }
  943.       mediaPlaylistType = streamInfo.stream.type;
  945.       // Wrap the stream from that stream info with a variant.
  946.       variants.push({
  947.         id: 0,
  948.         language: this.getLanguage_(languageValue),
  949.         disabledUntilTime: 0,
  950.         primary: true,
  951.         audio: mediaPlaylistType == 'audio' ? streamInfo.stream : null,
  952.         video: mediaPlaylistType == 'video' ? streamInfo.stream : null,
  953.         bandwidth: streamInfo.stream.bandwidth || 0,
  954.         allowedByApplication: true,
  955.         allowedByKeySystem: true,
  956.         decodingInfos: [],
  957.       });
  958.     } else {
  959.       this.parseMasterVariables_(variablesTags);
  961.       /** @type {!Array<!shaka.hls.Tag>} */
  962.       const mediaTags = Utils.filterTagsByName(
  963.           playlist.tags, 'EXT-X-MEDIA');
  964.       /** @type {!Array<!shaka.hls.Tag>} */
  965.       const variantTags = Utils.filterTagsByName(
  966.           playlist.tags, 'EXT-X-STREAM-INF');
  967.       /** @type {!Array<!shaka.hls.Tag>} */
  968.       const imageTags = Utils.filterTagsByName(
  969.           playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
  970.       /** @type {!Array<!shaka.hls.Tag>} */
  971.       const iFrameTags = Utils.filterTagsByName(
  972.           playlist.tags, 'EXT-X-I-FRAME-STREAM-INF');
  973.       /** @type {!Array<!shaka.hls.Tag>} */
  974.       const sessionKeyTags = Utils.filterTagsByName(
  975.           playlist.tags, 'EXT-X-SESSION-KEY');
  976.       /** @type {!Array<!shaka.hls.Tag>} */
  977.       const sessionDataTags = Utils.filterTagsByName(
  978.           playlist.tags, 'EXT-X-SESSION-DATA');
  979.       /** @type {!Array<!shaka.hls.Tag>} */
  980.       const contentSteeringTags = Utils.filterTagsByName(
  981.           playlist.tags, 'EXT-X-CONTENT-STEERING');
  983.       this.processSessionData_(sessionDataTags);
  984.       await this.processContentSteering_(contentSteeringTags);
  986.       if (!this.config_.ignoreSupplementalCodecs) {
  987.         // Duplicate variant tags with supplementalCodecs
  988.         const newVariantTags = [];
  989.         for (const tag of variantTags) {
  990.           const supplementalCodecsString =
  991.               tag.getAttributeValue('SUPPLEMENTAL-CODECS');
  992.           if (!supplementalCodecsString) {
  993.             continue;
  994.           }
  995.           const supplementalCodecs = supplementalCodecsString.split(/\s*,\s*/)
  996.               .map((codec) => {
  997.                 return codec.split('/')[0];
  998.               });
  999.           const newAttributes = tag.attributes.map((attr) => {
  1000.             const name = attr.name;
  1001.             let value = attr.value;
  1002.             if (name == 'CODECS') {
  1003.               value = supplementalCodecs.join(',');
  1004.               const allCodecs = attr.value.split(',');
  1005.               if (allCodecs.length > 1) {
  1006.                 const audioCodec =
  1007.                     shaka.util.ManifestParserUtils.guessCodecsSafe(
  1008.                         shaka.util.ManifestParserUtils.ContentType.AUDIO,
  1009.                         allCodecs);
  1010.                 if (audioCodec) {
  1011.                   value += ',' + audioCodec;
  1012.                 }
  1013.               }
  1014.             }
  1015.             return new shaka.hls.Attribute(name, value);
  1016.           });
  1017.           newVariantTags.push(
  1018.               new shaka.hls.Tag(tag.id, tag.name, newAttributes, null));
  1019.         }
  1020.         variantTags.push(...newVariantTags);
  1022.         // Duplicate iFrame tags with supplementalCodecs
  1023.         const newIFrameTags = [];
  1024.         for (const tag of iFrameTags) {
  1025.           const supplementalCodecsString =
  1026.               tag.getAttributeValue('SUPPLEMENTAL-CODECS');
  1027.           if (!supplementalCodecsString) {
  1028.             continue;
  1029.           }
  1030.           const supplementalCodecs = supplementalCodecsString.split(/\s*,\s*/)
  1031.               .map((codec) => {
  1032.                 return codec.split('/')[0];
  1033.               });
  1034.           const newAttributes = tag.attributes.map((attr) => {
  1035.             const name = attr.name;
  1036.             let value = attr.value;
  1037.             if (name == 'CODECS') {
  1038.               value = supplementalCodecs.join(',');
  1039.             }
  1040.             return new shaka.hls.Attribute(name, value);
  1041.           });
  1042.           newIFrameTags.push(
  1043.               new shaka.hls.Tag(tag.id, tag.name, newAttributes, null));
  1044.         }
  1045.         iFrameTags.push(...newIFrameTags);
  1046.       }
  1048.       this.parseCodecs_(variantTags);
  1050.       this.parseClosedCaptions_(mediaTags);
  1051.       const iFrameStreams = this.parseIFrames_(iFrameTags);
  1052.       variants = await this.createVariantsForTags_(
  1053.           variantTags, sessionKeyTags, mediaTags, getUris,
  1054.           this.globalVariables_, iFrameStreams);
  1055.       textStreams = this.parseTexts_(mediaTags);
  1056.       imageStreams = await this.parseImages_(imageTags, iFrameTags);
  1057.     }
  1059.     // Make sure that the parser has not been destroyed.
  1060.     if (!this.playerInterface_) {
  1061.       throw new shaka.util.Error(
  1062.           shaka.util.Error.Severity.CRITICAL,
  1063.           shaka.util.Error.Category.PLAYER,
  1064.           shaka.util.Error.Code.OPERATION_ABORTED);
  1065.     }
  1067.     this.determineStartTime_(playlist);
  1069.     // Single-variant streams aren't lazy-loaded, so for them we already have
  1070.     // enough info here to determine the presentation type and duration.
  1071.     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
  1072.       if (this.isLive_()) {
  1073.         this.changePresentationTimelineToLive_(playlist);
  1074.         const delay = this.getUpdatePlaylistDelay_();
  1075.         this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
  1076.       }
  1077.       const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  1078.       this.finalizeStreams_(streamInfos);
  1079.       this.determineDuration_();
  1081.       goog.asserts.assert(mediaPlaylistType,
  1082.           'mediaPlaylistType should be non-null');
  1083.       this.processDateRangeTags_(
  1084.           playlist.tags, mediaPlaylistType, mediaVariables, getUris);
  1085.     }
  1087.     this.manifest_ = {
  1088.       presentationTimeline: this.presentationTimeline_,
  1089.       variants,
  1090.       textStreams,
  1091.       imageStreams,
  1092.       offlineSessionIds: [],
  1093.       sequenceMode: this.config_.hls.sequenceMode,
  1094.       ignoreManifestTimestampsInSegmentsMode:
  1095.         this.config_.hls.ignoreManifestTimestampsInSegmentsMode,
  1096.       type: shaka.media.ManifestParser.HLS,
  1097.       serviceDescription: null,
  1098.       nextUrl: null,
  1099.       periodCount: 1,
  1100.       gapCount: 0,
  1101.       isLowLatency: false,
  1102.       startTime: this.startTime_,
  1103.     };
  1105.     // If there is no 'CODECS' attribute in the manifest and codec guessing is
  1106.     // disabled, we need to create the segment indexes now so that missing info
  1107.     // can be parsed from the media data and added to the stream objects.
  1108.     if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
  1109.       const createIndexes = [];
  1110.       for (const variant of this.manifest_.variants) {
  1111.         if (variant.audio && variant.audio.codecs === '') {
  1112.           createIndexes.push(variant.audio.createSegmentIndex());
  1113.         }
  1114.         if (variant.video && variant.video.codecs === '') {
  1115.           createIndexes.push(variant.video.createSegmentIndex());
  1116.         }
  1117.       }
  1119.       await Promise.all(createIndexes);
  1120.     }
  1122.     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
  1123.   }
  1125.   /**
  1126.    * @param {!Array<!shaka.media.SegmentReference>} segments
  1127.    * @return {!Promise<shaka.media.SegmentUtils.BasicInfo>}
  1128.    * @private
  1129.    */
  1130.   async getBasicInfoFromSegments_(segments) {
  1131.     const HlsParser = shaka.hls.HlsParser;
  1132.     const defaultBasicInfo = shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  1133.         this.config_.hls.mediaPlaylistFullMimeType);
  1134.     if (!segments.length) {
  1135.       return defaultBasicInfo;
  1136.     }
  1137.     const {segment, segmentIndex} = this.getAvailableSegment_(segments);
  1138.     const segmentUris = segment.getUris();
  1139.     const segmentUri = segmentUris[0];
  1140.     const parsedUri = new goog.Uri(segmentUri);
  1141.     const extension = parsedUri.getPath().split('.').pop();
  1142.     const rawMimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_.get(extension);
  1143.     if (rawMimeType) {
  1144.       return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  1145.           rawMimeType);
  1146.     }
  1148.     const basicInfos = await Promise.all([
  1149.       this.getInfoFromSegment_(segment.initSegmentReference, 0),
  1150.       this.getInfoFromSegment_(segment, segmentIndex),
  1151.     ]);
  1152.     const initMimeType = basicInfos[0].mimeType;
  1153.     const contentMimeType = basicInfos[1].mimeType;
  1154.     const initData = basicInfos[0].data;
  1155.     const data = basicInfos[1].data;
  1157.     const validMp4Extensions = [
  1158.       'mp4',
  1159.       'mp4a',
  1160.       'm4s',
  1161.       'm4i',
  1162.       'm4a',
  1163.       'm4f',
  1164.       'cmfa',
  1165.       'mp4v',
  1166.       'm4v',
  1167.       'cmfv',
  1168.       'fmp4',
  1169.     ];
  1170.     const validMp4MimeType = [
  1171.       'audio/mp4',
  1172.       'video/mp4',
  1173.       'video/iso.segment',
  1174.     ];
  1176.     if (shaka.util.TsParser.probe(
  1177.         shaka.util.BufferUtils.toUint8(data))) {
  1178.       const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromTs(
  1179.           data, this.config_.disableAudio, this.config_.disableVideo,
  1180.           this.config_.disableText);
  1181.       if (basicInfo) {
  1182.         return basicInfo;
  1183.       }
  1184.     } else if (validMp4Extensions.includes(extension) ||
  1185.         validMp4MimeType.includes(contentMimeType) ||
  1186.         (initMimeType && validMp4MimeType.includes(initMimeType))) {
  1187.       const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromMp4(
  1188.           initData, data, this.config_.disableText);
  1189.       if (basicInfo) {
  1190.         return basicInfo;
  1191.       }
  1192.     }
  1193.     if (contentMimeType) {
  1194.       return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  1195.           contentMimeType);
  1196.     }
  1197.     if (initMimeType) {
  1198.       return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  1199.           initMimeType);
  1200.     }
  1201.     return defaultBasicInfo;
  1202.   }
  1204.   /**
  1205.    * @param {?shaka.media.AnySegmentReference} segment
  1206.    * @param {number} segmentIndex
  1207.    * @return {!Promise<{mimeType: ?string, data: ?BufferSource}>}
  1208.    * @private
  1209.    */
  1210.   async getInfoFromSegment_(segment, segmentIndex) {
  1211.     if (!segment) {
  1212.       return {mimeType: null, data: null};
  1213.     }
  1214.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  1215.     const segmentRequest = shaka.util.Networking.createSegmentRequest(
  1216.         segment.getUris(), segment.getStartByte(), segment.getEndByte(),
  1217.         this.config_.retryParameters);
  1218.     const type = segment instanceof shaka.media.SegmentReference ?
  1219.       shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT :
  1220.       shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
  1221.     const response = await this.makeNetworkRequest_(
  1222.         segmentRequest, requestType, {type}).promise;
  1223.     let data = response.data;
  1224.     if (segment.aesKey) {
  1225.       data = await shaka.media.SegmentUtils.aesDecrypt(
  1226.           data, segment.aesKey, segmentIndex);
  1227.     }
  1228.     if (segment instanceof shaka.media.SegmentReference) {
  1229.       segment.setSegmentData(data, /* singleUse= */ true);
  1230.     } else {
  1231.       segment.setSegmentData(data);
  1232.     }
  1234.     let mimeType = response.headers['content-type'];
  1235.     if (mimeType) {
  1236.       // Split the MIME type in case the server sent additional parameters.
  1237.       mimeType = mimeType.split(';')[0].toLowerCase();
  1238.     }
  1239.     return {mimeType, data};
  1240.   }
  1242.   /** @private */
  1243.   determineDuration_() {
  1244.     goog.asserts.assert(this.presentationTimeline_,
  1245.         'Presentation timeline not created!');
  1247.     if (this.isLive_()) {
  1248.       // The spec says nothing much about seeking in live content, but Safari's
  1249.       // built-in HLS implementation does not allow it.  Therefore we will set
  1250.       // the availability window equal to the presentation delay.  The player
  1251.       // will be able to buffer ahead three segments, but the seek window will
  1252.       // be zero-sized.
  1253.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  1255.       if (this.presentationType_ == PresentationType.LIVE) {
  1256.         let segmentAvailabilityDuration = this.getLiveDuration_() || 0;
  1258.         // The app can override that with a longer duration, to allow seeking.
  1259.         if (!isNaN(this.config_.availabilityWindowOverride)) {
  1260.           segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
  1261.         }
  1263.         this.presentationTimeline_.setSegmentAvailabilityDuration(
  1264.             segmentAvailabilityDuration);
  1265.       }
  1266.     } else {
  1267.       // Use the minimum duration as the presentation duration.
  1268.       this.presentationTimeline_.setDuration(this.getMinDuration_());
  1269.     }
  1271.     if (!this.presentationTimeline_.isStartTimeLocked()) {
  1272.       for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  1273.         if (!streamInfo.stream.segmentIndex) {
  1274.           continue; // Not active.
  1275.         }
  1276.         if (streamInfo.type != 'audio' && streamInfo.type != 'video') {
  1277.           continue;
  1278.         }
  1279.         const firstReference =
  1280.             streamInfo.stream.segmentIndex.earliestReference();
  1281.         if (firstReference && firstReference.syncTime) {
  1282.           const syncTime = firstReference.syncTime;
  1283.           this.presentationTimeline_.setInitialProgramDateTime(syncTime);
  1284.         }
  1285.       }
  1286.     }
  1288.     // This is the first point where we have a meaningful presentation start
  1289.     // time, and we need to tell PresentationTimeline that so that it can
  1290.     // maintain consistency from here on.
  1291.     this.presentationTimeline_.lockStartTime();
  1293.     // This asserts that the live edge is being calculated from segment times.
  1294.     // For VOD and event streams, this check should still pass.
  1295.     goog.asserts.assert(
  1296.         !this.presentationTimeline_.usingPresentationStartTime(),
  1297.         'We should not be using the presentation start time in HLS!');
  1298.   }
  1300.   /**
  1301.    * Get the variables of each variant tag, and store in a map.
  1302.    * @param {!Array<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1303.    * @private
  1304.    */
  1305.   parseMasterVariables_(tags) {
  1306.     const queryParams = new goog.Uri(this.masterPlaylistUri_).getQueryData();
  1307.     for (const variableTag of tags) {
  1308.       const name = variableTag.getAttributeValue('NAME');
  1309.       const value = variableTag.getAttributeValue('VALUE');
  1310.       const queryParam = variableTag.getAttributeValue('QUERYPARAM');
  1311.       if (name && value) {
  1312.         if (!this.globalVariables_.has(name)) {
  1313.           this.globalVariables_.set(name, value);
  1314.         }
  1315.       }
  1316.       if (queryParam) {
  1317.         const queryParamValue = queryParams.get(queryParam)[0];
  1318.         if (queryParamValue && !this.globalVariables_.has(queryParamValue)) {
  1319.           this.globalVariables_.set(queryParam, queryParamValue);
  1320.         }
  1321.       }
  1322.     }
  1323.   }
  1325.   /**
  1326.    * Get the variables of each variant tag, and store in a map.
  1327.    * @param {!Array<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1328.    * @param {string} uri Media playlist URI.
  1329.    * @return {!Map<string, string>}
  1330.    * @private
  1331.    */
  1332.   parseMediaVariables_(tags, uri) {
  1333.     const queryParams = new goog.Uri(uri).getQueryData();
  1334.     const mediaVariables = new Map();
  1335.     for (const variableTag of tags) {
  1336.       const name = variableTag.getAttributeValue('NAME');
  1337.       const value = variableTag.getAttributeValue('VALUE');
  1338.       const queryParam = variableTag.getAttributeValue('QUERYPARAM');
  1339.       const mediaImport = variableTag.getAttributeValue('IMPORT');
  1340.       if (name && value) {
  1341.         if (!mediaVariables.has(name)) {
  1342.           mediaVariables.set(name, value);
  1343.         }
  1344.       }
  1345.       if (queryParam) {
  1346.         const queryParamValue = queryParams.get(queryParam)[0];
  1347.         if (queryParamValue && !mediaVariables.has(queryParamValue)) {
  1348.           mediaVariables.set(queryParam, queryParamValue);
  1349.         }
  1350.       }
  1351.       if (mediaImport) {
  1352.         const globalValue = this.globalVariables_.get(mediaImport);
  1353.         if (globalValue) {
  1354.           mediaVariables.set(mediaImport, globalValue);
  1355.         }
  1356.       }
  1357.     }
  1358.     return mediaVariables;
  1359.   }
  1361.   /**
  1362.    * Get the codecs of each variant tag, and store in a map from
  1363.    * audio/video/subtitle group id to the codecs array list.
  1364.    * @param {!Array<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1365.    * @private
  1366.    */
  1367.   parseCodecs_(tags) {
  1368.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1370.     for (const variantTag of tags) {
  1371.       const audioGroupId = variantTag.getAttributeValue('AUDIO');
  1372.       const videoGroupId = variantTag.getAttributeValue('VIDEO');
  1373.       const subGroupId = variantTag.getAttributeValue('SUBTITLES');
  1374.       const allCodecs = this.getCodecsForVariantTag_(variantTag);
  1376.       if (subGroupId) {
  1377.         const textCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1378.             ContentType.TEXT, allCodecs);
  1379.         goog.asserts.assert(textCodecs != null, 'Text codecs should be valid.');
  1380.         this.groupIdToCodecsMap_.set(subGroupId, textCodecs);
  1381.         shaka.util.ArrayUtils.remove(allCodecs, textCodecs);
  1382.       }
  1383.       if (audioGroupId) {
  1384.         let codecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1385.             ContentType.AUDIO, allCodecs);
  1386.         if (!codecs) {
  1387.           codecs = this.config_.hls.defaultAudioCodec;
  1388.         }
  1389.         this.groupIdToCodecsMap_.set(audioGroupId, codecs);
  1390.       }
  1391.       if (videoGroupId) {
  1392.         let codecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1393.             ContentType.VIDEO, allCodecs);
  1394.         if (!codecs) {
  1395.           codecs = this.config_.hls.defaultVideoCodec;
  1396.         }
  1397.         this.groupIdToCodecsMap_.set(videoGroupId, codecs);
  1398.       }
  1399.     }
  1400.   }
  1402.   /**
  1403.    * Process EXT-X-SESSION-DATA tags.
  1404.    *
  1405.    * @param {!Array<!shaka.hls.Tag>} tags
  1406.    * @private
  1407.    */
  1408.   processSessionData_(tags) {
  1409.     for (const tag of tags) {
  1410.       const id = tag.getAttributeValue('DATA-ID');
  1411.       const uri = tag.getAttributeValue('URI');
  1412.       const language = tag.getAttributeValue('LANGUAGE');
  1413.       const value = tag.getAttributeValue('VALUE');
  1414.       const data = (new Map()).set('id', id);
  1415.       if (uri) {
  1416.         data.set('uri', shaka.hls.Utils.constructSegmentUris(
  1417.             [this.masterPlaylistUri_], uri, this.globalVariables_)[0]);
  1418.       }
  1419.       if (language) {
  1420.         data.set('language', language);
  1421.       }
  1422.       if (value) {
  1423.         data.set('value', value);
  1424.       }
  1425.       const event = new shaka.util.FakeEvent('sessiondata', data);
  1426.       if (this.playerInterface_) {
  1427.         this.playerInterface_.onEvent(event);
  1428.       }
  1429.     }
  1430.   }
  1432.   /**
  1433.    * Process EXT-X-CONTENT-STEERING tags.
  1434.    *
  1435.    * @param {!Array<!shaka.hls.Tag>} tags
  1436.    * @return {!Promise}
  1437.    * @private
  1438.    */
  1439.   async processContentSteering_(tags) {
  1440.     if (!this.playerInterface_ || !this.config_) {
  1441.       return;
  1442.     }
  1443.     let contentSteeringPromise;
  1444.     for (const tag of tags) {
  1445.       const defaultPathwayId = tag.getAttributeValue('PATHWAY-ID');
  1446.       const uri = tag.getAttributeValue('SERVER-URI');
  1447.       if (!defaultPathwayId || !uri) {
  1448.         continue;
  1449.       }
  1450.       this.contentSteeringManager_ =
  1451.             new shaka.util.ContentSteeringManager(this.playerInterface_);
  1452.       this.contentSteeringManager_.configure(this.config_);
  1453.       this.contentSteeringManager_.setBaseUris([this.masterPlaylistUri_]);
  1454.       this.contentSteeringManager_.setManifestType(
  1455.           shaka.media.ManifestParser.HLS);
  1456.       this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
  1457.       contentSteeringPromise =
  1458.           this.contentSteeringManager_.requestInfo(uri);
  1459.       break;
  1460.     }
  1461.     await contentSteeringPromise;
  1462.   }
  1464.   /**
  1465.    * Parse Subtitles and Closed Captions from 'EXT-X-MEDIA' tags.
  1466.    * Create text streams for Subtitles, but not Closed Captions.
  1467.    *
  1468.    * @param {!Array<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
  1469.    * @return {!Array<!shaka.extern.Stream>}
  1470.    * @private
  1471.    */
  1472.   parseTexts_(mediaTags) {
  1473.     // Create text stream for each Subtitle media tag.
  1474.     const subtitleTags =
  1475.         shaka.hls.Utils.filterTagsByType(mediaTags, 'SUBTITLES');
  1476.     const textStreams = subtitleTags.map((tag) => {
  1477.       const disableText = this.config_.disableText;
  1478.       if (disableText) {
  1479.         return null;
  1480.       }
  1481.       try {
  1482.         return this.createStreamInfoFromMediaTags_([tag], new Map()).stream;
  1483.       } catch (e) {
  1484.         if (this.config_.hls.ignoreTextStreamFailures) {
  1485.           return null;
  1486.         }
  1487.         throw e;
  1488.       }
  1489.     });
  1491.     const type = shaka.util.ManifestParserUtils.ContentType.TEXT;
  1493.     // Set the codecs for text streams.
  1494.     for (const tag of subtitleTags) {
  1495.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1496.       const codecs = this.groupIdToCodecsMap_.get(groupId);
  1497.       if (codecs) {
  1498.         const textStreamInfos = this.groupIdToStreamInfosMap_.get(groupId);
  1499.         if (textStreamInfos) {
  1500.           for (const textStreamInfo of textStreamInfos) {
  1501.             textStreamInfo.stream.codecs = codecs;
  1502.             textStreamInfo.stream.mimeType =
  1503.                 this.guessMimeTypeBeforeLoading_(type, codecs) ||
  1504.                 this.guessMimeTypeFallback_(type);
  1505.             this.setFullTypeForStream_(textStreamInfo.stream);
  1506.           }
  1507.         }
  1508.       }
  1509.     }
  1511.     // Do not create text streams for Closed captions.
  1512.     return textStreams.filter((s) => s);
  1513.   }
  1515.   /**
  1516.    * @param {!shaka.extern.Stream} stream
  1517.    * @private
  1518.    */
  1519.   setFullTypeForStream_(stream) {
  1520.     const combinations = new Set([shaka.util.MimeUtils.getFullType(
  1521.         stream.mimeType, stream.codecs)]);
  1522.     if (stream.segmentIndex) {
  1523.       stream.segmentIndex.forEachTopLevelReference((reference) => {
  1524.         if (reference.mimeType) {
  1525.           combinations.add(shaka.util.MimeUtils.getFullType(
  1526.               reference.mimeType, stream.codecs));
  1527.         }
  1528.       });
  1529.     }
  1530.     stream.fullMimeTypes = combinations;
  1531.   }
  1533.   /**
  1534.    * @param {!Array<!shaka.hls.Tag>} imageTags from the playlist.
  1535.    * @param {!Array<!shaka.hls.Tag>} iFrameTags from the playlist.
  1536.    * @return {!Promise<!Array<!shaka.extern.Stream>>}
  1537.    * @private
  1538.    */
  1539.   async parseImages_(imageTags, iFrameTags) {
  1540.     // Create image stream for each image tag.
  1541.     const imageStreamPromises = imageTags.map(async (tag) => {
  1542.       const disableThumbnails = this.config_.disableThumbnails;
  1543.       if (disableThumbnails) {
  1544.         return null;
  1545.       }
  1546.       try {
  1547.         const streamInfo = await this.createStreamInfoFromImageTag_(tag);
  1548.         return streamInfo.stream;
  1549.       } catch (e) {
  1550.         if (this.config_.hls.ignoreImageStreamFailures) {
  1551.           return null;
  1552.         }
  1553.         throw e;
  1554.       }
  1555.     }).concat(iFrameTags.map((tag) => {
  1556.       const disableThumbnails = this.config_.disableThumbnails;
  1557.       if (disableThumbnails) {
  1558.         return null;
  1559.       }
  1560.       try {
  1561.         const streamInfo = this.createStreamInfoFromIframeTag_(tag);
  1562.         const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1563.         if (streamInfo.stream.type !== ContentType.IMAGE) {
  1564.           return null;
  1565.         }
  1566.         return streamInfo.stream;
  1567.       } catch (e) {
  1568.         if (this.config_.hls.ignoreImageStreamFailures) {
  1569.           return null;
  1570.         }
  1571.         throw e;
  1572.       }
  1573.     }));
  1574.     const imageStreams = await Promise.all(imageStreamPromises);
  1575.     return imageStreams.filter((s) => s);
  1576.   }
  1578.   /**
  1579.    * @param {!Array<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
  1580.    * @param {!Map<string, string>} groupIdPathwayIdMapping
  1581.    * @private
  1582.    */
  1583.   createStreamInfosFromMediaTags_(mediaTags, groupIdPathwayIdMapping) {
  1584.     // Filter out subtitles and media tags without uri (except audio).
  1585.     mediaTags = mediaTags.filter((tag) => {
  1586.       const uri = tag.getAttributeValue('URI') || '';
  1587.       const type = tag.getAttributeValue('TYPE');
  1588.       return type != 'SUBTITLES' && (uri != '' || type == 'AUDIO');
  1589.     });
  1591.     const groupedTags = {};
  1592.     for (const tag of mediaTags) {
  1593.       const key = tag.getTagKey(!this.contentSteeringManager_);
  1594.       if (!groupedTags[key]) {
  1595.         groupedTags[key] = [tag];
  1596.       } else {
  1597.         groupedTags[key].push(tag);
  1598.       }
  1599.     }
  1601.     for (const key in groupedTags) {
  1602.       // Create stream info for each audio / video media grouped tag.
  1603.       this.createStreamInfoFromMediaTags_(
  1604.           groupedTags[key], groupIdPathwayIdMapping, /* requireUri= */ false);
  1605.     }
  1606.   }
  1608.   /**
  1609.    * @param {!Array<!shaka.hls.Tag>} iFrameTags from the playlist.
  1610.    * @return {!Array<!shaka.extern.Stream>}
  1611.    * @private
  1612.    */
  1613.   parseIFrames_(iFrameTags) {
  1614.     // Create iFrame stream for each iFrame tag.
  1615.     const iFrameStreams = iFrameTags.map((tag) => {
  1616.       const streamInfo = this.createStreamInfoFromIframeTag_(tag);
  1617.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1618.       if (streamInfo.stream.type !== ContentType.VIDEO) {
  1619.         return null;
  1620.       }
  1621.       return streamInfo.stream;
  1622.     });
  1624.     // Filter mjpg iFrames
  1625.     return iFrameStreams.filter((s) => s);
  1626.   }
  1628.   /**
  1629.    * @param {!Array<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1630.    * @param {!Array<!shaka.hls.Tag>} sessionKeyTags EXT-X-SESSION-KEY tags
  1631.    * from the playlist.
  1632.    * @param {!Array<!shaka.hls.Tag>} mediaTags EXT-X-MEDIA tags from the
  1633.    * playlist.
  1634.    * @param {function(): !Array<string>} getUris
  1635.    * @param {?Map<string, string>} variables
  1636.    * @param {!Array<!shaka.extern.Stream>} iFrameStreams
  1637.    * @return {!Promise<!Array<!shaka.extern.Variant>>}
  1638.    * @private
  1639.    */
  1640.   async createVariantsForTags_(tags, sessionKeyTags, mediaTags, getUris,
  1641.       variables, iFrameStreams) {
  1642.     // EXT-X-SESSION-KEY processing
  1643.     const drmInfos = [];
  1644.     const keyIds = new Set();
  1645.     if (!this.config_.ignoreDrmInfo && sessionKeyTags.length > 0) {
  1646.       for (const drmTag of sessionKeyTags) {
  1647.         const method = drmTag.getRequiredAttrValue('METHOD');
  1648.         // According to the HLS spec, KEYFORMAT is optional and implicitly
  1649.         // defaults to "identity".
  1650.         // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
  1651.         const keyFormat =
  1652.             drmTag.getAttributeValue('KEYFORMAT') || 'identity';
  1653.         let drmInfo = null;
  1654.         if (method == 'NONE') {
  1655.           continue;
  1656.         } else if (this.isAesMethod_(method)) {
  1657.           const keyUris = shaka.hls.Utils.constructSegmentUris(
  1658.               getUris(), drmTag.getRequiredAttrValue('URI'), variables);
  1659.           const keyMapKey = keyUris.sort().join('');
  1660.           if (!this.aesKeyMap_.has(keyMapKey)) {
  1661.             const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  1662.             const request = shaka.net.NetworkingEngine.makeRequest(
  1663.                 keyUris, this.config_.retryParameters);
  1664.             const keyResponse = this.makeNetworkRequest_(request, requestType)
  1665.                 .promise;
  1666.             this.aesKeyMap_.set(keyMapKey, keyResponse);
  1667.           }
  1668.           continue;
  1669.         } else if (keyFormat == 'identity') {
  1670.           // eslint-disable-next-line no-await-in-loop
  1671.           drmInfo = await this.identityDrmParser_(
  1672.               drmTag, /* mimeType= */ '', getUris,
  1673.               /* initSegmentRef= */ null, variables);
  1674.         } else {
  1675.           const drmParser =
  1676.               this.keyFormatsToDrmParsers_.get(keyFormat);
  1678.           drmInfo = drmParser ?
  1679.             // eslint-disable-next-line no-await-in-loop
  1680.             await drmParser(drmTag, /* mimeType= */ '',
  1681.                 /* initSegmentRef= */ null) : null;
  1682.         }
  1683.         if (drmInfo) {
  1684.           if (drmInfo.keyIds) {
  1685.             for (const keyId of drmInfo.keyIds) {
  1686.               keyIds.add(keyId);
  1687.             }
  1688.           }
  1689.           drmInfos.push(drmInfo);
  1690.         } else {
  1691.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  1692.         }
  1693.       }
  1694.     }
  1696.     const groupedTags = {};
  1697.     for (const tag of tags) {
  1698.       const key = tag.getTagKey(!this.contentSteeringManager_);
  1699.       if (!groupedTags[key]) {
  1700.         groupedTags[key] = [tag];
  1701.       } else {
  1702.         groupedTags[key].push(tag);
  1703.       }
  1704.     }
  1706.     const allVariants = [];
  1707.     // Create variants for each group of variant tag.
  1708.     for (const key in groupedTags) {
  1709.       const tags = groupedTags[key];
  1710.       const firstTag = tags[0];
  1712.       const frameRate = firstTag.getAttributeValue('FRAME-RATE');
  1713.       const bandwidth =
  1714.           Number(firstTag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
  1715.           Number(firstTag.getRequiredAttrValue('BANDWIDTH'));
  1717.       const resolution = firstTag.getAttributeValue('RESOLUTION');
  1718.       const [width, height] = resolution ? resolution.split('x') : [null, null];
  1720.       const videoRange = firstTag.getAttributeValue('VIDEO-RANGE');
  1722.       let videoLayout = firstTag.getAttributeValue('REQ-VIDEO-LAYOUT');
  1723.       if (videoLayout && videoLayout.includes(',')) {
  1724.         // If multiple video layout strings are present, pick the first valid
  1725.         // one.
  1726.         const layoutStrings = videoLayout.split(',').filter((layoutString) => {
  1727.           return layoutString == 'CH-STEREO' || layoutString == 'CH-MONO';
  1728.         });
  1729.         videoLayout = layoutStrings[0];
  1730.       }
  1731.       // According to the HLS spec:
  1732.       // By default a video variant is monoscopic, so an attribute
  1733.       // consisting entirely of REQ-VIDEO-LAYOUT="CH-MONO" is unnecessary
  1734.       // and SHOULD NOT be present.
  1735.       videoLayout = videoLayout || 'CH-MONO';
  1737.       const streamInfos = this.createStreamInfosForVariantTags_(tags,
  1738.           mediaTags, resolution, frameRate);
  1740.       goog.asserts.assert(streamInfos.audio.length ||
  1741.           streamInfos.video.length, 'We should have created a stream!');
  1743.       allVariants.push(...this.createVariants_(
  1744.           streamInfos.audio,
  1745.           streamInfos.video,
  1746.           bandwidth,
  1747.           width,
  1748.           height,
  1749.           frameRate,
  1750.           videoRange,
  1751.           videoLayout,
  1752.           drmInfos,
  1753.           keyIds,
  1754.           iFrameStreams));
  1755.     }
  1756.     return allVariants.filter((variant) => variant != null);
  1757.   }
  1759.   /**
  1760.    * Create audio and video streamInfos from an 'EXT-X-STREAM-INF' tag and its
  1761.    * related media tags.
  1762.    *
  1763.    * @param {!Array<!shaka.hls.Tag>} tags
  1764.    * @param {!Array<!shaka.hls.Tag>} mediaTags
  1765.    * @param {?string} resolution
  1766.    * @param {?string} frameRate
  1767.    * @return {!shaka.hls.HlsParser.StreamInfos}
  1768.    * @private
  1769.    */
  1770.   createStreamInfosForVariantTags_(tags, mediaTags, resolution, frameRate) {
  1771.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1773.     /** @type {shaka.hls.HlsParser.StreamInfos} */
  1774.     const res = {
  1775.       audio: [],
  1776.       video: [],
  1777.     };
  1778.     const groupIdPathwayIdMapping = new Map();
  1779.     const globalGroupIds = [];
  1780.     let isAudioGroup = false;
  1781.     let isVideoGroup = false;
  1782.     for (const tag of tags) {
  1783.       const audioGroupId = tag.getAttributeValue('AUDIO');
  1784.       const videoGroupId = tag.getAttributeValue('VIDEO');
  1785.       goog.asserts.assert(audioGroupId == null || videoGroupId == null,
  1786.           'Unexpected: both video and audio described by media tags!');
  1788.       const groupId = audioGroupId || videoGroupId;
  1789.       if (!groupId) {
  1790.         continue;
  1791.       }
  1792.       if (!globalGroupIds.includes(groupId)) {
  1793.         globalGroupIds.push(groupId);
  1794.       }
  1795.       const pathwayId = tag.getAttributeValue('PATHWAY-ID');
  1796.       if (pathwayId) {
  1797.         groupIdPathwayIdMapping.set(groupId, pathwayId);
  1798.       }
  1799.       if (audioGroupId) {
  1800.         isAudioGroup = true;
  1801.       } else if (videoGroupId) {
  1802.         isVideoGroup = true;
  1803.       }
  1804.       // Make an educated guess about the stream type.
  1805.       shaka.log.debug('Guessing stream type for', tag.toString());
  1806.     }
  1807.     if (globalGroupIds.length && mediaTags.length) {
  1808.       const mediaTagsForVariant = mediaTags.filter((tag) => {
  1809.         return globalGroupIds.includes(tag.getRequiredAttrValue('GROUP-ID'));
  1810.       });
  1811.       this.createStreamInfosFromMediaTags_(
  1812.           mediaTagsForVariant, groupIdPathwayIdMapping);
  1813.     }
  1814.     const globalGroupId = globalGroupIds.sort().join(',');
  1815.     const streamInfos =
  1816.         (globalGroupId && this.groupIdToStreamInfosMap_.has(globalGroupId)) ?
  1817.         this.groupIdToStreamInfosMap_.get(globalGroupId) : [];
  1818.     if (isAudioGroup) {
  1819.       res.audio.push(...streamInfos);
  1820.     } else if (isVideoGroup) {
  1821.       res.video.push(...streamInfos);
  1822.     }
  1824.     let type;
  1825.     let ignoreStream = false;
  1827.     // The Microsoft HLS manifest generators will make audio-only variants
  1828.     // that link to their URI both directly and through an audio tag.
  1829.     // In that case, ignore the local URI and use the version in the
  1830.     // AUDIO tag, so you inherit its language.
  1831.     // As an example, see the manifest linked in issue #860.
  1832.     const allStreamUris = tags.map((tag) => tag.getRequiredAttrValue('URI'));
  1833.     const hasSameUri = res.audio.find((audio) => {
  1834.       return audio && audio.getUris().find((uri) => {
  1835.         return allStreamUris.includes(uri);
  1836.       });
  1837.     });
  1839.     /** @type {!Array<string>} */
  1840.     let allCodecs = this.getCodecsForVariantTag_(tags[0]);
  1841.     const videoCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1842.         ContentType.VIDEO, allCodecs);
  1843.     const audioCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1844.         ContentType.AUDIO, allCodecs);
  1846.     if (audioCodecs && !videoCodecs) {
  1847.       // There are no associated media tags, and there's only audio codec,
  1848.       // and no video codec, so it should be audio.
  1849.       type = ContentType.AUDIO;
  1850.       shaka.log.debug('Guessing audio-only.');
  1851.       ignoreStream = res.audio.length > 0;
  1852.     } else if (!res.audio.length && !res.video.length &&
  1853.         audioCodecs && videoCodecs) {
  1854.       // There are both audio and video codecs, so assume multiplexed content.
  1855.       // Note that the default used when CODECS is missing assumes multiple
  1856.       // (and therefore multiplexed).
  1857.       // Recombine the codec strings into one so that MediaSource isn't
  1858.       // lied to later. (That would trigger an error in Chrome.)
  1859.       shaka.log.debug('Guessing multiplexed audio+video.');
  1860.       type = ContentType.VIDEO;
  1861.       allCodecs = [[videoCodecs, audioCodecs].join(',')];
  1862.     } else if (res.audio.length && hasSameUri) {
  1863.       shaka.log.debug('Guessing audio-only.');
  1864.       type = ContentType.AUDIO;
  1865.       ignoreStream = true;
  1866.     } else if (res.video.length && !res.audio.length) {
  1867.       // There are associated video streams.  Assume this is audio.
  1868.       shaka.log.debug('Guessing audio-only.');
  1869.       type = ContentType.AUDIO;
  1870.     } else {
  1871.       shaka.log.debug('Guessing video-only.');
  1872.       type = ContentType.VIDEO;
  1873.     }
  1875.     if (!ignoreStream) {
  1876.       const streamInfo =
  1877.           this.createStreamInfoFromVariantTags_(tags, allCodecs, type);
  1878.       if (globalGroupId) {
  1879.         streamInfo.stream.groupId = globalGroupId;
  1880.       }
  1881.       res[streamInfo.stream.type] = [streamInfo];
  1882.     }
  1883.     return res;
  1884.   }
  1887.   /**
  1888.    * Get the codecs from the 'EXT-X-STREAM-INF' tag.
  1889.    *
  1890.    * @param {!shaka.hls.Tag} tag
  1891.    * @return {!Array<string>} codecs
  1892.    * @private
  1893.    */
  1894.   getCodecsForVariantTag_(tag) {
  1895.     let codecsString = tag.getAttributeValue('CODECS') || '';
  1897.     this.codecInfoInManifest_ = codecsString.length > 0;
  1899.     if (!this.codecInfoInManifest_ && !this.config_.hls.disableCodecGuessing) {
  1900.       // These are the default codecs to assume if none are specified.
  1901.       const defaultCodecsArray = [];
  1903.       if (!this.config_.disableVideo) {
  1904.         defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
  1905.       }
  1906.       if (!this.config_.disableAudio) {
  1907.         defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
  1908.       }
  1910.       codecsString = defaultCodecsArray.join(',');
  1911.     }
  1913.     // Strip out internal whitespace while splitting on commas:
  1914.     /** @type {!Array<string>} */
  1915.     const codecs = codecsString.split(/\s*,\s*/);
  1917.     return shaka.media.SegmentUtils.codecsFiltering(codecs);
  1918.   }
  1920.   /**
  1921.    * Get the channel count information for an HLS audio track.
  1922.    * CHANNELS specifies an ordered, "/" separated list of parameters.
  1923.    * If the type is audio, the first parameter will be a decimal integer
  1924.    * specifying the number of independent, simultaneous audio channels.
  1925.    * No other channels parameters are currently defined.
  1926.    *
  1927.    * @param {!shaka.hls.Tag} tag
  1928.    * @return {?number}
  1929.    * @private
  1930.    */
  1931.   getChannelsCount_(tag) {
  1932.     const channels = tag.getAttributeValue('CHANNELS');
  1933.     if (!channels) {
  1934.       return null;
  1935.     }
  1936.     const channelCountString = channels.split('/')[0];
  1937.     const count = parseInt(channelCountString, 10);
  1938.     return count;
  1939.   }
  1941.   /**
  1942.    * Get the sample rate information for an HLS audio track.
  1943.    *
  1944.    * @param {!shaka.hls.Tag} tag
  1945.    * @return {?number}
  1946.    * @private
  1947.    */
  1948.   getSampleRate_(tag) {
  1949.     const sampleRate = tag.getAttributeValue('SAMPLE-RATE');
  1950.     if (!sampleRate) {
  1951.       return null;
  1952.     }
  1953.     return parseInt(sampleRate, 10);
  1954.   }
  1956.   /**
  1957.    * Get the spatial audio information for an HLS audio track.
  1958.    * In HLS the channels field indicates the number of audio channels that the
  1959.    * stream has (eg: 2). In the case of Dolby Atmos (EAC-3), the complexity is
  1960.    * expressed with the number of channels followed by the word JOC
  1961.    * (eg: 16/JOC), so 16 would be the number of channels (eg: 7.3.6 layout),
  1962.    * and JOC indicates that the stream has spatial audio. For Dolby AC-4 ATMOS,
  1963.    * it's necessary search ATMOS word.
  1964.    * @see https://developer.apple.com/documentation/http-live-streaming/hls-authoring-specification-for-apple-devices-appendixes
  1965.    * @see https://ott.dolby.com/OnDelKits/AC-4/Dolby_AC-4_Online_Delivery_Kit_1.5/Documentation/Specs/AC4_HLS/help_files/topics/hls_playlist_c_codec_indication_ims.html
  1966.    *
  1967.    * @param {!shaka.hls.Tag} tag
  1968.    * @return {boolean}
  1969.    * @private
  1970.    */
  1971.   isSpatialAudio_(tag) {
  1972.     const channels = tag.getAttributeValue('CHANNELS');
  1973.     if (!channels) {
  1974.       return false;
  1975.     }
  1976.     const channelsParts = channels.split('/');
  1977.     if (channelsParts.length != 2) {
  1978.       return false;
  1979.     }
  1980.     return channelsParts[1] === 'JOC' || channelsParts[1].includes('ATMOS');
  1981.   }
  1983.   /**
  1984.    * Get the closed captions map information for the EXT-X-STREAM-INF tag, to
  1985.    * create the stream info.
  1986.    * @param {!shaka.hls.Tag} tag
  1987.    * @param {string} type
  1988.    * @return {Map<string, string>} closedCaptions
  1989.    * @private
  1990.    */
  1991.   getClosedCaptions_(tag, type) {
  1992.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1993.     // The attribute of closed captions is optional, and the value may be
  1994.     // 'NONE'.
  1995.     const closedCaptionsAttr = tag.getAttributeValue('CLOSED-CAPTIONS');
  1997.     // EXT-X-STREAM-INF tags may have CLOSED-CAPTIONS attributes.
  1998.     // The value can be either a quoted-string or an enumerated-string with
  1999.     // the value NONE. If the value is a quoted-string, it MUST match the
  2000.     // value of the GROUP-ID attribute of an EXT-X-MEDIA tag elsewhere in the
  2001.     // Playlist whose TYPE attribute is CLOSED-CAPTIONS.
  2002.     if (type == ContentType.VIDEO ) {
  2003.       if (this.config_.disableText) {
  2004.         this.needsClosedCaptionsDetection_ = false;
  2005.         return null;
  2006.       }
  2007.       if (closedCaptionsAttr) {
  2008.         if (closedCaptionsAttr != 'NONE') {
  2009.           return this.groupIdToClosedCaptionsMap_.get(closedCaptionsAttr);
  2010.         }
  2011.         this.needsClosedCaptionsDetection_ = false;
  2012.       } else if (!closedCaptionsAttr && this.groupIdToClosedCaptionsMap_.size) {
  2013.         for (const key of this.groupIdToClosedCaptionsMap_.keys()) {
  2014.           return this.groupIdToClosedCaptionsMap_.get(key);
  2015.         }
  2016.       }
  2017.     }
  2018.     return null;
  2019.   }
  2021.   /**
  2022.    * Get the normalized language value.
  2023.    *
  2024.    * @param {?string} languageValue
  2025.    * @return {string}
  2026.    * @private
  2027.    */
  2028.   getLanguage_(languageValue) {
  2029.     const LanguageUtils = shaka.util.LanguageUtils;
  2030.     return LanguageUtils.normalize(languageValue || 'und');
  2031.   }
  2033.   /**
  2034.    * Get the type value.
  2035.    * Shaka recognizes the content types 'audio', 'video', 'text', and 'image'.
  2036.    * The HLS 'subtitles' type needs to be mapped to 'text'.
  2037.    * @param {!shaka.hls.Tag} tag
  2038.    * @return {string}
  2039.    * @private
  2040.    */
  2041.   getType_(tag) {
  2042.     let type = tag.getRequiredAttrValue('TYPE').toLowerCase();
  2043.     if (type == 'subtitles') {
  2044.       type = shaka.util.ManifestParserUtils.ContentType.TEXT;
  2045.     }
  2046.     return type;
  2047.   }
  2049.   /**
  2050.    * @param {!Array<shaka.hls.HlsParser.StreamInfo>} audioInfos
  2051.    * @param {!Array<shaka.hls.HlsParser.StreamInfo>} videoInfos
  2052.    * @param {number} bandwidth
  2053.    * @param {?string} width
  2054.    * @param {?string} height
  2055.    * @param {?string} frameRate
  2056.    * @param {?string} videoRange
  2057.    * @param {?string} videoLayout
  2058.    * @param {!Array<shaka.extern.DrmInfo>} drmInfos
  2059.    * @param {!Set<string>} keyIds
  2060.    * @param {!Array<!shaka.extern.Stream>} iFrameStreams
  2061.    * @return {!Array<!shaka.extern.Variant>}
  2062.    * @private
  2063.    */
  2064.   createVariants_(
  2065.       audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange,
  2066.       videoLayout, drmInfos, keyIds, iFrameStreams) {
  2067.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2068.     const DrmUtils = shaka.drm.DrmUtils;
  2070.     for (const info of videoInfos) {
  2071.       this.addVideoAttributes_(
  2072.           info.stream, width, height, frameRate, videoRange, videoLayout,
  2073.           /** colorGamut= */ null);
  2074.     }
  2076.     // In case of audio-only or video-only content or the audio/video is
  2077.     // disabled by the config, we create an array of one item containing
  2078.     // a null. This way, the double-loop works for all kinds of content.
  2079.     // NOTE: we currently don't have support for audio-only content.
  2080.     const disableAudio = this.config_.disableAudio;
  2081.     if (!audioInfos.length || disableAudio) {
  2082.       audioInfos = [null];
  2083.     }
  2084.     const disableVideo = this.config_.disableVideo;
  2085.     if (!videoInfos.length || disableVideo) {
  2086.       videoInfos = [null];
  2087.     }
  2089.     const variants = [];
  2090.     for (const audioInfo of audioInfos) {
  2091.       for (const videoInfo of videoInfos) {
  2092.         const audioStream = audioInfo ? audioInfo.stream : null;
  2093.         if (audioStream) {
  2094.           audioStream.drmInfos = drmInfos;
  2095.           audioStream.keyIds = keyIds;
  2096.         }
  2097.         const videoStream = videoInfo ? videoInfo.stream : null;
  2098.         if (videoStream) {
  2099.           videoStream.drmInfos = drmInfos;
  2100.           videoStream.keyIds = keyIds;
  2101.           if (!this.config_.disableIFrames) {
  2102.             shaka.util.StreamUtils.setBetterIFrameStream(
  2103.                 videoStream, iFrameStreams);
  2104.           }
  2105.         }
  2106.         if (videoStream && !audioStream) {
  2107.           videoStream.bandwidth = bandwidth;
  2108.         }
  2109.         if (!videoStream && audioStream) {
  2110.           audioStream.bandwidth = bandwidth;
  2111.         }
  2112.         const audioDrmInfos = audioInfo ? audioInfo.stream.drmInfos : null;
  2113.         const videoDrmInfos = videoInfo ? videoInfo.stream.drmInfos : null;
  2114.         const videoStreamUri =
  2115.             videoInfo ? videoInfo.getUris().sort().join(',') : '';
  2116.         const audioStreamUri =
  2117.             audioInfo ? audioInfo.getUris().sort().join(',') : '';
  2118.         const codecs = [];
  2119.         if (audioStream && audioStream.codecs) {
  2120.           codecs.push(audioStream.codecs);
  2121.         }
  2122.         if (videoStream && videoStream.codecs) {
  2123.           codecs.push(videoStream.codecs);
  2124.         }
  2125.         const variantUriKey = [
  2126.           videoStreamUri,
  2127.           audioStreamUri,
  2128.           codecs.sort(),
  2129.         ].join('-');
  2131.         if (audioStream && videoStream) {
  2132.           if (!DrmUtils.areDrmCompatible(audioDrmInfos, videoDrmInfos)) {
  2133.             shaka.log.warning(
  2134.                 'Incompatible DRM info in HLS variant.  Skipping.');
  2135.             continue;
  2136.           }
  2137.         }
  2139.         if (this.variantUriSet_.has(variantUriKey)) {
  2140.           // This happens when two variants only differ in their text streams.
  2141.           shaka.log.debug(
  2142.               'Skipping variant which only differs in text streams.');
  2143.           continue;
  2144.         }
  2146.         // Since both audio and video are of the same type, this assertion will
  2147.         // catch certain mistakes at runtime that the compiler would miss.
  2148.         goog.asserts.assert(!audioStream ||
  2149.             audioStream.type == ContentType.AUDIO, 'Audio parameter mismatch!');
  2150.         goog.asserts.assert(!videoStream ||
  2151.             videoStream.type == ContentType.VIDEO, 'Video parameter mismatch!');
  2153.         const variant = {
  2154.           id: this.globalId_++,
  2155.           language: audioStream ? audioStream.language : 'und',
  2156.           disabledUntilTime: 0,
  2157.           primary: (!!audioStream && audioStream.primary) ||
  2158.               (!!videoStream && videoStream.primary),
  2159.           audio: audioStream,
  2160.           video: videoStream,
  2161.           bandwidth,
  2162.           allowedByApplication: true,
  2163.           allowedByKeySystem: true,
  2164.           decodingInfos: [],
  2165.         };
  2167.         variants.push(variant);
  2168.         this.variantUriSet_.add(variantUriKey);
  2169.       }
  2170.     }
  2171.     return variants;
  2172.   }
  2174.   /**
  2175.    * Parses an array of EXT-X-MEDIA tags, then stores the values of all tags
  2176.    * with TYPE="CLOSED-CAPTIONS" into a map of group id to closed captions.
  2177.    *
  2178.    * @param {!Array<!shaka.hls.Tag>} mediaTags
  2179.    * @private
  2180.    */
  2181.   parseClosedCaptions_(mediaTags) {
  2182.     const closedCaptionsTags =
  2183.         shaka.hls.Utils.filterTagsByType(mediaTags, 'CLOSED-CAPTIONS');
  2184.     this.needsClosedCaptionsDetection_ = closedCaptionsTags.length == 0;
  2185.     for (const tag of closedCaptionsTags) {
  2186.       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  2187.           'Should only be called on media tags!');
  2188.       const languageValue = tag.getAttributeValue('LANGUAGE');
  2189.       let language = this.getLanguage_(languageValue);
  2190.       if (!languageValue) {
  2191.         const nameValue = tag.getAttributeValue('NAME');
  2192.         if (nameValue) {
  2193.           language = nameValue;
  2194.         }
  2195.       }
  2197.       // The GROUP-ID value is a quoted-string that specifies the group to which
  2198.       // the Rendition belongs.
  2199.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  2201.       // The value of INSTREAM-ID is a quoted-string that specifies a Rendition
  2202.       // within the segments in the Media Playlist. This attribute is REQUIRED
  2203.       // if the TYPE attribute is CLOSED-CAPTIONS.
  2204.       // We need replace SERVICE string by our internal svc string.
  2205.       const instreamId = tag.getRequiredAttrValue('INSTREAM-ID')
  2206.           .replace('SERVICE', 'svc');
  2207.       if (!this.groupIdToClosedCaptionsMap_.get(groupId)) {
  2208.         this.groupIdToClosedCaptionsMap_.set(groupId, new Map());
  2209.       }
  2210.       this.groupIdToClosedCaptionsMap_.get(groupId).set(instreamId, language);
  2211.     }
  2212.   }
  2214.   /**
  2215.    * Parse EXT-X-MEDIA media tag into a Stream object.
  2216.    *
  2217.    * @param {!Array<!shaka.hls.Tag>} tags
  2218.    * @param {!Map<string, string>} groupIdPathwayIdMapping
  2219.    * @param {boolean=} requireUri
  2220.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2221.    * @private
  2222.    */
  2223.   createStreamInfoFromMediaTags_(tags, groupIdPathwayIdMapping,
  2224.       requireUri = true) {
  2225.     const verbatimMediaPlaylistUris = [];
  2226.     const globalGroupIds = [];
  2227.     const groupIdUriMapping = new Map();
  2228.     for (const tag of tags) {
  2229.       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  2230.           'Should only be called on media tags!');
  2231.       const uri = requireUri ? tag.getRequiredAttrValue('URI') :
  2232.           (tag.getAttributeValue('URI') || shaka.hls.HlsParser.FAKE_MUXED_URL_);
  2233.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  2234.       verbatimMediaPlaylistUris.push(uri);
  2235.       globalGroupIds.push(groupId);
  2236.       groupIdUriMapping.set(groupId, uri);
  2237.     }
  2239.     const globalGroupId = globalGroupIds.sort().join(',');
  2240.     const firstTag = tags[0];
  2241.     let codecs = '';
  2242.     /** @type {string} */
  2243.     const type = this.getType_(firstTag);
  2244.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  2245.       codecs = firstTag.getAttributeValue('CODECS') || '';
  2246.     } else {
  2247.       for (const groupId of globalGroupIds) {
  2248.         if (this.groupIdToCodecsMap_.has(groupId)) {
  2249.           codecs = this.groupIdToCodecsMap_.get(groupId);
  2250.           break;
  2251.         }
  2252.       }
  2253.     }
  2255.     // Check if the stream has already been created as part of another Variant
  2256.     // and return it if it has.
  2257.     const key = verbatimMediaPlaylistUris.sort().join(',');
  2258.     if (this.uriToStreamInfosMap_.has(key)) {
  2259.       return this.uriToStreamInfosMap_.get(key);
  2260.     }
  2261.     const streamId = this.globalId_++;
  2262.     if (this.contentSteeringManager_) {
  2263.       for (const [groupId, uri] of groupIdUriMapping) {
  2264.         const pathwayId = groupIdPathwayIdMapping.get(groupId);
  2265.         if (pathwayId) {
  2266.           this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
  2267.         }
  2268.       }
  2269.     }
  2271.     const language = firstTag.getAttributeValue('LANGUAGE');
  2272.     const name = firstTag.getAttributeValue('NAME');
  2274.     // NOTE: According to the HLS spec, "DEFAULT=YES" requires "AUTOSELECT=YES".
  2275.     // However, we don't bother to validate "AUTOSELECT", since we don't
  2276.     // actually use it in our streaming model, and we treat everything as
  2277.     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
  2278.     // only be selected explicitly by the user, and we don't have a way to
  2279.     // represent that in our model.
  2280.     const defaultAttrValue = firstTag.getAttributeValue('DEFAULT');
  2281.     const primary = defaultAttrValue == 'YES';
  2283.     const channelsCount =
  2284.         type == 'audio' ? this.getChannelsCount_(firstTag) : null;
  2285.     const spatialAudio =
  2286.         type == 'audio' ? this.isSpatialAudio_(firstTag) : false;
  2287.     const characteristics = firstTag.getAttributeValue('CHARACTERISTICS');
  2289.     const forcedAttrValue = firstTag.getAttributeValue('FORCED');
  2290.     const forced = forcedAttrValue == 'YES';
  2291.     const sampleRate = type == 'audio' ? this.getSampleRate_(firstTag) : null;
  2292.     // TODO: Should we take into account some of the currently ignored
  2293.     // attributes: INSTREAM-ID, Attribute descriptions: https://bit.ly/2lpjOhj
  2294.     const streamInfo = this.createStreamInfo_(
  2295.         streamId, verbatimMediaPlaylistUris, codecs, type, language,
  2296.         primary, name, channelsCount, /* closedCaptions= */ null,
  2297.         characteristics, forced, sampleRate, spatialAudio);
  2298.     if (streamInfo.stream) {
  2299.       streamInfo.stream.groupId = globalGroupId;
  2300.     }
  2301.     if (this.groupIdToStreamInfosMap_.has(globalGroupId)) {
  2302.       this.groupIdToStreamInfosMap_.get(globalGroupId).push(streamInfo);
  2303.     } else {
  2304.       this.groupIdToStreamInfosMap_.set(globalGroupId, [streamInfo]);
  2305.     }
  2307.     this.uriToStreamInfosMap_.set(key, streamInfo);
  2308.     return streamInfo;
  2309.   }
  2311.   /**
  2312.    * Parse EXT-X-IMAGE-STREAM-INF media tag into a Stream object.
  2313.    *
  2314.    * @param {shaka.hls.Tag} tag
  2315.    * @return {!Promise<!shaka.hls.HlsParser.StreamInfo>}
  2316.    * @private
  2317.    */
  2318.   async createStreamInfoFromImageTag_(tag) {
  2319.     goog.asserts.assert(tag.name == 'EXT-X-IMAGE-STREAM-INF',
  2320.         'Should only be called on image tags!');
  2321.     /** @type {string} */
  2322.     const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
  2324.     const verbatimImagePlaylistUri = tag.getRequiredAttrValue('URI');
  2325.     const codecs = tag.getAttributeValue('CODECS', 'jpeg') || '';
  2327.     // Check if the stream has already been created as part of another Variant
  2328.     // and return it if it has.
  2329.     if (this.uriToStreamInfosMap_.has(verbatimImagePlaylistUri)) {
  2330.       return this.uriToStreamInfosMap_.get(verbatimImagePlaylistUri);
  2331.     }
  2333.     const language = tag.getAttributeValue('LANGUAGE');
  2334.     const name = tag.getAttributeValue('NAME');
  2336.     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
  2338.     const streamInfo = this.createStreamInfo_(
  2339.         this.globalId_++, [verbatimImagePlaylistUri], codecs, type, language,
  2340.         /* primary= */ false, name, /* channelsCount= */ null,
  2341.         /* closedCaptions= */ null, characteristics, /* forced= */ false,
  2342.         /* sampleRate= */ null, /* spatialAudio= */ false);
  2344.     // Parse misc attributes.
  2345.     const resolution = tag.getAttributeValue('RESOLUTION');
  2346.     if (resolution) {
  2347.       // The RESOLUTION tag represents the resolution of a single thumbnail, not
  2348.       // of the entire sheet at once (like we expect in the output).
  2349.       // So multiply by the layout size.
  2351.       // Since we need to have generated the segment index for this, we can't
  2352.       // lazy-load in this situation.
  2353.       await streamInfo.stream.createSegmentIndex();
  2355.       const reference = streamInfo.stream.segmentIndex.earliestReference();
  2356.       const layout = reference.getTilesLayout();
  2357.       if (layout) {
  2358.         streamInfo.stream.width =
  2359.             Number(resolution.split('x')[0]) * Number(layout.split('x')[0]);
  2360.         streamInfo.stream.height =
  2361.             Number(resolution.split('x')[1]) * Number(layout.split('x')[1]);
  2362.         // TODO: What happens if there are multiple grids, with different
  2363.         // layout sizes, inside this image stream?
  2364.       }
  2365.     }
  2366.     const bandwidth = tag.getAttributeValue('BANDWIDTH');
  2367.     if (bandwidth) {
  2368.       streamInfo.stream.bandwidth = Number(bandwidth);
  2369.     }
  2371.     this.uriToStreamInfosMap_.set(verbatimImagePlaylistUri, streamInfo);
  2372.     return streamInfo;
  2373.   }
  2375.   /**
  2376.    * Parse EXT-X-I-FRAME-STREAM-INF media tag into a Stream object.
  2377.    *
  2378.    * @param {shaka.hls.Tag} tag
  2379.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2380.    * @private
  2381.    */
  2382.   createStreamInfoFromIframeTag_(tag) {
  2383.     goog.asserts.assert(tag.name == 'EXT-X-I-FRAME-STREAM-INF',
  2384.         'Should only be called on iframe tags!');
  2385.     /** @type {string} */
  2386.     let type = shaka.util.ManifestParserUtils.ContentType.VIDEO;
  2388.     const verbatimIFramePlaylistUri = tag.getRequiredAttrValue('URI');
  2389.     const codecs = tag.getAttributeValue('CODECS') || '';
  2391.     if (codecs == 'mjpg') {
  2392.       type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
  2393.     }
  2395.     // Check if the stream has already been created as part of another Variant
  2396.     // and return it if it has.
  2397.     if (this.uriToStreamInfosMap_.has(verbatimIFramePlaylistUri)) {
  2398.       return this.uriToStreamInfosMap_.get(verbatimIFramePlaylistUri);
  2399.     }
  2401.     const language = tag.getAttributeValue('LANGUAGE');
  2402.     const name = tag.getAttributeValue('NAME');
  2404.     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
  2406.     const streamInfo = this.createStreamInfo_(
  2407.         this.globalId_++, [verbatimIFramePlaylistUri], codecs, type, language,
  2408.         /* primary= */ false, name, /* channelsCount= */ null,
  2409.         /* closedCaptions= */ null, characteristics, /* forced= */ false,
  2410.         /* sampleRate= */ null, /* spatialAudio= */ false);
  2412.     // Parse misc attributes.
  2413.     const resolution = tag.getAttributeValue('RESOLUTION');
  2414.     const [width, height] = resolution ? resolution.split('x') : [null, null];
  2415.     streamInfo.stream.width = Number(width) || undefined;
  2416.     streamInfo.stream.height = Number(height) || undefined;
  2417.     const bandwidth = tag.getAttributeValue('BANDWIDTH');
  2418.     if (bandwidth) {
  2419.       streamInfo.stream.bandwidth = Number(bandwidth);
  2420.     }
  2422.     this.uriToStreamInfosMap_.set(verbatimIFramePlaylistUri, streamInfo);
  2423.     return streamInfo;
  2424.   }
  2426.   /**
  2427.    * Parse an EXT-X-STREAM-INF media tag into a Stream object.
  2428.    *
  2429.    * @param {!Array<!shaka.hls.Tag>} tags
  2430.    * @param {!Array<string>} allCodecs
  2431.    * @param {string} type
  2432.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2433.    * @private
  2434.    */
  2435.   createStreamInfoFromVariantTags_(tags, allCodecs, type) {
  2436.     const streamId = this.globalId_++;
  2437.     const verbatimMediaPlaylistUris = [];
  2438.     for (const tag of tags) {
  2439.       goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  2440.           'Should only be called on variant tags!');
  2441.       const uri = tag.getRequiredAttrValue('URI');
  2442.       const pathwayId = tag.getAttributeValue('PATHWAY-ID');
  2443.       if (this.contentSteeringManager_ && pathwayId) {
  2444.         this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
  2445.       }
  2446.       verbatimMediaPlaylistUris.push(uri);
  2447.     }
  2449.     const key = verbatimMediaPlaylistUris.sort().join(',') +
  2450.         allCodecs.sort().join(',');
  2451.     if (this.uriToStreamInfosMap_.has(key)) {
  2452.       return this.uriToStreamInfosMap_.get(key);
  2453.     }
  2455.     const name = verbatimMediaPlaylistUris.join(',');
  2456.     const closedCaptions = this.getClosedCaptions_(tags[0], type);
  2457.     const codecs = shaka.util.ManifestParserUtils.guessCodecs(type, allCodecs);
  2458.     const streamInfo = this.createStreamInfo_(
  2459.         streamId, verbatimMediaPlaylistUris,
  2460.         codecs, type, /* language= */ null, /* primary= */ false,
  2461.         name, /* channelCount= */ null, closedCaptions,
  2462.         /* characteristics= */ null, /* forced= */ false,
  2463.         /* sampleRate= */ null, /* spatialAudio= */ false);
  2465.     this.uriToStreamInfosMap_.set(key, streamInfo);
  2466.     return streamInfo;
  2467.   }
  2470.   /**
  2471.    * @param {number} streamId
  2472.    * @param {!Array<string>} verbatimMediaPlaylistUris
  2473.    * @param {string} codecs
  2474.    * @param {string} type
  2475.    * @param {?string} languageValue
  2476.    * @param {boolean} primary
  2477.    * @param {?string} name
  2478.    * @param {?number} channelsCount
  2479.    * @param {Map<string, string>} closedCaptions
  2480.    * @param {?string} characteristics
  2481.    * @param {boolean} forced
  2482.    * @param {?number} sampleRate
  2483.    * @param {boolean} spatialAudio
  2484.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2485.    * @private
  2486.    */
  2487.   createStreamInfo_(streamId, verbatimMediaPlaylistUris, codecs, type,
  2488.       languageValue, primary, name, channelsCount, closedCaptions,
  2489.       characteristics, forced, sampleRate, spatialAudio) {
  2490.     // TODO: Refactor, too many parameters
  2492.     // This stream is lazy-loaded inside the createSegmentIndex function.
  2493.     // So we start out with a stream object that does not contain the actual
  2494.     // segment index, then download when createSegmentIndex is called.
  2495.     const stream = this.makeStreamObject_(streamId, codecs, type,
  2496.         languageValue, primary, name, channelsCount, closedCaptions,
  2497.         characteristics, forced, sampleRate, spatialAudio);
  2499.     const FAKE_MUXED_URL_ = shaka.hls.HlsParser.FAKE_MUXED_URL_;
  2500.     if (verbatimMediaPlaylistUris.includes(FAKE_MUXED_URL_)) {
  2501.       stream.isAudioMuxedInVideo = true;
  2502.       // We assigned the TS mimetype because it is the only one that works
  2503.       // with this functionality. MP4 is not supported right now.
  2504.       stream.mimeType = 'video/mp2t';
  2505.       this.setFullTypeForStream_(stream);
  2506.     }
  2508.     const streamInfo = {
  2509.       stream,
  2510.       type,
  2511.       redirectUris: [],
  2512.       getUris: () => {},
  2513.       // These values are filled out or updated after lazy-loading:
  2514.       minTimestamp: 0,
  2515.       maxTimestamp: 0,
  2516.       mediaSequenceToStartTime: new Map(),
  2517.       canSkipSegments: false,
  2518.       canBlockReload: false,
  2519.       hasEndList: false,
  2520.       firstSequenceNumber: -1,
  2521.       nextMediaSequence: -1,
  2522.       nextPart: -1,
  2523.       loadedOnce: false,
  2524.     };
  2526.     const getUris = () => {
  2527.       if (this.contentSteeringManager_ &&
  2528.           verbatimMediaPlaylistUris.length > 1) {
  2529.         return this.contentSteeringManager_.getLocations(streamId);
  2530.       }
  2531.       return streamInfo.redirectUris.concat(shaka.hls.Utils.constructUris(
  2532.           [this.masterPlaylistUri_], verbatimMediaPlaylistUris,
  2533.           this.globalVariables_));
  2534.     };
  2536.     streamInfo.getUris = getUris;
  2538.     /** @param {!shaka.net.NetworkingEngine.PendingRequest} pendingRequest */
  2539.     const downloadSegmentIndex = async (pendingRequest) => {
  2540.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2542.       try {
  2543.         // Download the actual manifest.
  2544.         const response = await pendingRequest.promise;
  2545.         if (pendingRequest.aborted) {
  2546.           return;
  2547.         }
  2549.         // Record the final URI after redirects.
  2550.         const responseUri = response.uri;
  2551.         if (responseUri != response.originalUri) {
  2552.           const uris = streamInfo.getUris();
  2553.           if (!uris.includes(responseUri)) {
  2554.             streamInfo.redirectUris.push(responseUri);
  2555.           }
  2556.         }
  2558.         // Record the redirected, final URI of this media playlist when we parse
  2559.         // it.
  2560.         /** @type {!shaka.hls.Playlist} */
  2561.         const playlist = this.manifestTextParser_.parsePlaylist(response.data);
  2563.         if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  2564.           throw new shaka.util.Error(
  2565.               shaka.util.Error.Severity.CRITICAL,
  2566.               shaka.util.Error.Category.MANIFEST,
  2567.               shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  2568.         }
  2570.         /** @type {!Array<!shaka.hls.Tag>} */
  2571.         const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  2572.             'EXT-X-DEFINE');
  2574.         const mediaVariables =
  2575.             this.parseMediaVariables_(variablesTags, responseUri);
  2577.         const mimeType = undefined;
  2579.         let requestBasicInfo = false;
  2581.         // If no codec info was provided in the manifest and codec guessing is
  2582.         // disabled we try to get necessary info from the media data.
  2583.         if ((!this.codecInfoInManifest_ &&
  2584.             this.config_.hls.disableCodecGuessing) ||
  2585.             (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
  2586.             !this.config_.hls.disableClosedCaptionsDetection)) {
  2587.           if (playlist.segments.length > 0) {
  2588.             this.needsClosedCaptionsDetection_ = false;
  2589.             requestBasicInfo = true;
  2590.           }
  2591.         }
  2593.         const allowOverrideMimeType = !this.codecInfoInManifest_ &&
  2594.           this.config_.hls.disableCodecGuessing;
  2596.         const wasLive = this.isLive_();
  2597.         const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
  2598.             streamId, mediaVariables, playlist, getUris, codecs,
  2599.             type, languageValue, primary, name, channelsCount, closedCaptions,
  2600.             characteristics, forced, sampleRate, spatialAudio, mimeType,
  2601.             requestBasicInfo, allowOverrideMimeType);
  2602.         if (pendingRequest.aborted) {
  2603.           return;
  2604.         }
  2606.         const realStream = realStreamInfo.stream;
  2608.         this.determineStartTime_(playlist);
  2610.         if (this.isLive_() && !wasLive) {
  2611.           // Now that we know that the presentation is live, convert the
  2612.           // timeline to live.
  2613.           this.changePresentationTimelineToLive_(playlist);
  2614.         }
  2616.         // Copy values from the real stream info to our initial one.
  2617.         streamInfo.minTimestamp = realStreamInfo.minTimestamp;
  2618.         streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
  2619.         streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
  2620.         streamInfo.canBlockReload = realStreamInfo.canBlockReload;
  2621.         streamInfo.hasEndList = realStreamInfo.hasEndList;
  2622.         streamInfo.mediaSequenceToStartTime =
  2623.             realStreamInfo.mediaSequenceToStartTime;
  2624.         streamInfo.nextMediaSequence = realStreamInfo.nextMediaSequence;
  2625.         streamInfo.nextPart = realStreamInfo.nextPart;
  2626.         streamInfo.loadedOnce = true;
  2627.         stream.segmentIndex = realStream.segmentIndex;
  2628.         stream.encrypted = realStream.encrypted;
  2629.         stream.drmInfos = realStream.drmInfos;
  2630.         stream.keyIds = realStream.keyIds;
  2631.         stream.mimeType = realStream.mimeType;
  2632.         stream.bandwidth = stream.bandwidth || realStream.bandwidth;
  2633.         stream.codecs = stream.codecs || realStream.codecs;
  2634.         stream.closedCaptions =
  2635.             stream.closedCaptions || realStream.closedCaptions;
  2636.         stream.width = stream.width || realStream.width;
  2637.         stream.height = stream.height || realStream.height;
  2638.         stream.hdr = stream.hdr || realStream.hdr;
  2639.         stream.colorGamut = stream.colorGamut || realStream.colorGamut;
  2640.         stream.frameRate = stream.frameRate || realStream.frameRate;
  2641.         if (stream.language == 'und' && realStream.language != 'und') {
  2642.           stream.language = realStream.language;
  2643.         }
  2644.         stream.language = stream.language || realStream.language;
  2645.         stream.channelsCount = stream.channelsCount || realStream.channelsCount;
  2646.         stream.audioSamplingRate =
  2647.             stream.audioSamplingRate || realStream.audioSamplingRate;
  2648.         this.setFullTypeForStream_(stream);
  2650.         // Since we lazy-loaded this content, the player may need to create new
  2651.         // sessions for the DRM info in this stream.
  2652.         if (stream.drmInfos.length) {
  2653.           this.playerInterface_.newDrmInfo(stream);
  2654.         }
  2656.         let closedCaptionsUpdated = false;
  2657.         if ((!closedCaptions && stream.closedCaptions) ||
  2658.           (closedCaptions && stream.closedCaptions &&
  2659.           closedCaptions.size != stream.closedCaptions.size)) {
  2660.           closedCaptionsUpdated = true;
  2661.         }
  2663.         if (this.manifest_ && closedCaptionsUpdated) {
  2664.           this.playerInterface_.makeTextStreamsForClosedCaptions(
  2665.               this.manifest_);
  2666.         }
  2668.         if (type == ContentType.VIDEO || type == ContentType.AUDIO) {
  2669.           for (const otherStreamInfo of this.uriToStreamInfosMap_.values()) {
  2670.             if (!otherStreamInfo.loadedOnce && otherStreamInfo.type == type) {
  2671.               // To aid manifest filtering, assume before loading that all video
  2672.               // renditions have the same MIME type.  (And likewise for audio.)
  2673.               otherStreamInfo.stream.mimeType = realStream.mimeType;
  2674.               this.setFullTypeForStream_(otherStreamInfo.stream);
  2675.             }
  2676.           }
  2677.         }
  2679.         if (type == ContentType.TEXT) {
  2680.           const firstSegment = realStream.segmentIndex.earliestReference();
  2681.           if (firstSegment && firstSegment.initSegmentReference) {
  2682.             stream.mimeType = 'application/mp4';
  2683.             this.setFullTypeForStream_(stream);
  2684.           }
  2685.         }
  2687.         const qualityInfo =
  2688.             shaka.media.QualityObserver.createQualityInfo(stream);
  2689.         stream.segmentIndex.forEachTopLevelReference((reference) => {
  2690.           if (reference.initSegmentReference) {
  2691.             reference.initSegmentReference.mediaQuality = qualityInfo;
  2692.           }
  2693.         });
  2695.         // Add finishing touches to the stream that can only be done once we
  2696.         // have more full context on the media as a whole.
  2697.         if (this.hasEnoughInfoToFinalizeStreams_()) {
  2698.           if (!this.streamsFinalized_) {
  2699.             // Mark this manifest as having been finalized, so we don't go
  2700.             // through this whole process of finishing touches a second time.
  2701.             this.streamsFinalized_ = true;
  2702.             // Finalize all of the currently-loaded streams.
  2703.             const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  2704.             const activeStreamInfos =
  2705.                 streamInfos.filter((s) => s.stream.segmentIndex);
  2706.             this.finalizeStreams_(activeStreamInfos);
  2707.             // With the addition of this new stream, we now have enough info to
  2708.             // figure out how long the streams should be. So process all streams
  2709.             // we have downloaded up until this point.
  2710.             this.determineDuration_();
  2711.             // Finally, start the update timer, if this asset has been
  2712.             // determined to be a livestream.
  2713.             const delay = this.getUpdatePlaylistDelay_();
  2714.             if (delay > 0) {
  2715.               this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
  2716.             }
  2717.           } else {
  2718.             // We don't need to go through the full process; just finalize this
  2719.             // single stream.
  2720.             this.finalizeStreams_([streamInfo]);
  2721.           }
  2722.         }
  2724.         this.processDateRangeTags_(
  2725.             playlist.tags, stream.type, mediaVariables, getUris);
  2727.         if (this.manifest_) {
  2728.           this.manifest_.startTime = this.startTime_;
  2729.         }
  2730.       } catch (e) {
  2731.         stream.closeSegmentIndex();
  2732.         if (e.code === shaka.util.Error.Code.OPERATION_ABORTED) {
  2733.           return;
  2734.         }
  2735.         const handled = this.playerInterface_.disableStream(stream);
  2736.         if (!handled) {
  2737.           throw e;
  2738.         }
  2739.       }
  2740.     };
  2742.     /** @type {Promise} */
  2743.     let creationPromise = null;
  2744.     /** @type {!shaka.net.NetworkingEngine.PendingRequest} */
  2745.     let pendingRequest;
  2746.     const safeCreateSegmentIndex = () => {
  2747.       // An operation is already in progress.  The second and subsequent
  2748.       // callers receive the same Promise as the first caller, and only one
  2749.       // download operation will occur.
  2750.       if (creationPromise) {
  2751.         return creationPromise;
  2752.       }
  2754.       if (stream.isAudioMuxedInVideo) {
  2755.         const segmentIndex = new shaka.media.SegmentIndex([]);
  2756.         stream.segmentIndex = segmentIndex;
  2757.         return Promise.resolve();
  2758.       }
  2760.       // Create a new PendingRequest to be able to cancel this specific
  2761.       // download.
  2762.       pendingRequest = this.requestManifest_(streamInfo.getUris(),
  2763.           /* isPlaylist= */ true);
  2765.       // Create a Promise tied to the outcome of downloadSegmentIndex().  If
  2766.       // downloadSegmentIndex is rejected, creationPromise will also be
  2767.       // rejected.
  2768.       creationPromise = new Promise((resolve) => {
  2769.         resolve(downloadSegmentIndex(pendingRequest));
  2770.       });
  2771.       return creationPromise;
  2772.     };
  2774.     stream.createSegmentIndex = safeCreateSegmentIndex;
  2776.     stream.closeSegmentIndex = () => {
  2777.       // If we're mid-creation, cancel it.
  2778.       if (creationPromise && !stream.segmentIndex) {
  2779.         pendingRequest.abort();
  2780.       }
  2781.       // If we have a segment index, release it.
  2782.       if (stream.segmentIndex) {
  2783.         stream.segmentIndex.release();
  2784.         stream.segmentIndex = null;
  2785.       }
  2786.       // Clear the creation Promise so that a new operation can begin.
  2787.       creationPromise = null;
  2788.     };
  2790.     return streamInfo;
  2791.   }
  2793.   /**
  2794.    * @return {number}
  2795.    * @private
  2796.    */
  2797.   getMinDuration_() {
  2798.     let minDuration = Infinity;
  2799.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  2800.       if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text' &&
  2801.           !streamInfo.stream.isAudioMuxedInVideo) {
  2802.         // Since everything is already offset to 0 (either by sync or by being
  2803.         // VOD), only maxTimestamp is necessary to compute the duration.
  2804.         minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
  2805.       }
  2806.     }
  2807.     return minDuration;
  2808.   }
  2810.   /**
  2811.    * @return {number}
  2812.    * @private
  2813.    */
  2814.   getLiveDuration_() {
  2815.     let maxTimestamp = Infinity;
  2816.     let minTimestamp = Infinity;
  2817.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  2818.       if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text' &&
  2819.           !streamInfo.stream.isAudioMuxedInVideo) {
  2820.         maxTimestamp = Math.min(maxTimestamp, streamInfo.maxTimestamp);
  2821.         minTimestamp = Math.min(minTimestamp, streamInfo.minTimestamp);
  2822.       }
  2823.     }
  2824.     return maxTimestamp - minTimestamp;
  2825.   }
  2827.   /**
  2828.    * @param {!Array<!shaka.extern.Stream>} streams
  2829.    * @private
  2830.    */
  2831.   notifySegmentsForStreams_(streams) {
  2832.     const references = [];
  2833.     for (const stream of streams) {
  2834.       if (!stream.segmentIndex) {
  2835.         // The stream was closed since the list of streams was built.
  2836.         continue;
  2837.       }
  2838.       stream.segmentIndex.forEachTopLevelReference((reference) => {
  2839.         references.push(reference);
  2840.       });
  2841.     }
  2842.     this.presentationTimeline_.notifySegments(references);
  2843.   }
  2845.   /**
  2846.    * @param {!Array<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  2847.    * @private
  2848.    */
  2849.   finalizeStreams_(streamInfos) {
  2850.     if (!this.isLive_()) {
  2851.       const minDuration = this.getMinDuration_();
  2852.       for (const streamInfo of streamInfos) {
  2853.         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
  2854.       }
  2855.     }
  2856.     this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
  2858.     const activeStreamInfos = Array.from(this.uriToStreamInfosMap_.values())
  2859.         .filter((s) => s.stream.segmentIndex);
  2860.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2861.     const hasAudio =
  2862.         activeStreamInfos.some((s) => s.stream.type == ContentType.AUDIO);
  2863.     const hasVideo =
  2864.         activeStreamInfos.some((s) => s.stream.type == ContentType.VIDEO);
  2866.     const liveWithNoProgramDateTime =
  2867.         this.isLive_() && !this.usesProgramDateTime_;
  2868.     const vodWithOnlyAudioOrVideo = !this.isLive_() &&
  2869.         this.usesProgramDateTime_ && !(hasAudio && hasVideo);
  2870.     if (this.config_.hls.ignoreManifestProgramDateTime ||
  2871.         liveWithNoProgramDateTime || vodWithOnlyAudioOrVideo) {
  2872.       this.syncStreamsWithSequenceNumber_(
  2873.           streamInfos, liveWithNoProgramDateTime);
  2874.     } else {
  2875.       this.syncStreamsWithProgramDateTime_(streamInfos);
  2876.       if (this.config_.hls.ignoreManifestProgramDateTimeForTypes.length > 0) {
  2877.         this.syncStreamsWithSequenceNumber_(streamInfos);
  2878.       }
  2879.     }
  2880.   }
  2882.   /**
  2883.    * @param {string} type
  2884.    * @return {boolean}
  2885.    * @private
  2886.    */
  2887.   ignoreManifestProgramDateTimeFor_(type) {
  2888.     if (this.config_.hls.ignoreManifestProgramDateTime) {
  2889.       return true;
  2890.     }
  2891.     const forTypes = this.config_.hls.ignoreManifestProgramDateTimeForTypes;
  2892.     return forTypes.includes(type);
  2893.   }
  2895.   /**
  2896.    * There are some values on streams that can only be set once we know about
  2897.    * both the video and audio content, if present.
  2898.    * This checks if there is at least one video downloaded (if the media has
  2899.    * video), and that there is at least one audio downloaded (if the media has
  2900.    * audio).
  2901.    * @return {boolean}
  2902.    * @private
  2903.    */
  2904.   hasEnoughInfoToFinalizeStreams_() {
  2905.     if (!this.manifest_) {
  2906.       return false;
  2907.     }
  2908.     const videos = [];
  2909.     const audios = [];
  2910.     for (const variant of this.manifest_.variants) {
  2911.       if (variant.video) {
  2912.         videos.push(variant.video);
  2913.       }
  2914.       if (variant.audio) {
  2915.         audios.push(variant.audio);
  2916.       }
  2917.     }
  2918.     if (videos.length > 0 && !videos.some((stream) => stream.segmentIndex)) {
  2919.       return false;
  2920.     }
  2921.     if (audios.length > 0 && !audios.some((stream) => stream.segmentIndex)) {
  2922.       return false;
  2923.     }
  2924.     return true;
  2925.   }
  2927.   /**
  2928.    * @param {number} streamId
  2929.    * @param {!Map<string, string>} variables
  2930.    * @param {!shaka.hls.Playlist} playlist
  2931.    * @param {function(): !Array<string>} getUris
  2932.    * @param {string} codecs
  2933.    * @param {string} type
  2934.    * @param {?string} languageValue
  2935.    * @param {boolean} primary
  2936.    * @param {?string} name
  2937.    * @param {?number} channelsCount
  2938.    * @param {Map<string, string>} closedCaptions
  2939.    * @param {?string} characteristics
  2940.    * @param {boolean} forced
  2941.    * @param {?number} sampleRate
  2942.    * @param {boolean} spatialAudio
  2943.    * @param {(string|undefined)} mimeType
  2944.    * @param {boolean=} requestBasicInfo
  2945.    * @param {boolean=} allowOverrideMimeType
  2946.    * @return {!Promise<!shaka.hls.HlsParser.StreamInfo>}
  2947.    * @private
  2948.    */
  2949.   async convertParsedPlaylistIntoStreamInfo_(streamId, variables, playlist,
  2950.       getUris, codecs, type, languageValue, primary, name,
  2951.       channelsCount, closedCaptions, characteristics, forced, sampleRate,
  2952.       spatialAudio, mimeType = undefined, requestBasicInfo = true,
  2953.       allowOverrideMimeType = true) {
  2954.     const playlistSegments = playlist.segments || [];
  2955.     const allAreMissing = playlistSegments.every((seg) => {
  2956.       if (shaka.hls.Utils.getFirstTagWithName(seg.tags, 'EXT-X-GAP')) {
  2957.         return true;
  2958.       }
  2959.       return false;
  2960.     });
  2962.     if (!playlistSegments.length || allAreMissing) {
  2963.       throw new shaka.util.Error(
  2964.           shaka.util.Error.Severity.CRITICAL,
  2965.           shaka.util.Error.Category.MANIFEST,
  2966.           shaka.util.Error.Code.HLS_EMPTY_MEDIA_PLAYLIST);
  2967.     }
  2969.     this.determinePresentationType_(playlist);
  2971.     if (this.isLive_()) {
  2972.       this.determineLastTargetDuration_(playlist);
  2973.     }
  2975.     const mediaSequenceToStartTime = this.isLive_() ?
  2976.         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
  2978.     const {segments, bandwidth} = this.createSegments_(
  2979.         playlist, mediaSequenceToStartTime, variables, getUris, type);
  2981.     let width = null;
  2982.     let height = null;
  2983.     let videoRange = null;
  2984.     let colorGamut = null;
  2985.     let frameRate = null;
  2986.     if (segments.length > 0 && requestBasicInfo) {
  2987.       const basicInfo = await this.getBasicInfoFromSegments_(segments);
  2989.       type = basicInfo.type;
  2990.       languageValue = basicInfo.language;
  2991.       channelsCount = basicInfo.channelCount;
  2992.       sampleRate = basicInfo.sampleRate;
  2993.       if (!this.config_.disableText) {
  2994.         closedCaptions = basicInfo.closedCaptions;
  2995.       }
  2997.       height = basicInfo.height;
  2998.       width = basicInfo.width;
  2999.       videoRange = basicInfo.videoRange;
  3000.       colorGamut = basicInfo.colorGamut;
  3001.       frameRate = basicInfo.frameRate;
  3003.       if (allowOverrideMimeType) {
  3004.         mimeType = basicInfo.mimeType;
  3005.         codecs = basicInfo.codecs;
  3006.       }
  3007.     }
  3009.     if (!mimeType) {
  3010.       mimeType = await this.guessMimeType_(type, codecs, segments);
  3012.       // Some manifests don't say what text codec they use, this is a problem
  3013.       // if the cmft extension is used because we identify the mimeType as
  3014.       // application/mp4. In this case if we don't detect initialization
  3015.       // segments, we assume that the mimeType is text/vtt.
  3016.       if (type == shaka.util.ManifestParserUtils.ContentType.TEXT &&
  3017.           !codecs && mimeType == 'application/mp4' &&
  3018.           segments[0] && !segments[0].initSegmentReference) {
  3019.         mimeType = 'text/vtt';
  3020.       }
  3021.     }
  3023.     const {drmInfos, keyIds, encrypted, aesEncrypted} =
  3024.         await this.parseDrmInfo_(playlist, mimeType, getUris, variables);
  3026.     if (encrypted && !drmInfos.length && !aesEncrypted) {
  3027.       throw new shaka.util.Error(
  3028.           shaka.util.Error.Severity.CRITICAL,
  3029.           shaka.util.Error.Category.MANIFEST,
  3030.           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
  3031.     }
  3033.     const stream = this.makeStreamObject_(streamId, codecs, type,
  3034.         languageValue, primary, name, channelsCount, closedCaptions,
  3035.         characteristics, forced, sampleRate, spatialAudio);
  3036.     stream.encrypted = encrypted && !aesEncrypted;
  3037.     stream.drmInfos = drmInfos;
  3038.     stream.keyIds = keyIds;
  3039.     stream.mimeType = mimeType;
  3040.     if (bandwidth) {
  3041.       stream.bandwidth = bandwidth;
  3042.     }
  3043.     this.setFullTypeForStream_(stream);
  3045.     if (type == shaka.util.ManifestParserUtils.ContentType.VIDEO &&
  3046.         (width || height || videoRange || colorGamut)) {
  3047.       this.addVideoAttributes_(stream, width, height,
  3048.           frameRate, videoRange, /* videoLayout= */ null, colorGamut);
  3049.     }
  3051.     // This new calculation is necessary for Low Latency streams.
  3052.     if (this.isLive_()) {
  3053.       this.determineLastTargetDuration_(playlist);
  3054.     }
  3056.     const firstStartTime = segments[0].startTime;
  3057.     const lastSegment = segments[segments.length - 1];
  3058.     const lastEndTime = lastSegment.endTime;
  3059.     /** @type {!shaka.media.SegmentIndex} */
  3060.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  3061.     stream.segmentIndex = segmentIndex;
  3063.     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
  3064.         playlist.tags, 'EXT-X-SERVER-CONTROL');
  3065.     const canSkipSegments = serverControlTag ?
  3066.           serverControlTag.getAttribute('CAN-SKIP-UNTIL') != null : false;
  3067.     const canBlockReload = serverControlTag ?
  3068.           serverControlTag.getAttribute('CAN-BLOCK-RELOAD') != null : false;
  3070.     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3071.         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  3073.     const {nextMediaSequence, nextPart} =
  3074.         this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
  3076.     return {
  3077.       stream,
  3078.       type,
  3079.       redirectUris: [],
  3080.       getUris,
  3081.       minTimestamp: firstStartTime,
  3082.       maxTimestamp: lastEndTime,
  3083.       canSkipSegments,
  3084.       canBlockReload,
  3085.       hasEndList: false,
  3086.       firstSequenceNumber: -1,
  3087.       nextMediaSequence,
  3088.       nextPart,
  3089.       mediaSequenceToStartTime,
  3090.       loadedOnce: false,
  3091.     };
  3092.   }
  3094.   /**
  3095.    * Get the next msn and part
  3096.    *
  3097.    * @param {number} mediaSequenceNumber
  3098.    * @param {!Array<!shaka.media.SegmentReference>} segments
  3099.    * @return {{nextMediaSequence: number, nextPart:number}}}
  3100.    * @private
  3101.    */
  3102.   getNextMediaSequenceAndPart_(mediaSequenceNumber, segments) {
  3103.     const currentMediaSequence = mediaSequenceNumber + segments.length - 1;
  3104.     let nextMediaSequence = currentMediaSequence;
  3105.     let nextPart = -1;
  3106.     if (!segments.length) {
  3107.       nextMediaSequence++;
  3108.       return {
  3109.         nextMediaSequence,
  3110.         nextPart,
  3111.       };
  3112.     }
  3113.     const lastSegment = segments[segments.length - 1];
  3114.     const partialReferences = lastSegment.partialReferences;
  3115.     if (!lastSegment.partialReferences.length) {
  3116.       nextMediaSequence++;
  3117.       if (lastSegment.hasByterangeOptimization()) {
  3118.         nextPart = 0;
  3119.       }
  3120.       return {
  3121.         nextMediaSequence,
  3122.         nextPart,
  3123.       };
  3124.     }
  3125.     nextPart = partialReferences.length - 1;
  3126.     const lastPartialReference =
  3127.         partialReferences[partialReferences.length - 1];
  3128.     if (!lastPartialReference.isPreload()) {
  3129.       nextMediaSequence++;
  3130.       nextPart = 0;
  3131.     }
  3132.     return {
  3133.       nextMediaSequence,
  3134.       nextPart,
  3135.     };
  3136.   }
  3139.   /**
  3140.    * Creates a stream object with the given parameters.
  3141.    * The parameters that are passed into here are only the things that can be
  3142.    * known without downloading the media playlist; other values must be set
  3143.    * manually on the object after creation.
  3144.    * @param {number} id
  3145.    * @param {string} codecs
  3146.    * @param {string} type
  3147.    * @param {?string} languageValue
  3148.    * @param {boolean} primary
  3149.    * @param {?string} name
  3150.    * @param {?number} channelsCount
  3151.    * @param {Map<string, string>} closedCaptions
  3152.    * @param {?string} characteristics
  3153.    * @param {boolean} forced
  3154.    * @param {?number} sampleRate
  3155.    * @param {boolean} spatialAudio
  3156.    * @return {!shaka.extern.Stream}
  3157.    * @private
  3158.    */
  3159.   makeStreamObject_(id, codecs, type, languageValue, primary, name,
  3160.       channelsCount, closedCaptions, characteristics, forced, sampleRate,
  3161.       spatialAudio) {
  3162.     // Fill out a "best-guess" mimeType, for now. It will be replaced once the
  3163.     // stream is lazy-loaded.
  3164.     const mimeType = this.guessMimeTypeBeforeLoading_(type, codecs) ||
  3165.         this.guessMimeTypeFallback_(type);
  3166.     const roles = [];
  3167.     if (characteristics) {
  3168.       for (const characteristic of characteristics.split(',')) {
  3169.         roles.push(characteristic);
  3170.       }
  3171.     }
  3173.     let kind = undefined;
  3174.     let accessibilityPurpose = null;
  3175.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  3176.       if (roles.includes('public.accessibility.transcribes-spoken-dialog') &&
  3177.           roles.includes('public.accessibility.describes-music-and-sound')) {
  3178.         kind = shaka.util.ManifestParserUtils.TextStreamKind.CLOSED_CAPTION;
  3179.       } else {
  3180.         kind = shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE;
  3181.       }
  3182.     } else {
  3183.       if (roles.includes('public.accessibility.describes-video')) {
  3184.         accessibilityPurpose =
  3185.               shaka.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED;
  3186.       }
  3187.     }
  3189.     // If there are no roles, and we have defaulted to the subtitle "kind" for
  3190.     // this track, add the implied subtitle role.
  3191.     if (!roles.length &&
  3192.         kind === shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE) {
  3193.       roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
  3194.     }
  3196.     const stream = {
  3197.       id: this.globalId_++,
  3198.       originalId: name,
  3199.       groupId: null,
  3200.       createSegmentIndex: () => Promise.resolve(),
  3201.       segmentIndex: null,
  3202.       mimeType,
  3203.       codecs,
  3204.       kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
  3205.           shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
  3206.       encrypted: false,
  3207.       drmInfos: [],
  3208.       keyIds: new Set(),
  3209.       language: this.getLanguage_(languageValue),
  3210.       originalLanguage: languageValue,
  3211.       label: name,  // For historical reasons, since before "originalId".
  3212.       type,
  3213.       primary,
  3214.       // TODO: trick mode
  3215.       trickModeVideo: null,
  3216.       dependencyStream: null,
  3217.       emsgSchemeIdUris: null,
  3218.       frameRate: undefined,
  3219.       pixelAspectRatio: undefined,
  3220.       width: undefined,
  3221.       height: undefined,
  3222.       bandwidth: undefined,
  3223.       roles,
  3224.       forced,
  3225.       channelsCount,
  3226.       audioSamplingRate: sampleRate,
  3227.       spatialAudio,
  3228.       closedCaptions,
  3229.       hdr: undefined,
  3230.       colorGamut: undefined,
  3231.       videoLayout: undefined,
  3232.       tilesLayout: undefined,
  3233.       accessibilityPurpose: accessibilityPurpose,
  3234.       external: false,
  3235.       fastSwitching: false,
  3236.       fullMimeTypes: new Set(),
  3237.       isAudioMuxedInVideo: false,
  3238.       baseOriginalId: null,
  3239.     };
  3240.     this.setFullTypeForStream_(stream);
  3241.     return stream;
  3242.   }
  3244.   /**
  3245.    * @param {!shaka.hls.Playlist} playlist
  3246.    * @param {string} mimeType
  3247.    * @param {function(): !Array<string>} getUris
  3248.    * @param {?Map<string, string>=} variables
  3249.    * @return {Promise<{
  3250.    *   drmInfos: !Array<shaka.extern.DrmInfo>,
  3251.    *   keyIds: !Set<string>,
  3252.    *   encrypted: boolean,
  3253.    *   aesEncrypted: boolean
  3254.    * }>}
  3255.    * @private
  3256.    */
  3257.   async parseDrmInfo_(playlist, mimeType, getUris, variables) {
  3258.     /** @type {!Map<!shaka.hls.Tag, ?shaka.media.InitSegmentReference>} */
  3259.     const drmTagsMap = new Map();
  3260.     if (!this.config_.ignoreDrmInfo && playlist.segments) {
  3261.       for (const segment of playlist.segments) {
  3262.         const segmentKeyTags = shaka.hls.Utils.filterTagsByName(segment.tags,
  3263.             'EXT-X-KEY');
  3264.         let initSegmentRef = null;
  3265.         if (segmentKeyTags.length) {
  3266.           initSegmentRef = this.getInitSegmentReference_(playlist,
  3267.               segment.tags, getUris, variables);
  3268.           for (const segmentKeyTag of segmentKeyTags) {
  3269.             drmTagsMap.set(segmentKeyTag, initSegmentRef);
  3270.           }
  3271.         }
  3272.       }
  3273.     }
  3275.     let encrypted = false;
  3276.     let aesEncrypted = false;
  3278.     /** @type {!Array<shaka.extern.DrmInfo>}*/
  3279.     const drmInfos = [];
  3280.     const keyIds = new Set();
  3282.     for (const [key, value] of drmTagsMap) {
  3283.       const drmTag = /** @type {!shaka.hls.Tag} */ (key);
  3284.       const initSegmentRef =
  3285.       /** @type {?shaka.media.InitSegmentReference} */ (value);
  3286.       const method = drmTag.getRequiredAttrValue('METHOD');
  3287.       if (method != 'NONE') {
  3288.         encrypted = true;
  3290.         // According to the HLS spec, KEYFORMAT is optional and implicitly
  3291.         // defaults to "identity".
  3292.         // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
  3293.         const keyFormat =
  3294.             drmTag.getAttributeValue('KEYFORMAT') || 'identity';
  3295.         let drmInfo = null;
  3297.         if (this.isAesMethod_(method)) {
  3298.           // These keys are handled separately.
  3299.           aesEncrypted = true;
  3300.           continue;
  3301.         } else if (keyFormat == 'identity') {
  3302.           // eslint-disable-next-line no-await-in-loop
  3303.           drmInfo = await this.identityDrmParser_(
  3304.               drmTag, mimeType, getUris, initSegmentRef, variables);
  3305.         } else {
  3306.           const drmParser =
  3307.               this.keyFormatsToDrmParsers_.get(keyFormat);
  3308.           drmInfo = drmParser ?
  3309.             // eslint-disable-next-line no-await-in-loop
  3310.             await drmParser(drmTag, mimeType, initSegmentRef) :
  3311.             null;
  3312.         }
  3313.         if (drmInfo) {
  3314.           if (drmInfo.keyIds) {
  3315.             for (const keyId of drmInfo.keyIds) {
  3316.               keyIds.add(keyId);
  3317.             }
  3318.           }
  3319.           drmInfos.push(drmInfo);
  3320.         } else {
  3321.           shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  3322.         }
  3323.       }
  3324.     }
  3326.     return {drmInfos, keyIds, encrypted, aesEncrypted};
  3327.   }
  3329.   /**
  3330.    * @param {!shaka.hls.Tag} drmTag
  3331.    * @param {!shaka.hls.Playlist} playlist
  3332.    * @param {function(): !Array<string>} getUris
  3333.    * @param {?Map<string, string>=} variables
  3334.    * @return {!shaka.extern.aesKey}
  3335.    * @private
  3336.    */
  3337.   parseAESDrmTag_(drmTag, playlist, getUris, variables) {
  3338.     // Check if the Web Crypto API is available.
  3339.     if (!window.crypto || !window.crypto.subtle) {
  3340.       shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
  3341.           'AES. (Web Crypto only exists in secure origins like https)');
  3342.       throw new shaka.util.Error(
  3343.           shaka.util.Error.Severity.CRITICAL,
  3344.           shaka.util.Error.Category.MANIFEST,
  3345.           shaka.util.Error.Code.NO_WEB_CRYPTO_API);
  3346.     }
  3348.     // HLS RFC 8216 Section 5.2:
  3349.     // An EXT-X-KEY tag with a KEYFORMAT of "identity" that does not have an IV
  3350.     // attribute indicates that the Media Sequence Number is to be used as the
  3351.     // IV when decrypting a Media Segment, by putting its big-endian binary
  3352.     // representation into a 16-octet (128-bit) buffer and padding (on the left)
  3353.     // with zeros.
  3354.     let firstMediaSequenceNumber = 0;
  3355.     let iv;
  3356.     const ivHex = drmTag.getAttributeValue('IV', '');
  3357.     if (!ivHex) {
  3358.       // Media Sequence Number will be used as IV.
  3359.       firstMediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3360.           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  3361.     } else {
  3362.       // Exclude 0x at the start of string.
  3363.       iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
  3364.       if (iv.byteLength != 16) {
  3365.         throw new shaka.util.Error(
  3366.             shaka.util.Error.Severity.CRITICAL,
  3367.             shaka.util.Error.Category.MANIFEST,
  3368.             shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
  3369.       }
  3370.     }
  3372.     const keyUris = shaka.hls.Utils.constructSegmentUris(
  3373.         getUris(), drmTag.getRequiredAttrValue('URI'), variables);
  3374.     const keyMapKey = keyUris.sort().join('');
  3375.     const aesKeyInfoKey =
  3376.         `${drmTag.toString()}-${firstMediaSequenceNumber}-${keyMapKey}`;
  3377.     if (!this.aesKeyInfoMap_.has(aesKeyInfoKey)) {
  3378.       // Default AES-128
  3379.       const keyInfo = {
  3380.         bitsKey: 128,
  3381.         blockCipherMode: 'CBC',
  3382.         iv,
  3383.         firstMediaSequenceNumber,
  3384.       };
  3386.       const method = drmTag.getRequiredAttrValue('METHOD');
  3387.       switch (method) {
  3388.         case 'AES-256':
  3389.           keyInfo.bitsKey = 256;
  3390.           break;
  3391.         case 'AES-256-CTR':
  3392.           keyInfo.bitsKey = 256;
  3393.           keyInfo.blockCipherMode = 'CTR';
  3394.           break;
  3395.       }
  3397.       // Don't download the key object until the segment is parsed, to avoid a
  3398.       // startup delay for long manifests with lots of keys.
  3399.       keyInfo.fetchKey = async () => {
  3400.         if (!this.aesKeyMap_.has(keyMapKey)) {
  3401.           const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  3402.           const request = shaka.net.NetworkingEngine.makeRequest(
  3403.               keyUris, this.config_.retryParameters);
  3404.           const keyResponse = this.makeNetworkRequest_(request, requestType)
  3405.               .promise;
  3406.           this.aesKeyMap_.set(keyMapKey, keyResponse);
  3407.         }
  3408.         const keyResponse = await this.aesKeyMap_.get(keyMapKey);
  3410.         // keyResponse.status is undefined when URI is "data:text/plain;base64,"
  3411.         if (!keyResponse.data ||
  3412.             keyResponse.data.byteLength != (keyInfo.bitsKey / 8)) {
  3413.           throw new shaka.util.Error(
  3414.               shaka.util.Error.Severity.CRITICAL,
  3415.               shaka.util.Error.Category.MANIFEST,
  3416.               shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
  3417.         }
  3419.         const algorithm = {
  3420.           name: keyInfo.blockCipherMode == 'CTR' ? 'AES-CTR' : 'AES-CBC',
  3421.           length: keyInfo.bitsKey,
  3422.         };
  3423.         keyInfo.cryptoKey = await window.crypto.subtle.importKey(
  3424.             'raw', keyResponse.data, algorithm, true, ['decrypt']);
  3425.         keyInfo.fetchKey = undefined; // No longer needed.
  3426.       };
  3427.       this.aesKeyInfoMap_.set(aesKeyInfoKey, keyInfo);
  3428.     }
  3429.     return this.aesKeyInfoMap_.get(aesKeyInfoKey);
  3430.   }
  3433.   /**
  3434.    * @param {!shaka.hls.Playlist} playlist
  3435.    * @private
  3436.    */
  3437.   determineStartTime_(playlist) {
  3438.     // If we already have a starttime we avoid processing this again.
  3439.     if (this.startTime_ != null) {
  3440.       return;
  3441.     }
  3442.     const startTimeTag =
  3443.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-START');
  3444.     if (startTimeTag) {
  3445.       this.startTime_ =
  3446.           Number(startTimeTag.getRequiredAttrValue('TIME-OFFSET'));
  3447.     }
  3448.   }
  3451.   /**
  3452.    * @param {!shaka.hls.Playlist} playlist
  3453.    * @private
  3454.    */
  3455.   determinePresentationType_(playlist) {
  3456.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  3457.     const presentationTypeTag =
  3458.         shaka.hls.Utils.getFirstTagWithName(playlist.tags,
  3459.             'EXT-X-PLAYLIST-TYPE');
  3460.     const endListTag =
  3461.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  3463.     const isVod = (presentationTypeTag && presentationTypeTag.value == 'VOD') ||
  3464.         endListTag;
  3465.     const isEvent = presentationTypeTag &&
  3466.         presentationTypeTag.value == 'EVENT' && !isVod;
  3467.     const isLive = !isVod && !isEvent;
  3469.     if (isVod) {
  3470.       this.setPresentationType_(PresentationType.VOD);
  3471.     } else {
  3472.       // If it's not VOD, it must be presentation type LIVE or an ongoing EVENT.
  3473.       if (isLive) {
  3474.         this.setPresentationType_(PresentationType.LIVE);
  3475.       } else {
  3476.         this.setPresentationType_(PresentationType.EVENT);
  3477.       }
  3478.     }
  3479.   }
  3482.   /**
  3483.    * @param {!shaka.hls.Playlist} playlist
  3484.    * @private
  3485.    */
  3486.   determineLastTargetDuration_(playlist) {
  3487.     let lastTargetDuration = Infinity;
  3488.     const segments = playlist.segments;
  3489.     if (segments.length) {
  3490.       let segmentIndex = segments.length - 1;
  3491.       while (segmentIndex >= 0) {
  3492.         const segment = segments[segmentIndex];
  3493.         const extinfTag =
  3494.             shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXTINF');
  3495.         if (extinfTag) {
  3496.           // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  3497.           // We're interested in the duration part.
  3498.           const extinfValues = extinfTag.value.split(',');
  3499.           lastTargetDuration = Number(extinfValues[0]);
  3500.           break;
  3501.         }
  3502.         segmentIndex--;
  3503.       }
  3504.     }
  3506.     const targetDurationTag = this.getRequiredTag_(playlist.tags,
  3507.         'EXT-X-TARGETDURATION');
  3508.     const targetDuration = Number(targetDurationTag.value);
  3509.     const partialTargetDurationTag =
  3510.       shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-PART-INF');
  3511.     if (partialTargetDurationTag) {
  3512.       this.partialTargetDuration_ = Number(
  3513.           partialTargetDurationTag.getRequiredAttrValue('PART-TARGET'));
  3514.     }
  3515.     // Get the server-recommended min distance from the live edge.
  3516.     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
  3517.         playlist.tags, 'EXT-X-SERVER-CONTROL');
  3518.     // According to the HLS spec, updates should not happen more often than
  3519.     // once in targetDuration.  It also requires us to only update the active
  3520.     // variant.  We might implement that later, but for now every variant
  3521.     // will be updated.  To get the update period, choose the smallest
  3522.     // targetDuration value across all playlists.
  3523.     // 1. Update the shortest one to use as update period and segment
  3524.     // availability time (for LIVE).
  3525.     if (this.lowLatencyMode_ && this.partialTargetDuration_) {
  3526.       // For low latency streaming, use the partial segment target duration.
  3527.       if (this.lowLatencyByterangeOptimization_) {
  3528.         // We always have at least 1 partial segment part, and most servers
  3529.         // allow you to make a request with _HLS_msn=X&_HLS_part=0 with a
  3530.         // distance of 4 partial segments.  With this we ensure that we
  3531.         // obtain the minimum latency in this type of case.
  3532.         if (this.partialTargetDuration_ * 5 <= lastTargetDuration) {
  3533.           this.lastTargetDuration_ = Math.min(
  3534.               this.partialTargetDuration_, this.lastTargetDuration_);
  3535.         } else {
  3536.           this.lastTargetDuration_ = Math.min(
  3537.               lastTargetDuration, this.lastTargetDuration_);
  3538.         }
  3539.       } else {
  3540.         this.lastTargetDuration_ = Math.min(
  3541.             this.partialTargetDuration_, this.lastTargetDuration_);
  3542.       }
  3543.       // Use 'PART-HOLD-BACK' as the presentation delay for low latency mode.
  3544.       this.lowLatencyPresentationDelay_ = serverControlTag ? Number(
  3545.           serverControlTag.getRequiredAttrValue('PART-HOLD-BACK')) : 0;
  3546.     } else {
  3547.       this.lastTargetDuration_ = Math.min(
  3548.           lastTargetDuration, this.lastTargetDuration_);
  3549.       // Use 'HOLD-BACK' as the presentation delay for default if defined.
  3550.       const holdBack = serverControlTag ?
  3551.           serverControlTag.getAttribute('HOLD-BACK') : null;
  3552.       this.presentationDelay_ = holdBack ? Number(holdBack.value) : 0;
  3553.     }
  3554.     // 2. Update the longest target duration if need be to use as a
  3555.     // presentation delay later.
  3556.     this.maxTargetDuration_ = Math.max(
  3557.         targetDuration, this.maxTargetDuration_);
  3558.   }
  3561.   /**
  3562.    * @param {!shaka.hls.Playlist} playlist
  3563.    * @private
  3564.    */
  3565.   changePresentationTimelineToLive_(playlist) {
  3566.     // The live edge will be calculated from segments, so we don't need to
  3567.     // set a presentation start time.  We will assert later that this is
  3568.     // working as expected.
  3570.     // The HLS spec (RFC 8216) states in 6.3.3:
  3571.     //
  3572.     // "The client SHALL choose which Media Segment to play first ... the
  3573.     // client SHOULD NOT choose a segment that starts less than three target
  3574.     // durations from the end of the Playlist file.  Doing so can trigger
  3575.     // playback stalls."
  3576.     //
  3577.     // We accomplish this in our DASH-y model by setting a presentation
  3578.     // delay of configured value, or 3 segments duration if not configured.
  3579.     // This will be the "live edge" of the presentation.
  3580.     let presentationDelay = 0;
  3581.     if (this.config_.defaultPresentationDelay) {
  3582.       presentationDelay = this.config_.defaultPresentationDelay;
  3583.     } else if (this.lowLatencyPresentationDelay_) {
  3584.       presentationDelay = this.lowLatencyPresentationDelay_;
  3585.     } else if (this.presentationDelay_) {
  3586.       presentationDelay = this.presentationDelay_;
  3587.     } else {
  3588.       const totalSegments = playlist.segments.length;
  3589.       let delaySegments = this.config_.hls.liveSegmentsDelay;
  3590.       if (delaySegments > (totalSegments - 2)) {
  3591.         delaySegments = Math.max(1, totalSegments - 2);
  3592.       }
  3593.       for (let i = totalSegments - delaySegments; i < totalSegments; i++) {
  3594.         const extinfTag = shaka.hls.Utils.getFirstTagWithName(
  3595.             playlist.segments[i].tags, 'EXTINF');
  3596.         if (extinfTag) {
  3597.           const extinfValues = extinfTag.value.split(',');
  3598.           const duration = Number(extinfValues[0]);
  3599.           presentationDelay += Math.ceil(duration);
  3600.         } else {
  3601.           presentationDelay += this.maxTargetDuration_;
  3602.         }
  3603.       }
  3604.     }
  3606.     if (this.startTime_ && this.startTime_ < 0) {
  3607.       presentationDelay = Math.min(-this.startTime_, presentationDelay);
  3608.       this.startTime_ += presentationDelay;
  3609.     }
  3611.     this.presentationTimeline_.setPresentationStartTime(0);
  3612.     this.presentationTimeline_.setDelay(presentationDelay);
  3613.     this.presentationTimeline_.setStatic(false);
  3614.   }
  3616.   /**
  3617.    * Get the InitSegmentReference for a segment if it has a EXT-X-MAP tag.
  3618.    * @param {!shaka.hls.Playlist} playlist
  3619.    * @param {!Array<!shaka.hls.Tag>} tags Segment tags
  3620.    * @param {function(): !Array<string>} getUris
  3621.    * @param {?Map<string, string>=} variables
  3622.    * @return {shaka.media.InitSegmentReference}
  3623.    * @private
  3624.    */
  3625.   getInitSegmentReference_(playlist, tags, getUris, variables) {
  3626.     /** @type {?shaka.hls.Tag} */
  3627.     const mapTag = shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-MAP');
  3629.     if (!mapTag) {
  3630.       return null;
  3631.     }
  3632.     // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
  3633.     const verbatimInitSegmentUri = mapTag.getRequiredAttrValue('URI');
  3634.     const absoluteInitSegmentUris = shaka.hls.Utils.constructSegmentUris(
  3635.         getUris(), verbatimInitSegmentUri, variables);
  3637.     const mapTagKey = [
  3638.       absoluteInitSegmentUris.toString(),
  3639.       mapTag.getAttributeValue('BYTERANGE', ''),
  3640.     ].join('-');
  3641.     if (!this.mapTagToInitSegmentRefMap_.has(mapTagKey)) {
  3642.       /** @type {shaka.extern.aesKey|undefined} */
  3643.       let aesKey = undefined;
  3644.       let byteRangeTag = null;
  3645.       let encrypted = false;
  3646.       for (const tag of tags) {
  3647.         if (tag.name == 'EXT-X-KEY') {
  3648.           const method = tag.getRequiredAttrValue('METHOD');
  3649.           if (this.isAesMethod_(method) && tag.id < mapTag.id) {
  3650.             encrypted = false;
  3651.             aesKey =
  3652.                 this.parseAESDrmTag_(tag, playlist, getUris, variables);
  3653.           } else {
  3654.             encrypted = method != 'NONE';
  3655.           }
  3656.         } else if (tag.name == 'EXT-X-BYTERANGE' && tag.id < mapTag.id) {
  3657.           byteRangeTag = tag;
  3658.         }
  3659.       }
  3660.       const initSegmentRef = this.createInitSegmentReference_(
  3661.           absoluteInitSegmentUris, mapTag, byteRangeTag, aesKey, encrypted);
  3662.       this.mapTagToInitSegmentRefMap_.set(mapTagKey, initSegmentRef);
  3663.     }
  3664.     return this.mapTagToInitSegmentRefMap_.get(mapTagKey);
  3665.   }
  3667.   /**
  3668.    * Create an InitSegmentReference object for the EXT-X-MAP tag in the media
  3669.    * playlist.
  3670.    * @param {!Array<string>} absoluteInitSegmentUris
  3671.    * @param {!shaka.hls.Tag} mapTag EXT-X-MAP
  3672.    * @param {shaka.hls.Tag=} byteRangeTag EXT-X-BYTERANGE
  3673.    * @param {shaka.extern.aesKey=} aesKey
  3674.    * @param {boolean=} encrypted
  3675.    * @return {!shaka.media.InitSegmentReference}
  3676.    * @private
  3677.    */
  3678.   createInitSegmentReference_(absoluteInitSegmentUris, mapTag, byteRangeTag,
  3679.       aesKey, encrypted) {
  3680.     let startByte = 0;
  3681.     let endByte = null;
  3682.     let byterange = mapTag.getAttributeValue('BYTERANGE');
  3683.     if (!byterange && byteRangeTag) {
  3684.       byterange = byteRangeTag.value;
  3685.     }
  3686.     // If a BYTERANGE attribute is not specified, the segment consists
  3687.     // of the entire resource.
  3688.     if (byterange) {
  3689.       const blocks = byterange.split('@');
  3690.       const byteLength = Number(blocks[0]);
  3691.       startByte = Number(blocks[1]);
  3692.       endByte = startByte + byteLength - 1;
  3694.       if (aesKey) {
  3695.         // MAP segment encrypted with method AES, when served with
  3696.         // HTTP Range, has the unencrypted size specified in the range.
  3697.         // See: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
  3698.         const length = (endByte + 1) - startByte;
  3699.         if (length % 16) {
  3700.           endByte += (16 - (length % 16));
  3701.         }
  3702.       }
  3703.     }
  3705.     const initSegmentRef = new shaka.media.InitSegmentReference(
  3706.         () => absoluteInitSegmentUris,
  3707.         startByte,
  3708.         endByte,
  3709.         /* mediaQuality= */ null,
  3710.         /* timescale= */ null,
  3711.         /* segmentData= */ null,
  3712.         aesKey,
  3713.         encrypted);
  3714.     return initSegmentRef;
  3715.   }
  3717.   /**
  3718.    * Parses one shaka.hls.Segment object into a shaka.media.SegmentReference.
  3719.    *
  3720.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  3721.    * @param {shaka.media.SegmentReference} previousReference
  3722.    * @param {!shaka.hls.Segment} hlsSegment
  3723.    * @param {number} startTime
  3724.    * @param {!Map<string, string>} variables
  3725.    * @param {!shaka.hls.Playlist} playlist
  3726.    * @param {string} type
  3727.    * @param {function(): !Array<string>} getUris
  3728.    * @param {shaka.extern.aesKey=} aesKey
  3729.    * @return {shaka.media.SegmentReference}
  3730.    * @private
  3731.    */
  3732.   createSegmentReference_(
  3733.       initSegmentReference, previousReference, hlsSegment, startTime,
  3734.       variables, playlist, type, getUris, aesKey) {
  3735.     const HlsParser = shaka.hls.HlsParser;
  3737.     const getMimeType = (uri) => {
  3738.       const parsedUri = new goog.Uri(uri);
  3739.       const extension = parsedUri.getPath().split('.').pop();
  3740.       const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_.get(type);
  3741.       let mimeType = map.get(extension);
  3742.       if (!mimeType) {
  3743.         mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_.get(extension);
  3744.       }
  3745.       return mimeType;
  3746.     };
  3748.     const tags = hlsSegment.tags;
  3749.     const extinfTag =
  3750.         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
  3752.     let endTime = 0;
  3753.     let startByte = 0;
  3754.     let endByte = null;
  3756.     if (hlsSegment.partialSegments.length) {
  3757.       this.manifest_.isLowLatency = true;
  3758.     }
  3760.     let syncTime = null;
  3761.     if (!this.config_.hls.ignoreManifestProgramDateTime) {
  3762.       const dateTimeTag =
  3763.           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
  3764.       if (dateTimeTag && dateTimeTag.value) {
  3765.         syncTime = shaka.util.TXml.parseDate(dateTimeTag.value);
  3766.         goog.asserts.assert(syncTime != null,
  3767.             'EXT-X-PROGRAM-DATE-TIME format not valid');
  3768.         this.usesProgramDateTime_ = true;
  3769.       }
  3770.     }
  3772.     let status = shaka.media.SegmentReference.Status.AVAILABLE;
  3773.     if (shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-GAP')) {
  3774.       this.manifest_.gapCount++;
  3775.       status = shaka.media.SegmentReference.Status.MISSING;
  3776.     }
  3778.     if (!extinfTag) {
  3779.       if (hlsSegment.partialSegments.length == 0) {
  3780.         // EXTINF tag must be available if the segment has no partial segments.
  3781.         throw new shaka.util.Error(
  3782.             shaka.util.Error.Severity.CRITICAL,
  3783.             shaka.util.Error.Category.MANIFEST,
  3784.             shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
  3785.       } else if (!this.lowLatencyMode_) {
  3786.         // Without EXTINF and without low-latency mode, partial segments get
  3787.         // ignored.
  3788.         return null;
  3789.       }
  3790.     }
  3792.     // Create SegmentReferences for the partial segments.
  3793.     let partialSegmentRefs = [];
  3795.     // Optimization for LL-HLS with byterange
  3796.     // More info in https://tinyurl.com/hls-open-byte-range
  3797.     let segmentWithByteRangeOptimization = false;
  3798.     let getUrisOptimization = null;
  3799.     let somePartialSegmentWithGap = false;
  3800.     let isPreloadSegment = false;
  3802.     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
  3803.       const byterangeOptimizationSupport =
  3804.           initSegmentReference && window.ReadableStream &&
  3805.           this.config_.hls.allowLowLatencyByteRangeOptimization;
  3807.       let partialSyncTime = syncTime;
  3808.       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
  3809.         const item = hlsSegment.partialSegments[i];
  3810.         const pPreviousReference = i == 0 ?
  3811.           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
  3812.         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
  3814.         // If DURATION is missing from this partial segment, use the target
  3815.         // partial duration from the top of the playlist, which is a required
  3816.         // attribute for content with partial segments.
  3817.         const pDuration = Number(item.getAttributeValue('DURATION')) ||
  3818.             this.partialTargetDuration_;
  3820.         // If for some reason we have neither an explicit duration, nor a target
  3821.         // partial duration, we should SKIP this partial segment to avoid
  3822.         // duplicating content in the presentation timeline.
  3823.         if (!pDuration) {
  3824.           continue;
  3825.         }
  3827.         const pEndTime = pStartTime + pDuration;
  3829.         let pStartByte = 0;
  3830.         let pEndByte = null;
  3831.         if (item.name == 'EXT-X-PRELOAD-HINT') {
  3832.           // A preload hinted partial segment may have byterange start info.
  3833.           const pByterangeStart = item.getAttributeValue('BYTERANGE-START');
  3834.           pStartByte = pByterangeStart ? Number(pByterangeStart) : 0;
  3835.           // A preload hinted partial segment may have byterange length info.
  3836.           const pByterangeLength = item.getAttributeValue('BYTERANGE-LENGTH');
  3837.           if (pByterangeLength) {
  3838.             pEndByte = pStartByte + Number(pByterangeLength) - 1;
  3839.           } else if (pStartByte) {
  3840.             // If we have a non-zero start byte, but no end byte, follow the
  3841.             // recommendation of https://tinyurl.com/hls-open-byte-range and
  3842.             // set the end byte explicitly to a large integer.
  3843.             pEndByte = Number.MAX_SAFE_INTEGER;
  3844.           }
  3845.         } else {
  3846.           const pByterange = item.getAttributeValue('BYTERANGE');
  3847.           [pStartByte, pEndByte] =
  3848.             this.parseByteRange_(pPreviousReference, pByterange);
  3849.         }
  3850.         const pUri = item.getAttributeValue('URI');
  3851.         if (!pUri) {
  3852.           continue;
  3853.         }
  3855.         let partialStatus = shaka.media.SegmentReference.Status.AVAILABLE;
  3856.         if (item.getAttributeValue('GAP') == 'YES') {
  3857.           this.manifest_.gapCount++;
  3858.           partialStatus = shaka.media.SegmentReference.Status.MISSING;
  3859.           somePartialSegmentWithGap = true;
  3860.         }
  3862.         let uris = null;
  3863.         const getPartialUris = () => {
  3864.           if (uris == null) {
  3865.             goog.asserts.assert(pUri, 'Partial uri should be defined!');
  3866.             uris = shaka.hls.Utils.constructSegmentUris(
  3867.                 getUris(), pUri, variables);
  3868.           }
  3869.           return uris;
  3870.         };
  3872.         if (byterangeOptimizationSupport &&
  3873.             pStartByte >= 0 && pEndByte != null) {
  3874.           getUrisOptimization = getPartialUris;
  3875.           segmentWithByteRangeOptimization = true;
  3876.         }
  3878.         const partial = new shaka.media.SegmentReference(
  3879.             pStartTime,
  3880.             pEndTime,
  3881.             getPartialUris,
  3882.             pStartByte,
  3883.             pEndByte,
  3884.             initSegmentReference,
  3885.             /* timestampOffset= */ 0,
  3886.             /* appendWindowStart= */ 0,
  3887.             /* appendWindowEnd= */ Infinity,
  3888.             /* partialReferences= */ [],
  3889.             /* tilesLayout= */ '',
  3890.             /* tileDuration= */ null,
  3891.             partialSyncTime,
  3892.             partialStatus,
  3893.             aesKey);
  3894.         if (item.name == 'EXT-X-PRELOAD-HINT') {
  3895.           partial.markAsPreload();
  3896.           isPreloadSegment = true;
  3897.         }
  3898.         // The spec doesn't say that we can assume INDEPENDENT=YES for the
  3899.         // first partial segment. It does call the flag "optional", though, and
  3900.         // that cases where there are no such flags on any partial segments, it
  3901.         // is sensible to assume the first one is independent.
  3902.         if (item.getAttributeValue('INDEPENDENT') != 'YES' && i > 0) {
  3903.           partial.markAsNonIndependent();
  3904.         }
  3906.         const pMimeType = getMimeType(pUri);
  3907.         if (pMimeType) {
  3908.           partial.mimeType = pMimeType;
  3909.           if (HlsParser.MIME_TYPES_WITHOUT_INIT_SEGMENT_.has(pMimeType)) {
  3910.             partial.initSegmentReference = null;
  3911.           }
  3912.         }
  3913.         partialSegmentRefs.push(partial);
  3915.         if (partialSyncTime) {
  3916.           partialSyncTime += pDuration;
  3917.         }
  3918.       } // for-loop of hlsSegment.partialSegments
  3919.     }
  3921.     // If the segment has EXTINF tag, set the segment's end time, start byte
  3922.     // and end byte based on the duration and byterange information.
  3923.     // Otherwise, calculate the end time, start / end byte based on its partial
  3924.     // segments.
  3925.     // Note that the sum of partial segments durations may be slightly different
  3926.     // from the parent segment's duration. In this case, use the duration from
  3927.     // the parent segment tag.
  3928.     if (extinfTag) {
  3929.       // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  3930.       // We're interested in the duration part.
  3931.       const extinfValues = extinfTag.value.split(',');
  3932.       const duration = Number(extinfValues[0]);
  3933.       // Skip segments without duration
  3934.       if (duration == 0) {
  3935.         return null;
  3936.       }
  3937.       endTime = startTime + duration;
  3938.     } else if (partialSegmentRefs.length) {
  3939.       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
  3940.     } else {
  3941.       // Skip segments without duration and without partial segments
  3942.       return null;
  3943.     }
  3945.     if (segmentWithByteRangeOptimization) {
  3946.       // We cannot optimize segments with gaps, or with a start byte that is
  3947.       // not 0.
  3948.       if (somePartialSegmentWithGap || partialSegmentRefs[0].startByte != 0) {
  3949.         segmentWithByteRangeOptimization = false;
  3950.         getUrisOptimization = null;
  3951.       } else {
  3952.         partialSegmentRefs = [];
  3953.       }
  3954.     }
  3956.     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
  3957.     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
  3958.     // and has partial segments, set the start byte and end byte base on the
  3959.     // partial segments.
  3960.     const byterangeTag =
  3961.          shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-BYTERANGE');
  3962.     if (byterangeTag) {
  3963.       [startByte, endByte] =
  3964.           this.parseByteRange_(previousReference, byterangeTag.value);
  3965.     } else if (partialSegmentRefs.length) {
  3966.       startByte = partialSegmentRefs[0].startByte;
  3967.       endByte = partialSegmentRefs[partialSegmentRefs.length - 1].endByte;
  3968.     }
  3970.     let tilesLayout = '';
  3971.     let tileDuration = null;
  3972.     if (type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
  3973.       // By default in HLS the tilesLayout is 1x1
  3974.       tilesLayout = '1x1';
  3975.       const tilesTag =
  3976.           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-TILES');
  3977.       if (tilesTag) {
  3978.         tilesLayout = tilesTag.getRequiredAttrValue('LAYOUT');
  3979.         const duration = tilesTag.getAttributeValue('DURATION');
  3980.         if (duration) {
  3981.           tileDuration = Number(duration);
  3982.         }
  3983.       }
  3984.     }
  3986.     let uris = null;
  3987.     const getSegmentUris = () => {
  3988.       if (getUrisOptimization) {
  3989.         return getUrisOptimization();
  3990.       }
  3991.       if (uris == null) {
  3992.         uris = shaka.hls.Utils.constructSegmentUris(getUris(),
  3993.             hlsSegment.verbatimSegmentUri, variables);
  3994.       }
  3995.       return uris || [];
  3996.     };
  3998.     const allPartialSegments = partialSegmentRefs.length > 0 &&
  3999.         !!hlsSegment.verbatimSegmentUri;
  4001.     const reference = new shaka.media.SegmentReference(
  4002.         startTime,
  4003.         endTime,
  4004.         getSegmentUris,
  4005.         startByte,
  4006.         endByte,
  4007.         initSegmentReference,
  4008.         /* timestampOffset= */ 0,
  4009.         /* appendWindowStart= */ 0,
  4010.         /* appendWindowEnd= */ Infinity,
  4011.         partialSegmentRefs,
  4012.         tilesLayout,
  4013.         tileDuration,
  4014.         syncTime,
  4015.         status,
  4016.         aesKey,
  4017.         allPartialSegments,
  4018.     );
  4020.     const mimeType = getMimeType(hlsSegment.verbatimSegmentUri);
  4021.     if (mimeType) {
  4022.       reference.mimeType = mimeType;
  4023.       if (HlsParser.MIME_TYPES_WITHOUT_INIT_SEGMENT_.has(mimeType)) {
  4024.         reference.initSegmentReference = null;
  4025.       }
  4026.     }
  4028.     if (segmentWithByteRangeOptimization) {
  4029.       this.lowLatencyByterangeOptimization_ = true;
  4030.       reference.markAsByterangeOptimization();
  4032.       if (isPreloadSegment) {
  4033.         reference.markAsPreload();
  4034.       }
  4035.     }
  4037.     return reference;
  4038.   }
  4041.   /**
  4042.    * Parse the startByte and endByte.
  4043.    * @param {shaka.media.SegmentReference} previousReference
  4044.    * @param {?string} byterange
  4045.    * @return {!Array<number>} An array with the start byte and end byte.
  4046.    * @private
  4047.    */
  4048.   parseByteRange_(previousReference, byterange) {
  4049.     let startByte = 0;
  4050.     let endByte = null;
  4051.     // If BYTERANGE is not specified, the segment consists of the entire
  4052.     // resource.
  4053.     if (byterange) {
  4054.       const blocks = byterange.split('@');
  4055.       const byteLength = Number(blocks[0]);
  4056.       if (blocks[1]) {
  4057.         startByte = Number(blocks[1]);
  4058.       } else {
  4059.         goog.asserts.assert(previousReference,
  4060.             'Cannot refer back to previous HLS segment!');
  4061.         startByte = previousReference.endByte + 1;
  4062.       }
  4063.       endByte = startByte + byteLength - 1;
  4064.     }
  4065.     return [startByte, endByte];
  4066.   }
  4068.   /**
  4069.    * @param {!Array<!shaka.hls.Tag>} tags
  4070.    * @param {string} contentType
  4071.    * @param {!Map<string, string>} variables
  4072.    * @param {function(): !Array<string>} getUris
  4073.    * @private
  4074.    */
  4075.   processDateRangeTags_(tags, contentType, variables, getUris) {
  4076.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  4077.     if (contentType != ContentType.VIDEO && contentType != ContentType.AUDIO) {
  4078.       // DATE-RANGE should only appear in AUDIO or VIDEO playlists.
  4079.       // We ignore those that appear in other playlists.
  4080.       return;
  4081.     }
  4082.     const Utils = shaka.hls.Utils;
  4083.     const initialProgramDateTime =
  4084.         this.presentationTimeline_.getInitialProgramDateTime();
  4085.     if (!initialProgramDateTime ||
  4086.         this.ignoreManifestProgramDateTimeFor_(contentType)) {
  4087.       return;
  4088.     }
  4089.     let dateRangeTags =
  4090.         shaka.hls.Utils.filterTagsByName(tags, 'EXT-X-DATERANGE');
  4091.     dateRangeTags = dateRangeTags.filter((tag) => {
  4092.       return tag.getAttribute('START-DATE') != null;
  4093.     }).sort((a, b) => {
  4094.       const aStartDateValue = a.getRequiredAttrValue('START-DATE');
  4095.       const bStartDateValue = b.getRequiredAttrValue('START-DATE');
  4096.       if (aStartDateValue < bStartDateValue) {
  4097.         return -1;
  4098.       }
  4099.       if (aStartDateValue > bStartDateValue) {
  4100.         return 1;
  4101.       }
  4102.       return 0;
  4103.     });
  4104.     for (let i = 0; i < dateRangeTags.length; i++) {
  4105.       const tag = dateRangeTags[i];
  4106.       try {
  4107.         const id = tag.getRequiredAttrValue('ID');
  4108.         if (this.dateRangeIdsEmitted_.has(id)) {
  4109.           continue;
  4110.         }
  4111.         const startDateValue = tag.getRequiredAttrValue('START-DATE');
  4112.         const startDate = shaka.util.TXml.parseDate(startDateValue);
  4113.         if (isNaN(startDate)) {
  4114.           // Invalid START-DATE
  4115.           continue;
  4116.         }
  4117.         goog.asserts.assert(startDate != null,
  4118.             'Start date should not be null!');
  4119.         const startTime = Math.max(0, startDate - initialProgramDateTime);
  4121.         let endTime = null;
  4122.         const endDateValue = tag.getAttributeValue('END-DATE');
  4123.         if (endDateValue) {
  4124.           const endDate = shaka.util.TXml.parseDate(endDateValue);
  4125.           if (!isNaN(endDate)) {
  4126.             goog.asserts.assert(endDate != null,
  4127.                 'End date should not be null!');
  4128.             endTime = endDate - initialProgramDateTime;
  4129.             if (endTime < 0) {
  4130.               // Date range in the past
  4131.               continue;
  4132.             }
  4133.           }
  4134.         }
  4135.         if (endTime == null) {
  4136.           const durationValue = tag.getAttributeValue('DURATION') ||
  4137.               tag.getAttributeValue('PLANNED-DURATION');
  4138.           if (durationValue) {
  4139.             const duration = parseFloat(durationValue);
  4140.             if (!isNaN(duration)) {
  4141.               endTime = startTime + duration;
  4142.             }
  4143.             const realEndTime = startDate - initialProgramDateTime + duration;
  4144.             if (realEndTime < 0) {
  4145.               // Date range in the past
  4146.               continue;
  4147.             }
  4148.           }
  4149.         }
  4150.         const type =
  4151.             tag.getAttributeValue('CLASS') || 'com.apple.quicktime.HLS';
  4153.         const endOnNext = tag.getAttributeValue('END-ON-NEXT') == 'YES';
  4154.         if (endTime == null && endOnNext) {
  4155.           for (let j = i + 1; j < dateRangeTags.length; j++) {
  4156.             const otherDateRangeType =
  4157.                 dateRangeTags[j].getAttributeValue('CLASS') ||
  4158.                 'com.apple.quicktime.HLS';
  4159.             if (type != otherDateRangeType) {
  4160.               continue;
  4161.             }
  4162.             const otherDateRangeStartDateValue =
  4163.                 dateRangeTags[j].getRequiredAttrValue('START-DATE');
  4164.             const otherDateRangeStartDate =
  4165.                 shaka.util.TXml.parseDate(otherDateRangeStartDateValue);
  4166.             if (isNaN(otherDateRangeStartDate)) {
  4167.               // Invalid START-DATE
  4168.               continue;
  4169.             }
  4170.             if (otherDateRangeStartDate &&
  4171.                 otherDateRangeStartDate > startDate) {
  4172.               endTime = Math.max(0,
  4173.                   otherDateRangeStartDate - initialProgramDateTime);
  4174.               break;
  4175.             }
  4176.           }
  4177.           if (endTime == null) {
  4178.             // Since we cannot know when it ends, we omit it for now and in the
  4179.             // future with an update we will be able to have more information.
  4180.             continue;
  4181.           }
  4182.         }
  4184.         // Exclude these attributes from the metadata since they already go into
  4185.         // other fields (eg: startTime or endTime) or are not necessary..
  4186.         const excludedAttributes = [
  4187.           'CLASS',
  4188.           'START-DATE',
  4189.           'END-DATE',
  4190.           'DURATION',
  4191.           'END-ON-NEXT',
  4192.         ];
  4194.         /* @type {!Array<shaka.extern.MetadataFrame>} */
  4195.         const values = [];
  4196.         for (const attribute of tag.attributes) {
  4197.           if (excludedAttributes.includes(attribute.name)) {
  4198.             continue;
  4199.           }
  4200.           let data = Utils.variableSubstitution(attribute.value, variables);
  4201.           if (attribute.name == 'X-ASSET-URI' ||
  4202.               attribute.name == 'X-ASSET-LIST') {
  4203.             data = Utils.constructSegmentUris(
  4204.                 getUris(), attribute.value, variables)[0];
  4205.           }
  4206.           const metadataFrame = {
  4207.             key: attribute.name,
  4208.             description: '',
  4209.             data,
  4210.             mimeType: null,
  4211.             pictureType: null,
  4212.           };
  4213.           values.push(metadataFrame);
  4214.         }
  4216.         // ID is always required. So we need more than 1 value.
  4217.         if (values.length > 1) {
  4218.           this.playerInterface_.onMetadata(type, startTime, endTime, values);
  4219.         }
  4221.         this.dateRangeIdsEmitted_.add(id);
  4222.       } catch (e) {
  4223.         shaka.log.warning('Ignoring DATERANGE with errors', tag.toString());
  4224.       }
  4225.     }
  4226.   }
  4228.   /**
  4229.    * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences and
  4230.    * get the bandwidth necessary for this segments If it's defined in the
  4231.    * playlist.
  4232.    *
  4233.    * @param {!shaka.hls.Playlist} playlist
  4234.    * @param {!Map<number, number>} mediaSequenceToStartTime
  4235.    * @param {!Map<string, string>} variables
  4236.    * @param {function(): !Array<string>} getUris
  4237.    * @param {string} type
  4238.    * @return {{segments: !Array<!shaka.media.SegmentReference>,
  4239.    *          bandwidth: (number|undefined)}}
  4240.    * @private
  4241.    */
  4242.   createSegments_(playlist, mediaSequenceToStartTime, variables,
  4243.       getUris, type) {
  4244.     /** @type {Array<!shaka.hls.Segment>} */
  4245.     const hlsSegments = playlist.segments;
  4246.     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
  4248.     /** @type {shaka.media.InitSegmentReference} */
  4249.     let initSegmentRef;
  4251.     /** @type {shaka.extern.aesKey|undefined} */
  4252.     let aesKey = undefined;
  4254.     let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  4255.         playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', -1);
  4256.     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  4257.         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  4258.     const skipTag = shaka.hls.Utils.getFirstTagWithName(
  4259.         playlist.tags, 'EXT-X-SKIP');
  4260.     const skippedSegments =
  4261.         skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
  4262.     let position = mediaSequenceNumber + skippedSegments;
  4263.     let firstStartTime = 0;
  4265.     // For live stream, use the cached value in the mediaSequenceToStartTime
  4266.     // map if available.
  4267.     if (this.isLive_() && mediaSequenceToStartTime.has(position)) {
  4268.       firstStartTime = mediaSequenceToStartTime.get(position);
  4269.     }
  4270.     // This is for recovering from disconnects.
  4271.     if (firstStartTime === 0 &&
  4272.         this.presentationType_ == shaka.hls.HlsParser.PresentationType_.LIVE &&
  4273.         mediaSequenceToStartTime.size > 0 &&
  4274.         !mediaSequenceToStartTime.has(position) &&
  4275.         this.presentationTimeline_.getPresentationStartTime() != null) {
  4276.       firstStartTime = this.presentationTimeline_.getSegmentAvailabilityStart();
  4277.     }
  4279.     /** @type {!Array<!shaka.media.SegmentReference>} */
  4280.     const references = [];
  4282.     let previousReference = null;
  4284.     /** @type {!Array<{bitrate: number, duration: number}>} */
  4285.     const bitrates = [];
  4287.     for (let i = 0; i < hlsSegments.length; i++) {
  4288.       const item = hlsSegments[i];
  4289.       const startTime =
  4290.           (i == 0) ? firstStartTime : previousReference.endTime;
  4291.       position = mediaSequenceNumber + skippedSegments + i;
  4293.       const discontinuityTag = shaka.hls.Utils.getFirstTagWithName(
  4294.           item.tags, 'EXT-X-DISCONTINUITY');
  4295.       if (discontinuityTag) {
  4296.         discontinuitySequence++;
  4298.         if (previousReference && previousReference.initSegmentReference) {
  4299.           previousReference.initSegmentReference.boundaryEnd = startTime;
  4300.         }
  4301.       }
  4303.       // Apply new AES tags as you see them, keeping a running total.
  4304.       for (const drmTag of item.tags) {
  4305.         if (drmTag.name == 'EXT-X-KEY') {
  4306.           if (this.isAesMethod_(drmTag.getRequiredAttrValue('METHOD'))) {
  4307.             aesKey =
  4308.                 this.parseAESDrmTag_(drmTag, playlist, getUris, variables);
  4309.           } else {
  4310.             aesKey = undefined;
  4311.           }
  4312.         }
  4313.       }
  4315.       mediaSequenceToStartTime.set(position, startTime);
  4317.       initSegmentRef = this.getInitSegmentReference_(playlist,
  4318.           item.tags, getUris, variables);
  4320.       const reference = this.createSegmentReference_(
  4321.           initSegmentRef,
  4322.           previousReference,
  4323.           item,
  4324.           startTime,
  4325.           variables,
  4326.           playlist,
  4327.           type,
  4328.           getUris,
  4329.           aesKey);
  4331.       if (reference) {
  4332.         const bitrate = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  4333.             item.tags, 'EXT-X-BITRATE');
  4334.         if (bitrate) {
  4335.           bitrates.push({
  4336.             bitrate,
  4337.             duration: reference.endTime - reference.startTime,
  4338.           });
  4339.         } else if (bitrates.length) {
  4340.           // It applies to every segment between it and the next EXT-X-BITRATE,
  4341.           // so we use the latest bitrate value
  4342.           const prevBitrate = bitrates.pop();
  4343.           prevBitrate.duration += reference.endTime - reference.startTime;
  4344.           bitrates.push(prevBitrate);
  4345.         }
  4347.         previousReference = reference;
  4348.         reference.discontinuitySequence = discontinuitySequence;
  4350.         if (this.ignoreManifestProgramDateTimeFor_(type) &&
  4351.             this.minSequenceNumber_ != null &&
  4352.             position < this.minSequenceNumber_) {
  4353.           // This segment is ignored as part of our fallback synchronization
  4354.           // method.
  4355.         } else {
  4356.           references.push(reference);
  4357.         }
  4358.       }
  4359.     }
  4361.     let bandwidth = undefined;
  4362.     if (bitrates.length) {
  4363.       const duration = bitrates.reduce((sum, value) => {
  4364.         return sum + value.duration;
  4365.       }, 0);
  4366.       bandwidth = Math.round(bitrates.reduce((sum, value) => {
  4367.         return sum + value.bitrate * value.duration;
  4368.       }, 0) / duration * 1000);
  4369.     }
  4371.     // If some segments have sync times, but not all, extrapolate the sync
  4372.     // times of the ones with none.
  4373.     const someSyncTime = references.some((ref) => ref.syncTime != null);
  4374.     if (someSyncTime) {
  4375.       for (let i = 0; i < references.length; i++) {
  4376.         const reference = references[i];
  4377.         if (reference.syncTime != null) {
  4378.           // No need to extrapolate.
  4379.           continue;
  4380.         }
  4381.         // Find the nearest segment with syncTime, in either direction.
  4382.         // This looks forward and backward simultaneously, keeping track of what
  4383.         // to offset the syncTime it finds by as it goes.
  4384.         let forwardAdd = 0;
  4385.         let forwardI = i;
  4386.         /**
  4387.          * Look forwards one reference at a time, summing all durations as we
  4388.          * go, until we find a reference with a syncTime to use as a basis.
  4389.          * This DOES count the original reference, but DOESN'T count the first
  4390.          * reference with a syncTime (as we approach it from behind).
  4391.          * @return {?number}
  4392.          */
  4393.         const lookForward = () => {
  4394.           const other = references[forwardI];
  4395.           if (other) {
  4396.             if (other.syncTime != null) {
  4397.               return other.syncTime + forwardAdd;
  4398.             }
  4399.             forwardAdd -= other.endTime - other.startTime;
  4400.             forwardI += 1;
  4401.           }
  4402.           return null;
  4403.         };
  4404.         let backwardAdd = 0;
  4405.         let backwardI = i;
  4406.         /**
  4407.          * Look backwards one reference at a time, summing all durations as we
  4408.          * go, until we find a reference with a syncTime to use as a basis.
  4409.          * This DOESN'T count the original reference, but DOES count the first
  4410.          * reference with a syncTime (as we approach it from ahead).
  4411.          * @return {?number}
  4412.          */
  4413.         const lookBackward = () => {
  4414.           const other = references[backwardI];
  4415.           if (other) {
  4416.             if (other != reference) {
  4417.               backwardAdd += other.endTime - other.startTime;
  4418.             }
  4419.             if (other.syncTime != null) {
  4420.               return other.syncTime + backwardAdd;
  4421.             }
  4422.             backwardI -= 1;
  4423.           }
  4424.           return null;
  4425.         };
  4426.         while (reference.syncTime == null) {
  4427.           reference.syncTime = lookBackward();
  4428.           if (reference.syncTime == null) {
  4429.             reference.syncTime = lookForward();
  4430.           }
  4431.         }
  4432.       }
  4433.     }
  4435.     // Split the sync times properly among partial segments.
  4436.     if (someSyncTime) {
  4437.       for (const reference of references) {
  4438.         let syncTime = reference.syncTime;
  4439.         for (const partial of reference.partialReferences) {
  4440.           partial.syncTime = syncTime;
  4441.           syncTime += partial.endTime - partial.startTime;
  4442.         }
  4443.       }
  4444.     }
  4446.     // lowestSyncTime is a value from a previous playlist update.  Use it to
  4447.     // set reference start times.  If this is the first playlist parse, we will
  4448.     // skip this step, and wait until we have sync time across stream types.
  4449.     const lowestSyncTime = this.lowestSyncTime_;
  4450.     if (someSyncTime && lowestSyncTime != Infinity) {
  4451.       if (!this.ignoreManifestProgramDateTimeFor_(type)) {
  4452.         for (const reference of references) {
  4453.           reference.syncAgainst(lowestSyncTime);
  4454.         }
  4455.       }
  4456.     }
  4458.     return {
  4459.       segments: references,
  4460.       bandwidth,
  4461.     };
  4462.   }
  4464.   /**
  4465.    * Attempts to guess stream's mime type based on content type and URI.
  4466.    *
  4467.    * @param {string} contentType
  4468.    * @param {string} codecs
  4469.    * @return {?string}
  4470.    * @private
  4471.    */
  4472.   guessMimeTypeBeforeLoading_(contentType, codecs) {
  4473.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  4474.       if (codecs == 'vtt' || codecs == 'wvtt') {
  4475.         // If codecs is 'vtt', it's WebVTT.
  4476.         return 'text/vtt';
  4477.       } else if (codecs && codecs !== '') {
  4478.         // Otherwise, assume MP4-embedded text, since text-based formats tend
  4479.         // not to have a codecs string at all.
  4480.         return 'application/mp4';
  4481.       }
  4482.     }
  4484.     if (contentType == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
  4485.       if (!codecs || codecs == 'jpeg') {
  4486.         return 'image/jpeg';
  4487.       }
  4488.     }
  4490.     if (contentType == shaka.util.ManifestParserUtils.ContentType.AUDIO) {
  4491.       // See: https://bugs.chromium.org/p/chromium/issues/detail?id=489520
  4492.       if (codecs == 'mp4a.40.34') {
  4493.         return 'audio/mpeg';
  4494.       }
  4495.     }
  4497.     if (codecs == 'mjpg') {
  4498.       return 'application/mp4';
  4499.     }
  4501.     // Not enough information to guess from the content type and codecs.
  4502.     return null;
  4503.   }
  4505.   /**
  4506.    * Get a fallback mime type for the content. Used if all the better methods
  4507.    * for determining the mime type have failed.
  4508.    *
  4509.    * @param {string} contentType
  4510.    * @return {string}
  4511.    * @private
  4512.    */
  4513.   guessMimeTypeFallback_(contentType) {
  4514.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  4515.       // If there was no codecs string and no content-type, assume HLS text
  4516.       // streams are WebVTT.
  4517.       return 'text/vtt';
  4518.     }
  4519.     // If the HLS content is lacking in both MIME type metadata and
  4520.     // segment file extensions, we fall back to assuming it's MP4.
  4521.     const map =
  4522.         shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_.get(contentType);
  4523.     return map.get('mp4');
  4524.   }
  4526.   /**
  4527.    * @param {!Array<!shaka.media.SegmentReference>} segments
  4528.    * @return {{segment: !shaka.media.SegmentReference, segmentIndex: number}}
  4529.    * @private
  4530.    */
  4531.   getAvailableSegment_(segments) {
  4532.     goog.asserts.assert(segments.length, 'Should have segments!');
  4534.     // If you wait long enough, requesting the first segment can fail
  4535.     // because it has fallen off the left edge of DVR, so to be safer,
  4536.     // let's request the middle segment.
  4537.     let segmentIndex = this.isLive_() ?
  4538.         Math.trunc((segments.length - 1) / 2) : 0;
  4539.     let segment = segments[segmentIndex];
  4540.     while (segment.getStatus() == shaka.media.SegmentReference.Status.MISSING &&
  4541.         (segmentIndex + 1) < segments.length) {
  4542.       segmentIndex ++;
  4543.       segment = segments[segmentIndex];
  4544.     }
  4545.     return {segment, segmentIndex};
  4546.   }
  4548.   /**
  4549.    * Attempts to guess stream's mime type.
  4550.    *
  4551.    * @param {string} contentType
  4552.    * @param {string} codecs
  4553.    * @param {!Array<!shaka.media.SegmentReference>} segments
  4554.    * @return {!Promise<string>}
  4555.    * @private
  4556.    */
  4557.   async guessMimeType_(contentType, codecs, segments) {
  4558.     const HlsParser = shaka.hls.HlsParser;
  4559.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  4561.     const {segment} = this.getAvailableSegment_(segments);
  4563.     if (segment.status == shaka.media.SegmentReference.Status.MISSING) {
  4564.       return this.guessMimeTypeFallback_(contentType);
  4565.     }
  4567.     const segmentUris = segment.getUris();
  4569.     const parsedUri = new goog.Uri(segmentUris[0]);
  4570.     const extension = parsedUri.getPath().split('.').pop();
  4571.     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_.get(contentType);
  4573.     let mimeType = map.get(extension);
  4574.     if (mimeType) {
  4575.       return mimeType;
  4576.     }
  4578.     mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_.get(extension);
  4579.     if (mimeType) {
  4580.       return mimeType;
  4581.     }
  4583.     // The extension map didn't work, so guess based on codecs.
  4584.     mimeType = this.guessMimeTypeBeforeLoading_(contentType, codecs);
  4585.     if (mimeType) {
  4586.       return mimeType;
  4587.     }
  4589.     // If unable to guess mime type, request a segment and try getting it
  4590.     // from the response.
  4591.     let contentMimeType;
  4592.     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
  4593.     const headRequest = shaka.net.NetworkingEngine.makeRequest(
  4594.         segmentUris, this.config_.retryParameters);
  4595.     let response;
  4596.     try {
  4597.       headRequest.method = 'HEAD';
  4598.       response = await this.makeNetworkRequest_(
  4599.           headRequest, requestType, {type}).promise;
  4601.       contentMimeType = response.headers['content-type'];
  4602.     } catch (error) {
  4603.       if (error &&
  4604.         (error.code == shaka.util.Error.Code.HTTP_ERROR ||
  4605.          error.code == shaka.util.Error.Code.BAD_HTTP_STATUS)) {
  4606.         headRequest.method = 'GET';
  4607.         if (this.config_.hls.allowRangeRequestsToGuessMimeType) {
  4608.           // Only requesting first byte
  4609.           headRequest.headers['Range'] = 'bytes=0-0';
  4610.         }
  4611.         response = await this.makeNetworkRequest_(
  4612.             headRequest, requestType, {type}).promise;
  4614.         contentMimeType = response.headers['content-type'];
  4615.       }
  4616.     }
  4618.     if (contentMimeType) {
  4619.       // Split the MIME type in case the server sent additional parameters.
  4620.       mimeType = contentMimeType.toLowerCase().split(';')[0];
  4621.       if (mimeType == 'application/octet-stream') {
  4622.         if (!response.data.byteLength) {
  4623.           headRequest.method = 'GET';
  4624.           response = await this.makeNetworkRequest_(
  4625.               headRequest, requestType, {type}).promise;
  4626.         }
  4627.         if (shaka.util.TsParser.probe(
  4628.             shaka.util.BufferUtils.toUint8(response.data))) {
  4629.           mimeType = 'video/mp2t';
  4630.         }
  4631.       }
  4632.       if (mimeType != 'application/octet-stream') {
  4633.         return mimeType;
  4634.       }
  4635.     }
  4637.     return this.guessMimeTypeFallback_(contentType);
  4638.   }
  4640.   /**
  4641.    * Returns a tag with a given name.
  4642.    * Throws an error if tag was not found.
  4643.    *
  4644.    * @param {!Array<shaka.hls.Tag>} tags
  4645.    * @param {string} tagName
  4646.    * @return {!shaka.hls.Tag}
  4647.    * @private
  4648.    */
  4649.   getRequiredTag_(tags, tagName) {
  4650.     const tag = shaka.hls.Utils.getFirstTagWithName(tags, tagName);
  4651.     if (!tag) {
  4652.       throw new shaka.util.Error(
  4653.           shaka.util.Error.Severity.CRITICAL,
  4654.           shaka.util.Error.Category.MANIFEST,
  4655.           shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, tagName);
  4656.     }
  4658.     return tag;
  4659.   }
  4661.   /**
  4662.    * @param {shaka.extern.Stream} stream
  4663.    * @param {?string} width
  4664.    * @param {?string} height
  4665.    * @param {?string} frameRate
  4666.    * @param {?string} videoRange
  4667.    * @param {?string} videoLayout
  4668.    * @param {?string} colorGamut
  4669.    * @private
  4670.    */
  4671.   addVideoAttributes_(stream, width, height, frameRate, videoRange,
  4672.       videoLayout, colorGamut) {
  4673.     if (stream) {
  4674.       stream.width = Number(width) || undefined;
  4675.       stream.height = Number(height) || undefined;
  4676.       stream.frameRate = Number(frameRate) || undefined;
  4677.       stream.hdr = videoRange || undefined;
  4678.       stream.videoLayout = videoLayout || undefined;
  4679.       stream.colorGamut = colorGamut || undefined;
  4680.     }
  4681.   }
  4683.   /**
  4684.    * Makes a network request for the manifest and returns a Promise
  4685.    * with the resulting data.
  4686.    *
  4687.    * @param {!Array<string>} uris
  4688.    * @param {boolean=} isPlaylist
  4689.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  4690.    * @private
  4691.    */
  4692.   requestManifest_(uris, isPlaylist) {
  4693.     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  4695.     const request = shaka.net.NetworkingEngine.makeRequest(
  4696.         uris, this.config_.retryParameters);
  4698.     const type = isPlaylist ?
  4699.         shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_PLAYLIST :
  4700.         shaka.net.NetworkingEngine.AdvancedRequestType.MASTER_PLAYLIST;
  4701.     return this.makeNetworkRequest_(request, requestType, {type});
  4702.   }
  4704.   /**
  4705.    * Called when the update timer ticks. Because parsing a manifest is async,
  4706.    * this method is async. To work with this, this method will schedule the next
  4707.    * update when it finished instead of using a repeating-start.
  4708.    *
  4709.    * @return {!Promise}
  4710.    * @private
  4711.    */
  4712.   async onUpdate_() {
  4713.     shaka.log.info('Updating manifest...');
  4715.     goog.asserts.assert(
  4716.         this.getUpdatePlaylistDelay_() > 0,
  4717.         'We should only call |onUpdate_| when we are suppose to be updating.');
  4719.     // Detect a call to stop()
  4720.     if (!this.playerInterface_) {
  4721.       return;
  4722.     }
  4724.     try {
  4725.       const startTime = Date.now();
  4726.       await this.update();
  4728.       // Keep track of how long the longest manifest update took.
  4729.       const endTime = Date.now();
  4731.       // This may have converted to VOD, in which case we stop updating.
  4732.       if (this.isLive_()) {
  4733.         const updateDuration = (endTime - startTime) / 1000.0;
  4734.         this.averageUpdateDuration_.sample(1, updateDuration);
  4735.         const delay = this.config_.updatePeriod > 0 ?
  4736.             this.config_.updatePeriod : this.getUpdatePlaylistDelay_();
  4737.         const finalDelay = Math.max(0,
  4738.             delay - this.averageUpdateDuration_.getEstimate());
  4739.         this.updatePlaylistTimer_.tickAfter(/* seconds= */ finalDelay);
  4740.       }
  4741.     } catch (error) {
  4742.       // Detect a call to stop() during this.update()
  4743.       if (!this.playerInterface_) {
  4744.         return;
  4745.       }
  4747.       goog.asserts.assert(error instanceof shaka.util.Error,
  4748.           'Should only receive a Shaka error');
  4750.       if (this.config_.raiseFatalErrorOnManifestUpdateRequestFailure) {
  4751.         this.playerInterface_.onError(error);
  4752.         return;
  4753.       }
  4755.       // We will retry updating, so override the severity of the error.
  4756.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  4757.       this.playerInterface_.onError(error);
  4759.       // Try again very soon.
  4760.       this.updatePlaylistTimer_.tickAfter(/* seconds= */ 0.1);
  4761.     }
  4763.     // Detect a call to stop()
  4764.     if (!this.playerInterface_) {
  4765.       return;
  4766.     }
  4768.     this.playerInterface_.onManifestUpdated();
  4769.   }
  4772.   /**
  4773.    * @return {boolean}
  4774.    * @private
  4775.    */
  4776.   isLive_() {
  4777.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  4778.     return this.presentationType_ != PresentationType.VOD;
  4779.   }
  4782.   /**
  4783.    * @return {number}
  4784.    * @private
  4785.    */
  4786.   getUpdatePlaylistDelay_() {
  4787.     // The HLS spec (RFC 8216) states in 6.3.4:
  4788.     // "the client MUST wait for at least the target duration before
  4789.     // attempting to reload the Playlist file again".
  4790.     // For LL-HLS, the server must add a new partial segment to the Playlist
  4791.     // every part target duration.
  4792.     return this.lastTargetDuration_;
  4793.   }
  4796.   /**
  4797.    * @param {shaka.hls.HlsParser.PresentationType_} type
  4798.    * @private
  4799.    */
  4800.   setPresentationType_(type) {
  4801.     this.presentationType_ = type;
  4803.     if (this.presentationTimeline_) {
  4804.       this.presentationTimeline_.setStatic(!this.isLive_());
  4805.     }
  4807.     // If this manifest is not for live content, then we have no reason to
  4808.     // update it.
  4809.     if (!this.isLive_()) {
  4810.       this.updatePlaylistTimer_.stop();
  4811.     }
  4812.   }
  4815.   /**
  4816.    * Create a networking request. This will manage the request using the
  4817.    * parser's operation manager. If the parser has already been stopped, the
  4818.    * request will not be made.
  4819.    *
  4820.    * @param {shaka.extern.Request} request
  4821.    * @param {shaka.net.NetworkingEngine.RequestType} type
  4822.    * @param {shaka.extern.RequestContext=} context
  4823.    * @return {!shaka.net.NetworkingEngine.PendingRequest}
  4824.    * @private
  4825.    */
  4826.   makeNetworkRequest_(request, type, context) {
  4827.     if (!this.operationManager_) {
  4828.       throw new shaka.util.Error(
  4829.           shaka.util.Error.Severity.CRITICAL,
  4830.           shaka.util.Error.Category.PLAYER,
  4831.           shaka.util.Error.Code.OPERATION_ABORTED);
  4832.     }
  4834.     if (!context) {
  4835.       context = {};
  4836.     }
  4837.     context.isPreload = this.isPreloadFn_();
  4838.     const op = this.playerInterface_.networkingEngine.request(
  4839.         type, request, context);
  4840.     this.operationManager_.manage(op);
  4842.     return op;
  4843.   }
  4845.   /**
  4846.    * @param {string} method
  4847.    * @return {boolean}
  4848.    * @private
  4849.    */
  4850.   isAesMethod_(method) {
  4851.     return method == 'AES-128' ||
  4852.         method == 'AES-256' ||
  4853.         method == 'AES-256-CTR';
  4854.   }
  4856.   /**
  4857.    * @param {!shaka.hls.Tag} drmTag
  4858.    * @param {string} mimeType
  4859.    * @param {?shaka.media.InitSegmentReference} initSegmentRef
  4860.    * @return {!Promise<?shaka.extern.DrmInfo>}
  4861.    * @private
  4862.    */
  4863.   async fairplayDrmParser_(drmTag, mimeType, initSegmentRef) {
  4864.     if (mimeType == 'video/mp2t') {
  4865.       throw new shaka.util.Error(
  4866.           shaka.util.Error.Severity.CRITICAL,
  4867.           shaka.util.Error.Category.MANIFEST,
  4868.           shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
  4869.     }
  4871.     if (shaka.drm.DrmUtils.isMediaKeysPolyfilled('apple')) {
  4872.       throw new shaka.util.Error(
  4873.           shaka.util.Error.Severity.CRITICAL,
  4874.           shaka.util.Error.Category.MANIFEST,
  4875.           shaka.util.Error.Code
  4876.               .HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
  4877.     }
  4879.     const method = drmTag.getRequiredAttrValue('METHOD');
  4880.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4881.     if (!VALID_METHODS.includes(method)) {
  4882.       shaka.log.error('FairPlay in HLS is only supported with [',
  4883.           VALID_METHODS.join(', '), '], not', method);
  4884.       return null;
  4885.     }
  4887.     let encryptionScheme = 'cenc';
  4888.     if (method == 'SAMPLE-AES') {
  4889.       // It should be 'cbcs-1-9' but Safari doesn't support it.
  4890.       // See: https://github.com/WebKit/WebKit/blob/main/Source/WebCore/Modules/encryptedmedia/MediaKeyEncryptionScheme.idl
  4891.       encryptionScheme = 'cbcs';
  4892.     }
  4894.     const uri = drmTag.getRequiredAttrValue('URI');
  4896.     /*
  4897.      * Even if we're not able to construct initData through the HLS tag, adding
  4898.      * a DRMInfo will allow DRM Engine to request a media key system access
  4899.      * with the correct keySystem and initDataType
  4900.      */
  4901.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4902.         'com.apple.fps', encryptionScheme, [
  4903.           {initDataType: 'sinf', initData: new Uint8Array(0), keyId: null},
  4904.         ], uri);
  4906.     let keyId = shaka.drm.FairPlay.defaultGetKeyId(uri);
  4907.     if (!keyId && initSegmentRef) {
  4908.       keyId = await this.getKeyIdFromInitSegment_(initSegmentRef);
  4909.     }
  4910.     if (keyId) {
  4911.       drmInfo.keyIds.add(keyId);
  4912.     }
  4914.     return drmInfo;
  4915.   }
  4917.   /**
  4918.    * @param {!shaka.hls.Tag} drmTag
  4919.    * @param {string} mimeType
  4920.    * @param {?shaka.media.InitSegmentReference} initSegmentRef
  4921.    * @return {!Promise<?shaka.extern.DrmInfo>}
  4922.    * @private
  4923.    */
  4924.   widevineDrmParser_(drmTag, mimeType, initSegmentRef) {
  4925.     const method = drmTag.getRequiredAttrValue('METHOD');
  4926.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4927.     if (!VALID_METHODS.includes(method)) {
  4928.       shaka.log.error('Widevine in HLS is only supported with [',
  4929.           VALID_METHODS.join(', '), '], not', method);
  4930.       return Promise.resolve(null);
  4931.     }
  4933.     let encryptionScheme = 'cenc';
  4934.     if (method == 'SAMPLE-AES') {
  4935.       encryptionScheme = 'cbcs';
  4936.     }
  4938.     const uri = drmTag.getRequiredAttrValue('URI');
  4939.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri.split('?')[0]);
  4941.     // The data encoded in the URI is a PSSH box to be used as init data.
  4942.     const pssh = shaka.util.BufferUtils.toUint8(parsedData.data);
  4943.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4944.         'com.widevine.alpha', encryptionScheme, [
  4945.           {initDataType: 'cenc', initData: pssh},
  4946.         ]);
  4948.     const keyId = drmTag.getAttributeValue('KEYID');
  4949.     if (keyId) {
  4950.       const keyIdLowerCase = keyId.toLowerCase();
  4951.       // This value should begin with '0x':
  4952.       goog.asserts.assert(
  4953.           keyIdLowerCase.startsWith('0x'), 'Incorrect KEYID format!');
  4954.       // But the output should not contain the '0x':
  4955.       drmInfo.keyIds.add(keyIdLowerCase.substr(2));
  4956.     }
  4957.     return Promise.resolve(drmInfo);
  4958.   }
  4960.   /**
  4961.    * See: https://docs.microsoft.com/en-us/playready/packaging/mp4-based-formats-supported-by-playready-clients?tabs=case4
  4962.    *
  4963.    * @param {!shaka.hls.Tag} drmTag
  4964.    * @param {string} mimeType
  4965.    * @param {?shaka.media.InitSegmentReference} initSegmentRef
  4966.    * @return {!Promise<?shaka.extern.DrmInfo>}
  4967.    * @private
  4968.    */
  4969.   playreadyDrmParser_(drmTag, mimeType, initSegmentRef) {
  4970.     const method = drmTag.getRequiredAttrValue('METHOD');
  4971.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4972.     if (!VALID_METHODS.includes(method)) {
  4973.       shaka.log.error('PlayReady in HLS is only supported with [',
  4974.           VALID_METHODS.join(', '), '], not', method);
  4975.       return Promise.resolve(null);
  4976.     }
  4978.     let encryptionScheme = 'cenc';
  4979.     if (method == 'SAMPLE-AES') {
  4980.       encryptionScheme = 'cbcs';
  4981.     }
  4983.     const uri = drmTag.getRequiredAttrValue('URI');
  4984.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri.split('?')[0]);
  4986.     // The data encoded in the URI is a PlayReady Pro Object, so we need
  4987.     // convert it to pssh.
  4988.     const data = shaka.util.BufferUtils.toUint8(parsedData.data);
  4989.     const systemId = new Uint8Array([
  4990.       0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
  4991.       0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
  4992.     ]);
  4993.     const keyIds = new Set();
  4994.     const psshVersion = 0;
  4995.     const pssh =
  4996.         shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  4997.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4998.         'com.microsoft.playready', encryptionScheme, [
  4999.           {initDataType: 'cenc', initData: pssh},
  5000.         ]);
  5002.     const input = shaka.util.TXml.parseXmlString([
  5003.       '<PLAYREADY>',
  5004.       shaka.util.Uint8ArrayUtils.toBase64(data),
  5005.       '</PLAYREADY>',
  5006.     ].join('\n'));
  5007.     if (input) {
  5008.       drmInfo.licenseServerUri = shaka.drm.PlayReady.getLicenseUrl(input);
  5009.     }
  5011.     return Promise.resolve(drmInfo);
  5012.   }
  5014.   /**
  5015.    * @param {!shaka.hls.Tag} drmTag
  5016.    * @param {string} mimeType
  5017.    * @param {?shaka.media.InitSegmentReference} initSegmentRef
  5018.    * @return {!Promise<?shaka.extern.DrmInfo>}
  5019.    * @private
  5020.    */
  5021.   wiseplayDrmParser_(drmTag, mimeType, initSegmentRef) {
  5022.     const method = drmTag.getRequiredAttrValue('METHOD');
  5023.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  5024.     if (!VALID_METHODS.includes(method)) {
  5025.       shaka.log.error('WisePlay in HLS is only supported with [',
  5026.           VALID_METHODS.join(', '), '], not', method);
  5027.       return Promise.resolve(null);
  5028.     }
  5030.     let encryptionScheme = 'cenc';
  5031.     if (method == 'SAMPLE-AES') {
  5032.       encryptionScheme = 'cbcs';
  5033.     }
  5035.     const uri = drmTag.getRequiredAttrValue('URI');
  5036.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri.split('?')[0]);
  5038.     // The data encoded in the URI is a PSSH box to be used as init data.
  5039.     const pssh = shaka.util.BufferUtils.toUint8(parsedData.data);
  5040.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  5041.         'com.huawei.wiseplay', encryptionScheme, [
  5042.           {initDataType: 'cenc', initData: pssh},
  5043.         ]);
  5045.     const keyId = drmTag.getAttributeValue('KEYID');
  5046.     if (keyId) {
  5047.       const keyIdLowerCase = keyId.toLowerCase();
  5048.       // This value should begin with '0x':
  5049.       goog.asserts.assert(
  5050.           keyIdLowerCase.startsWith('0x'), 'Incorrect KEYID format!');
  5051.       // But the output should not contain the '0x':
  5052.       drmInfo.keyIds.add(keyIdLowerCase.substr(2));
  5053.     }
  5054.     return Promise.resolve(drmInfo);
  5055.   }
  5057.   /**
  5058.    * See: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-5.1
  5059.    *
  5060.    * @param {!shaka.hls.Tag} drmTag
  5061.    * @param {string} mimeType
  5062.    * @param {function(): !Array<string>} getUris
  5063.    * @param {?shaka.media.InitSegmentReference} initSegmentRef
  5064.    * @param {?Map<string, string>=} variables
  5065.    * @return {!Promise<?shaka.extern.DrmInfo>}
  5066.    * @private
  5067.    */
  5068.   async identityDrmParser_(drmTag, mimeType, getUris, initSegmentRef,
  5069.       variables) {
  5070.     if (mimeType == 'video/mp2t') {
  5071.       throw new shaka.util.Error(
  5072.           shaka.util.Error.Severity.CRITICAL,
  5073.           shaka.util.Error.Category.MANIFEST,
  5074.           shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
  5075.     }
  5077.     if (shaka.drm.DrmUtils.isMediaKeysPolyfilled('apple')) {
  5078.       throw new shaka.util.Error(
  5079.           shaka.util.Error.Severity.CRITICAL,
  5080.           shaka.util.Error.Category.MANIFEST,
  5081.           shaka.util.Error.Code
  5082.               .HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
  5083.     }
  5085.     const method = drmTag.getRequiredAttrValue('METHOD');
  5086.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  5087.     if (!VALID_METHODS.includes(method)) {
  5088.       shaka.log.error('Identity (ClearKey) in HLS is only supported with [',
  5089.           VALID_METHODS.join(', '), '], not', method);
  5090.       return null;
  5091.     }
  5093.     const keyUris = shaka.hls.Utils.constructSegmentUris(
  5094.         getUris(), drmTag.getRequiredAttrValue('URI'), variables);
  5096.     let key;
  5097.     if (keyUris[0].startsWith('data:text/plain;base64,')) {
  5098.       key = shaka.util.Uint8ArrayUtils.toHex(
  5099.           shaka.util.Uint8ArrayUtils.fromBase64(
  5100.               keyUris[0].split('data:text/plain;base64,').pop()));
  5101.     } else {
  5102.       const keyMapKey = keyUris.sort().join('');
  5103.       if (!this.identityKeyMap_.has(keyMapKey)) {
  5104.         const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  5105.         const request = shaka.net.NetworkingEngine.makeRequest(
  5106.             keyUris, this.config_.retryParameters);
  5107.         const keyResponse = this.makeNetworkRequest_(request, requestType)
  5108.             .promise;
  5109.         this.identityKeyMap_.set(keyMapKey, keyResponse);
  5110.       }
  5111.       const keyResponse = await this.identityKeyMap_.get(keyMapKey);
  5112.       key = shaka.util.Uint8ArrayUtils.toHex(keyResponse.data);
  5113.     }
  5115.     // NOTE: The ClearKey CDM requires a key-id to key mapping.  HLS doesn't
  5116.     // provide a key ID anywhere.  So although we could use the 'URI' attribute
  5117.     // to fetch the actual 16-byte key, without a key ID, we can't provide this
  5118.     // automatically to the ClearKey CDM. By default we assume that keyId is 0,
  5119.     // but we will try to get key ID from Init Segment.
  5120.     // If the application want override this behavior will have to use
  5121.     // player.configure('drm.clearKeys', { ... }) to provide the key IDs
  5122.     // and keys or player.configure('drm.servers.org\.w3\.clearkey', ...) to
  5123.     // provide a ClearKey license server URI.
  5124.     let keyId = '00000000000000000000000000000000';
  5126.     if (initSegmentRef) {
  5127.       const defaultKID = await this.getKeyIdFromInitSegment_(initSegmentRef);
  5128.       if (defaultKID) {
  5129.         keyId = defaultKID;
  5130.       }
  5131.     }
  5133.     const clearkeys = new Map();
  5134.     clearkeys.set(keyId, key);
  5136.     let encryptionScheme = 'cenc';
  5137.     if (method == 'SAMPLE-AES') {
  5138.       encryptionScheme = 'cbcs';
  5139.     }
  5141.     return shaka.util.ManifestParserUtils.createDrmInfoFromClearKeys(
  5142.         clearkeys, encryptionScheme);
  5143.   }
  5145.   /**
  5146.    * @param {!shaka.media.InitSegmentReference} initSegmentRef
  5147.    * @return {!Promise<?string>}
  5148.    * @private
  5149.    */
  5150.   async getKeyIdFromInitSegment_(initSegmentRef) {
  5151.     let keyId = null;
  5152.     if (this.initSegmentToKidMap_.has(initSegmentRef)) {
  5153.       keyId = this.initSegmentToKidMap_.get(initSegmentRef);
  5154.     } else {
  5155.       const initSegmentRequest = shaka.util.Networking.createSegmentRequest(
  5156.           initSegmentRef.getUris(),
  5157.           initSegmentRef.getStartByte(),
  5158.           initSegmentRef.getEndByte(),
  5159.           this.config_.retryParameters);
  5160.       const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  5161.       const initType =
  5162.           shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
  5163.       const initResponse = await this.makeNetworkRequest_(
  5164.           initSegmentRequest, requestType, {type: initType}).promise;
  5166.       initSegmentRef.setSegmentData(initResponse.data);
  5168.       keyId = shaka.media.SegmentUtils.getDefaultKID(
  5169.           initResponse.data);
  5170.       this.initSegmentToKidMap_.set(initSegmentRef, keyId);
  5171.     }
  5172.     return keyId;
  5173.   }
  5174. };
  5177. /**
  5178.  * @typedef {{
  5179.  *   stream: !shaka.extern.Stream,
  5180.  *   type: string,
  5181.  *   redirectUris: !Array<string>,
  5182.  *   getUris: function():!Array<string>,
  5183.  *   minTimestamp: number,
  5184.  *   maxTimestamp: number,
  5185.  *   mediaSequenceToStartTime: !Map<number, number>,
  5186.  *   canSkipSegments: boolean,
  5187.  *   canBlockReload: boolean,
  5188.  *   hasEndList: boolean,
  5189.  *   firstSequenceNumber: number,
  5190.  *   nextMediaSequence: number,
  5191.  *   nextPart: number,
  5192.  *   loadedOnce: boolean
  5193.  * }}
  5194.  *
  5195.  * @description
  5196.  * Contains a stream and information about it.
  5197.  *
  5198.  * @property {!shaka.extern.Stream} stream
  5199.  *   The Stream itself.
  5200.  * @property {string} type
  5201.  *   The type value. Could be 'video', 'audio', 'text', or 'image'.
  5202.  * @property {!Array<string>} redirectUris
  5203.  *   The redirect URIs.
  5204.  * @property {function():!Array<string>} getUris
  5205.  *   The verbatim media playlist URIs, as it appeared in the master playlist.
  5206.  * @property {number} minTimestamp
  5207.  *   The minimum timestamp found in the stream.
  5208.  * @property {number} maxTimestamp
  5209.  *   The maximum timestamp found in the stream.
  5210.  * @property {!Map<number, number>} mediaSequenceToStartTime
  5211.  *   A map of media sequence numbers to media start times.
  5212.  *   Only used for VOD content.
  5213.  * @property {boolean} canSkipSegments
  5214.  *   True if the server supports delta playlist updates, and we can send a
  5215.  *   request for a playlist that can skip older media segments.
  5216.  * @property {boolean} canBlockReload
  5217.  *   True if the server supports blocking playlist reload, and we can send a
  5218.  *   request for a playlist that can block reload until some segments are
  5219.  *   present.
  5220.  * @property {boolean} hasEndList
  5221.  *   True if the stream has an EXT-X-ENDLIST tag.
  5222.  * @property {number} firstSequenceNumber
  5223.  *   The sequence number of the first reference. Only calculated if needed.
  5224.  * @property {number} nextMediaSequence
  5225.  *   The next media sequence.
  5226.  * @property {number} nextPart
  5227.  *   The next part.
  5228.  * @property {boolean} loadedOnce
  5229.  *   True if the stream has been loaded at least once.
  5230.  */
  5231. shaka.hls.HlsParser.StreamInfo;
  5234. /**
  5235.  * @typedef {{
  5236.  *   audio: !Array<shaka.hls.HlsParser.StreamInfo>,
  5237.  *   video: !Array<shaka.hls.HlsParser.StreamInfo>
  5238.  * }}
  5239.  *
  5240.  * @description Audio and video stream infos.
  5241.  * @property {!Array<shaka.hls.HlsParser.StreamInfo>} audio
  5242.  * @property {!Array<shaka.hls.HlsParser.StreamInfo>} video
  5243.  */
  5244. shaka.hls.HlsParser.StreamInfos;
  5247. /**
  5248.  * @const {!Map<string, string>}
  5249.  * @private
  5250.  */
  5251. shaka.hls.HlsParser.RAW_FORMATS_TO_MIME_TYPES_ = new Map()
  5252.     .set('aac', 'audio/aac')
  5253.     .set('ac3', 'audio/ac3')
  5254.     .set('ec3', 'audio/ec3')
  5255.     .set('mp3', 'audio/mpeg');
  5258. /**
  5259.  * @const {!Map<string, string>}
  5260.  * @private
  5261.  */
  5262. shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = new Map()
  5263.     .set('mp4', 'audio/mp4')
  5264.     .set('mp4a', 'audio/mp4')
  5265.     .set('m4s', 'audio/mp4')
  5266.     .set('m4i', 'audio/mp4')
  5267.     .set('m4a', 'audio/mp4')
  5268.     .set('m4f', 'audio/mp4')
  5269.     .set('cmfa', 'audio/mp4')
  5270.     // MPEG2-TS also uses video/ for audio: https://bit.ly/TsMse
  5271.     .set('ts', 'video/mp2t')
  5272.     .set('tsa', 'video/mp2t');
  5275. /**
  5276.  * @const {!Map<string, string>}
  5277.  * @private
  5278.  */
  5279. shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = new Map()
  5280.     .set('mp4', 'video/mp4')
  5281.     .set('mp4v', 'video/mp4')
  5282.     .set('m4s', 'video/mp4')
  5283.     .set('m4i', 'video/mp4')
  5284.     .set('m4v', 'video/mp4')
  5285.     .set('m4f', 'video/mp4')
  5286.     .set('cmfv', 'video/mp4')
  5287.     .set('ts', 'video/mp2t')
  5288.     .set('tsv', 'video/mp2t');
  5291. /**
  5292.  * @const {!Map<string, string>}
  5293.  * @private
  5294.  */
  5295. shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_ = new Map()
  5296.     .set('mp4', 'application/mp4')
  5297.     .set('m4s', 'application/mp4')
  5298.     .set('m4i', 'application/mp4')
  5299.     .set('m4f', 'application/mp4')
  5300.     .set('cmft', 'application/mp4')
  5301.     .set('vtt', 'text/vtt')
  5302.     .set('webvtt', 'text/vtt')
  5303.     .set('ttml', 'application/ttml+xml');
  5306. /**
  5307.  * @const {!Map<string, string>}
  5308.  * @private
  5309.  */
  5310. shaka.hls.HlsParser.IMAGE_EXTENSIONS_TO_MIME_TYPES_ = new Map()
  5311.     .set('jpg', 'image/jpeg')
  5312.     .set('png', 'image/png')
  5313.     .set('svg', 'image/svg+xml')
  5314.     .set('webp', 'image/webp')
  5315.     .set('avif', 'image/avif');
  5318. /**
  5319.  * @const {!Map<string, !Map<string, string>>}
  5320.  * @private
  5321.  */
  5322. shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_ = new Map()
  5323.     .set('audio', shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_)
  5324.     .set('video', shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_)
  5325.     .set('text', shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_)
  5326.     .set('image', shaka.hls.HlsParser.IMAGE_EXTENSIONS_TO_MIME_TYPES_);
  5329. /**
  5330.  * MIME types without init segment.
  5331.  *
  5332.  * @const {!Set<string>}
  5333.  * @private
  5334.  */
  5335. shaka.hls.HlsParser.MIME_TYPES_WITHOUT_INIT_SEGMENT_ = new Set([
  5336.   'video/mp2t',
  5337.   // Containerless types
  5338.   ...shaka.util.MimeUtils.RAW_FORMATS,
  5339. ]);
  5342. /**
  5343.  * @typedef {function(!shaka.hls.Tag,
  5344.  *                    string,
  5345.  *                    ?shaka.media.InitSegmentReference):
  5346.  *                        !Promise<?shaka.extern.DrmInfo>}
  5347.  * @private
  5348.  */
  5349. shaka.hls.HlsParser.DrmParser_;
  5352. /**
  5353.  * @enum {string}
  5354.  * @private
  5355.  */
  5356. shaka.hls.HlsParser.PresentationType_ = {
  5357.   VOD: 'VOD',
  5358.   EVENT: 'EVENT',
  5359.   LIVE: 'LIVE',
  5360. };
  5363. /**
  5364.  * @const {string}
  5365.  * @private
  5366.  */
  5367. shaka.hls.HlsParser.FAKE_MUXED_URL_ = 'shaka://hls-muxed';
  5370. shaka.media.ManifestParser.registerParserByMime(
  5371.     'application/x-mpegurl', () => new shaka.hls.HlsParser());
  5372. shaka.media.ManifestParser.registerParserByMime(
  5373.     'application/vnd.apple.mpegurl', () => new shaka.hls.HlsParser());