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