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.DrmEngine');
  20. goog.require('shaka.media.InitSegmentReference');
  21. goog.require('shaka.media.ManifestParser');
  22. goog.require('shaka.media.PresentationTimeline');
  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.util.ArrayUtils');
  28. goog.require('shaka.util.BufferUtils');
  29. goog.require('shaka.util.ContentSteeringManager');
  30. goog.require('shaka.util.Error');
  31. goog.require('shaka.util.FakeEvent');
  32. goog.require('shaka.util.LanguageUtils');
  33. goog.require('shaka.util.ManifestParserUtils');
  34. goog.require('shaka.util.MimeUtils');
  35. goog.require('shaka.util.OperationManager');
  36. goog.require('shaka.util.Pssh');
  37. goog.require('shaka.media.SegmentUtils');
  38. goog.require('shaka.util.Timer');
  39. goog.require('shaka.util.Platform');
  40. goog.require('shaka.util.Uint8ArrayUtils');
  41. goog.require('shaka.util.XmlUtils');
  42. goog.requireType('shaka.hls.Segment');
  45. /**
  46.  * HLS parser.
  47.  *
  48.  * @implements {shaka.extern.ManifestParser}
  49.  * @export
  50.  */
  51. shaka.hls.HlsParser = class {
  52.   /**
  53.    * Creates an Hls Parser object.
  54.    */
  55.   constructor() {
  56.     /** @private {?shaka.extern.ManifestParser.PlayerInterface} */
  57.     this.playerInterface_ = null;
  59.     /** @private {?shaka.extern.ManifestConfiguration} */
  60.     this.config_ = null;
  62.     /** @private {number} */
  63.     this.globalId_ = 1;
  65.     /** @private {!Map.<string, string>} */
  66.     this.globalVariables_ = new Map();
  68.     /**
  69.      * A map from group id to stream infos created from the media tags.
  70.      * @private {!Map.<string, !Array.<?shaka.hls.HlsParser.StreamInfo>>}
  71.      */
  72.     this.groupIdToStreamInfosMap_ = new Map();
  74.     /**
  75.      * For media playlist lazy-loading to work in livestreams, we have to assume
  76.      * that each stream of a type (video, audio, etc) has the same mappings of
  77.      * sequence number to start time.
  78.      * This map stores those relationships.
  79.      * Only used during livestreams; we do not assume that VOD content is
  80.      * aligned in that way.
  81.      * @private {!Map.<string, !Map.<number, number>>}
  82.      */
  83.     this.mediaSequenceToStartTimeByType_ = new Map();
  85.     // Set initial maps.
  86.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  87.     this.mediaSequenceToStartTimeByType_.set(ContentType.VIDEO, new Map());
  88.     this.mediaSequenceToStartTimeByType_.set(ContentType.AUDIO, new Map());
  89.     this.mediaSequenceToStartTimeByType_.set(ContentType.TEXT, new Map());
  90.     this.mediaSequenceToStartTimeByType_.set(ContentType.IMAGE, new Map());
  92.     /**
  93.      * The values are strings of the form "<VIDEO URI> - <AUDIO URI>",
  94.      * where the URIs are the verbatim media playlist URIs as they appeared in
  95.      * the master playlist.
  96.      *
  97.      * Used to avoid duplicates that vary only in their text stream.
  98.      *
  99.      * @private {!Set.<string>}
  100.      */
  101.     this.variantUriSet_ = new Set();
  103.     /**
  104.      * A map from (verbatim) media playlist URI to stream infos representing the
  105.      * playlists.
  106.      *
  107.      * On update, used to iterate through and update from media playlists.
  108.      *
  109.      * On initial parse, used to iterate through and determine minimum
  110.      * timestamps, offsets, and to handle TS rollover.
  111.      *
  112.      * During parsing, used to avoid duplicates in the async methods
  113.      * createStreamInfoFromMediaTags_, createStreamInfoFromImageTag_ and
  114.      * createStreamInfoFromVariantTags_.
  115.      *
  116.      * @private {!Map.<string, shaka.hls.HlsParser.StreamInfo>}
  117.      */
  118.     this.uriToStreamInfosMap_ = new Map();
  120.     /** @private {?shaka.media.PresentationTimeline} */
  121.     this.presentationTimeline_ = null;
  123.     /**
  124.      * The master playlist URI, after redirects.
  125.      *
  126.      * @private {string}
  127.      */
  128.     this.masterPlaylistUri_ = '';
  130.     /** @private {shaka.hls.ManifestTextParser} */
  131.     this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
  133.     /**
  134.      * The minimum sequence number for generated segments, when ignoring
  135.      * EXT-X-PROGRAM-DATE-TIME.
  136.      *
  137.      * @private {number}
  138.      */
  139.     this.minSequenceNumber_ = -1;
  141.     /**
  142.      * The lowest time value for any of the streams, as defined by the
  143.      * EXT-X-PROGRAM-DATE-TIME value. Measured in seconds since January 1, 1970.
  144.      *
  145.      * @private {number}
  146.      */
  147.     this.lowestSyncTime_ = Infinity;
  149.     /**
  150.      * Whether the streams have previously been "finalized"; that is to say,
  151.      * whether we have loaded enough streams to know information about the asset
  152.      * such as timing information, live status, etc.
  153.      *
  154.      * @private {boolean}
  155.      */
  156.     this.streamsFinalized_ = false;
  158.     /**
  159.      * Whether the manifest informs about the codec to use.
  160.      *
  161.      * @private
  162.      */
  163.     this.codecInfoInManifest_ = false;
  165.     /**
  166.      * This timer is used to trigger the start of a manifest update. A manifest
  167.      * update is async. Once the update is finished, the timer will be restarted
  168.      * to trigger the next update. The timer will only be started if the content
  169.      * is live content.
  170.      *
  171.      * @private {shaka.util.Timer}
  172.      */
  173.     this.updatePlaylistTimer_ = new shaka.util.Timer(() => {
  174.       this.onUpdate_();
  175.     });
  177.     /** @private {shaka.hls.HlsParser.PresentationType_} */
  178.     this.presentationType_ = shaka.hls.HlsParser.PresentationType_.VOD;
  180.     /** @private {?shaka.extern.Manifest} */
  181.     this.manifest_ = null;
  183.     /** @private {number} */
  184.     this.maxTargetDuration_ = 0;
  186.     /** @private {number} */
  187.     this.lastTargetDuration_ = Infinity;
  189.     /** Partial segments target duration.
  190.      * @private {number}
  191.      */
  192.     this.partialTargetDuration_ = 0;
  194.     /** @private {number} */
  195.     this.presentationDelay_ = 0;
  197.     /** @private {number} */
  198.     this.lowLatencyPresentationDelay_ = 0;
  200.     /** @private {shaka.util.OperationManager} */
  201.     this.operationManager_ = new shaka.util.OperationManager();
  203.     /** A map from closed captions' group id, to a map of closed captions info.
  204.      * {group id -> {closed captions channel id -> language}}
  205.      * @private {Map.<string, Map.<string, string>>}
  206.      */
  207.     this.groupIdToClosedCaptionsMap_ = new Map();
  209.     /** @private {Map.<string, string>} */
  210.     this.groupIdToCodecsMap_ = new Map();
  212.     /** A cache mapping EXT-X-MAP tag info to the InitSegmentReference created
  213.      * from the tag.
  214.      * The key is a string combining the EXT-X-MAP tag's absolute uri, and
  215.      * its BYTERANGE if available.
  216.      * {!Map.<string, !shaka.media.InitSegmentReference>} */
  217.     this.mapTagToInitSegmentRefMap_ = new Map();
  219.     /** @private {boolean} */
  220.     this.lowLatencyMode_ = false;
  222.     /** @private {boolean} */
  223.     this.lowLatencyByterangeOptimization_ = false;
  225.     /**
  226.      * An ewma that tracks how long updates take.
  227.      * This is to mitigate issues caused by slow parsing on embedded devices.
  228.      * @private {!shaka.abr.Ewma}
  229.      */
  230.     this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
  232.     /** @private {?shaka.util.ContentSteeringManager} */
  233.     this.contentSteeringManager_ = null;
  234.   }
  237.   /**
  238.    * @override
  239.    * @exportInterface
  240.    */
  241.   configure(config) {
  242.     this.config_ = config;
  244.     if (this.contentSteeringManager_) {
  245.       this.contentSteeringManager_.configure(this.config_);
  246.     }
  247.   }
  249.   /**
  250.    * @override
  251.    * @exportInterface
  252.    */
  253.   async start(uri, playerInterface) {
  254.     goog.asserts.assert(this.config_, 'Must call configure() before start()!');
  255.     this.playerInterface_ = playerInterface;
  256.     this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
  258.     const response = await this.requestManifest_([uri]);
  260.     // Record the master playlist URI after redirects.
  261.     this.masterPlaylistUri_ = response.uri;
  263.     goog.asserts.assert(response.data, 'Response data should be non-null!');
  264.     await this.parseManifest_(response.data, uri);
  266.     goog.asserts.assert(this.manifest_, 'Manifest should be non-null');
  267.     return this.manifest_;
  268.   }
  270.   /**
  271.    * @override
  272.    * @exportInterface
  273.    */
  274.   stop() {
  275.     // Make sure we don't update the manifest again. Even if the timer is not
  276.     // running, this is safe to call.
  277.     if (this.updatePlaylistTimer_) {
  278.       this.updatePlaylistTimer_.stop();
  279.       this.updatePlaylistTimer_ = null;
  280.     }
  282.     /** @type {!Array.<!Promise>} */
  283.     const pending = [];
  285.     if (this.operationManager_) {
  286.       pending.push(this.operationManager_.destroy());
  287.       this.operationManager_ = null;
  288.     }
  290.     this.playerInterface_ = null;
  291.     this.config_ = null;
  292.     this.variantUriSet_.clear();
  293.     this.manifest_ = null;
  294.     this.uriToStreamInfosMap_.clear();
  295.     this.groupIdToStreamInfosMap_.clear();
  296.     this.groupIdToCodecsMap_.clear();
  297.     this.globalVariables_.clear();
  299.     if (this.contentSteeringManager_) {
  300.       this.contentSteeringManager_.destroy();
  301.     }
  303.     return Promise.all(pending);
  304.   }
  306.   /**
  307.    * @override
  308.    * @exportInterface
  309.    */
  310.   async update() {
  311.     if (!this.isLive_()) {
  312.       return;
  313.     }
  315.     /** @type {!Array.<!Promise>} */
  316.     const updates = [];
  317.     const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  319.     // This is necessary to calculate correctly the update time.
  320.     this.lastTargetDuration_ = Infinity;
  322.     // Only update active streams.
  323.     const activeStreamInfos = streamInfos.filter((s) => s.stream.segmentIndex);
  324.     for (const streamInfo of activeStreamInfos) {
  325.       updates.push(this.updateStream_(streamInfo));
  326.     }
  327.     await Promise.all(updates);
  329.     // Now that streams have been updated, notify the presentation timeline.
  330.     this.notifySegmentsForStreams_(activeStreamInfos.map((s) => s.stream));
  332.     // If any hasEndList is false, the stream is still live.
  333.     const stillLive = activeStreamInfos.some((s) => s.hasEndList == false);
  334.     if (activeStreamInfos.length && !stillLive) {
  335.       // Convert the presentation to VOD and set the duration.
  336.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  337.       this.setPresentationType_(PresentationType.VOD);
  339.       // The duration is the minimum of the end times of all active streams.
  340.       // Non-active streams are not guaranteed to have useful maxTimestamp
  341.       // values, due to the lazy-loading system, so they are ignored.
  342.       const maxTimestamps = activeStreamInfos.map((s) => s.maxTimestamp);
  343.       // The duration is the minimum of the end times of all streams.
  344.       this.presentationTimeline_.setDuration(Math.min(...maxTimestamps));
  345.       this.playerInterface_.updateDuration();
  346.     }
  347.     if (stillLive) {
  348.       this.determineDuration_();
  349.     }
  350.   }
  352.   /**
  353.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  354.    * @return {!Map.<number, number>}
  355.    * @private
  356.    */
  357.   getMediaSequenceToStartTimeFor_(streamInfo) {
  358.     if (this.isLive_()) {
  359.       return this.mediaSequenceToStartTimeByType_.get(streamInfo.type);
  360.     } else {
  361.       return streamInfo.mediaSequenceToStartTime;
  362.     }
  363.   }
  365.   /**
  366.    * Updates a stream.
  367.    *
  368.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  369.    * @return {!Promise}
  370.    * @private
  371.    */
  372.   async updateStream_(streamInfo) {
  373.     const manifestUris = [];
  374.     for (const uri of streamInfo.getUris()) {
  375.       const uriObj = new goog.Uri(uri);
  376.       const queryData = uriObj.getQueryData();
  377.       if (streamInfo.canBlockReload) {
  378.         if (streamInfo.nextMediaSequence >= 0) {
  379.           // Indicates that the server must hold the request until a Playlist
  380.           // contains a Media Segment with Media Sequence
  381.           queryData.add('_HLS_msn', String(streamInfo.nextMediaSequence));
  382.         }
  383.         if (streamInfo.nextPart >= 0) {
  384.           // Indicates, in combination with _HLS_msn, that the server must hold
  385.           // the request until a Playlist contains Partial Segment N of Media
  386.           // Sequence Number M or later.
  387.           queryData.add('_HLS_part', String(streamInfo.nextPart));
  388.         }
  389.       }
  390.       if (streamInfo.canSkipSegments) {
  391.         // Enable delta updates. This will replace older segments with
  392.         // 'EXT-X-SKIP' tag in the media playlist.
  393.         queryData.add('_HLS_skip', 'YES');
  394.       }
  395.       if (queryData.getCount()) {
  396.         uriObj.setQueryData(queryData);
  397.       }
  398.       manifestUris.push(uriObj.toString());
  399.     }
  400.     const response =
  401.         await this.requestManifest_(manifestUris, /* isPlaylist= */ true);
  402.     if (!streamInfo.stream.segmentIndex) {
  403.       // The stream was closed since the update was first requested.
  404.       return;
  405.     }
  407.     /** @type {shaka.hls.Playlist} */
  408.     const playlist = this.manifestTextParser_.parsePlaylist(response.data);
  410.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  411.       throw new shaka.util.Error(
  412.           shaka.util.Error.Severity.CRITICAL,
  413.           shaka.util.Error.Category.MANIFEST,
  414.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  415.     }
  417.     // Record the final URI after redirects.
  418.     const responseUri = response.uri;
  419.     if (responseUri != response.originalUri &&
  420.         !streamInfo.getUris().includes(responseUri)) {
  421.       streamInfo.redirectUris.push(responseUri);
  422.     }
  424.     /** @type {!Array.<!shaka.hls.Tag>} */
  425.     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  426.         'EXT-X-DEFINE');
  428.     const mediaVariables = this.parseMediaVariables_(
  429.         variablesTags, responseUri);
  431.     const stream = streamInfo.stream;
  433.     const mediaSequenceToStartTime =
  434.         this.getMediaSequenceToStartTimeFor_(streamInfo);
  435.     const {keyIds, drmInfos} = this.parseDrmInfo_(playlist, stream.mimeType);
  437.     const keysAreEqual =
  438.       (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
  440.     if (!keysAreEqual(stream.keyIds, keyIds)) {
  441.       stream.keyIds = keyIds;
  442.       stream.drmInfos = drmInfos;
  443.       this.playerInterface_.newDrmInfo(stream);
  444.     }
  446.     const {segments, bandwidth} = this.createSegments_(
  447.         playlist, stream, mediaSequenceToStartTime, mediaVariables,
  448.         streamInfo.getUris);
  450.     stream.bandwidth = bandwidth;
  452.     stream.segmentIndex.mergeAndEvict(
  453.         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
  454.     if (segments.length) {
  455.       const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  456.           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  457.       const skipTag = shaka.hls.Utils.getFirstTagWithName(
  458.           playlist.tags, 'EXT-X-SKIP');
  459.       const skippedSegments =
  460.           skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
  461.       const {nextMediaSequence, nextPart} =
  462.           this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
  463.       streamInfo.nextMediaSequence = nextMediaSequence + skippedSegments;
  464.       streamInfo.nextPart = nextPart;
  465.       const playlistStartTime = mediaSequenceToStartTime.get(
  466.           mediaSequenceNumber);
  467.       stream.segmentIndex.evict(playlistStartTime);
  468.     }
  469.     const oldSegment = segments[0];
  470.     goog.asserts.assert(oldSegment, 'Should have segments!');
  472.     streamInfo.minTimestamp = oldSegment.startTime;
  474.     const newestSegment = segments[segments.length - 1];
  475.     goog.asserts.assert(newestSegment, 'Should have segments!');
  477.     streamInfo.maxTimestamp = newestSegment.endTime;
  479.     // Once the last segment has been added to the playlist,
  480.     // #EXT-X-ENDLIST tag will be appended.
  481.     // If that happened, treat the rest of the EVENT presentation as VOD.
  482.     const endListTag =
  483.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  485.     if (endListTag) {
  486.       // Flag this for later.  We don't convert the whole presentation into VOD
  487.       // until we've seen the ENDLIST tag for all active playlists.
  488.       streamInfo.hasEndList = true;
  489.     }
  491.     this.determineLastTargetDuration_(playlist);
  492.   }
  495.   /**
  496.    * @override
  497.    * @exportInterface
  498.    */
  499.   onExpirationUpdated(sessionId, expiration) {
  500.     // No-op
  501.   }
  503.   /**
  504.    * @override
  505.    * @exportInterface
  506.    */
  507.   onInitialVariantChosen(variant) {
  508.     // No-op
  509.   }
  511.   /**
  512.    * @override
  513.    * @exportInterface
  514.    */
  515.   banLocation(uri) {
  516.     if (this.contentSteeringManager_) {
  517.       this.contentSteeringManager_.banLocation(uri);
  518.     }
  519.   }
  521.   /**
  522.    * Align the streams by sequence number by dropping early segments.  Then
  523.    * offset the streams to begin at presentation time 0.
  524.    * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  525.    * @private
  526.    */
  527.   syncStreamsWithSequenceNumber_(streamInfos) {
  528.     // We assume that, when this is first called, we have enough info to
  529.     // determine how to use the program date times (e.g. we have both a video
  530.     // and an audio, and all other videos and audios match those).
  531.     // Thus, we only need to calculate this once.
  532.     const updateMinSequenceNumber = this.minSequenceNumber_ == -1;
  533.     // Sync using media sequence number.  Find the highest starting sequence
  534.     // number among all streams.  Later, we will drop any references to
  535.     // earlier segments in other streams, then offset everything back to 0.
  536.     for (const streamInfo of streamInfos) {
  537.       const segmentIndex = streamInfo.stream.segmentIndex;
  538.       goog.asserts.assert(segmentIndex,
  539.           'Only loaded streams should be synced');
  540.       const mediaSequenceToStartTime =
  541.           this.getMediaSequenceToStartTimeFor_(streamInfo);
  542.       const segment0 = segmentIndex.earliestReference();
  543.       if (segment0) {
  544.         // This looks inefficient, but iteration order is insertion order.
  545.         // So the very first entry should be the one we want.
  546.         // We assert that this holds true so that we are alerted by debug
  547.         // builds and tests if it changes.  We still do a loop, though, so
  548.         // that the code functions correctly in production no matter what.
  549.         if (goog.DEBUG) {
  550.           const firstSequenceStartTime =
  551.               mediaSequenceToStartTime.values().next().value;
  552.           goog.asserts.assert(
  553.               firstSequenceStartTime == segment0.startTime,
  554.               'Sequence number map is not ordered as expected!');
  555.         }
  556.         for (const [sequence, start] of mediaSequenceToStartTime) {
  557.           if (start == segment0.startTime) {
  558.             if (updateMinSequenceNumber) {
  559.               this.minSequenceNumber_ = Math.max(
  560.                   this.minSequenceNumber_, sequence);
  561.             }
  562.             // Even if we already have decided on a value for
  563.             // |this.minSequenceNumber_|, we still need to determine the first
  564.             // sequence number for the stream, to offset it in the code below.
  565.             streamInfo.firstSequenceNumber = sequence;
  566.             break;
  567.           }
  568.         }
  569.       }
  570.     }
  572.     if (this.minSequenceNumber_ < 0) {
  573.       // Nothing to sync.
  574.       return;
  575.     }
  577.     shaka.log.debug('Syncing HLS streams against base sequence number:',
  578.         this.minSequenceNumber_);
  580.     for (const streamInfo of streamInfos) {
  581.       const segmentIndex = streamInfo.stream.segmentIndex;
  582.       if (segmentIndex) {
  583.         // Drop any earlier references.
  584.         const numSegmentsToDrop =
  585.             this.minSequenceNumber_ - streamInfo.firstSequenceNumber;
  586.         segmentIndex.dropFirstReferences(numSegmentsToDrop);
  588.         // Now adjust timestamps back to begin at 0.
  589.         const segmentN = segmentIndex.earliestReference();
  590.         if (segmentN) {
  591.           const streamOffset = -segmentN.startTime;
  592.           // Modify all SegmentReferences equally.
  593.           streamInfo.stream.segmentIndex.offset(streamOffset);
  594.           // Update other parts of streamInfo the same way.
  595.           this.offsetStreamInfo_(streamInfo, streamOffset);
  596.         }
  597.       }
  598.     }
  599.   }
  601.   /**
  602.    * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
  603.    * segments.  Also normalizes segment times so that the earliest segment in
  604.    * any stream is at time 0.
  605.    * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  606.    * @private
  607.    */
  608.   syncStreamsWithProgramDateTime_(streamInfos) {
  609.     // We assume that, when this is first called, we have enough info to
  610.     // determine how to use the program date times (e.g. we have both a video
  611.     // and an audio, and all other videos and audios match those).
  612.     // Thus, we only need to calculate this once.
  613.     if (this.lowestSyncTime_ == Infinity) {
  614.       for (const streamInfo of streamInfos) {
  615.         const segmentIndex = streamInfo.stream.segmentIndex;
  616.         goog.asserts.assert(segmentIndex,
  617.             'Only loaded streams should be synced');
  618.         const segment0 = segmentIndex.earliestReference();
  619.         if (segment0 != null && segment0.syncTime != null) {
  620.           this.lowestSyncTime_ =
  621.               Math.min(this.lowestSyncTime_, segment0.syncTime);
  622.         }
  623.       }
  624.     }
  626.     const lowestSyncTime = this.lowestSyncTime_;
  627.     if (lowestSyncTime == Infinity) {
  628.       // Nothing to sync.
  629.       return;
  630.     }
  632.     shaka.log.debug('Syncing HLS streams against base time:', lowestSyncTime);
  634.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  635.       const segmentIndex = streamInfo.stream.segmentIndex;
  636.       if (segmentIndex != null) {
  637.         // A segment's startTime should be based on its syncTime vs the lowest
  638.         // syncTime across all streams.  The earliest segment sync time from
  639.         // any stream will become presentation time 0.  If two streams start
  640.         // e.g. 6 seconds apart in syncTime, then their first segments will
  641.         // also start 6 seconds apart in presentation time.
  643.         const segment0 = segmentIndex.earliestReference();
  644.         if (segment0.syncTime == null) {
  645.           shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
  646.               streamInfo.getUris(),
  647.               'Expect AV sync issues!');
  648.         } else {
  649.           // Stream metadata are offset by a fixed amount based on the
  650.           // first segment.
  651.           const segment0TargetTime = segment0.syncTime - lowestSyncTime;
  652.           const streamOffset = segment0TargetTime - segment0.startTime;
  653.           this.offsetStreamInfo_(streamInfo, streamOffset);
  655.           // This is computed across all segments separately to manage
  656.           // accumulated drift in durations.
  657.           for (const segment of segmentIndex) {
  658.             segment.syncAgainst(lowestSyncTime);
  659.           }
  660.         }
  661.       }
  662.     }
  663.   }
  665.   /**
  666.    * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
  667.    * @param {number} offset
  668.    * @private
  669.    */
  670.   offsetStreamInfo_(streamInfo, offset) {
  671.     // Adjust our accounting of the minimum timestamp.
  672.     streamInfo.minTimestamp += offset;
  674.     // Adjust our accounting of the maximum timestamp.
  675.     streamInfo.maxTimestamp += offset;
  676.     goog.asserts.assert(streamInfo.maxTimestamp >= 0,
  677.         'Negative maxTimestamp after adjustment!');
  679.     // Update our map from sequence number to start time.
  680.     const mediaSequenceToStartTime =
  681.         this.getMediaSequenceToStartTimeFor_(streamInfo);
  682.     for (const [key, value] of mediaSequenceToStartTime) {
  683.       mediaSequenceToStartTime.set(key, value + offset);
  684.     }
  686.     shaka.log.debug('Offset', offset, 'applied to',
  687.         streamInfo.getUris());
  688.   }
  690.   /**
  691.    * Parses the manifest.
  692.    *
  693.    * @param {BufferSource} data
  694.    * @param {string} uri
  695.    * @return {!Promise}
  696.    * @private
  697.    */
  698.   async parseManifest_(data, uri) {
  699.     const Utils = shaka.hls.Utils;
  701.     goog.asserts.assert(this.masterPlaylistUri_,
  702.         'Master playlist URI must be set before calling parseManifest_!');
  704.     const playlist = this.manifestTextParser_.parsePlaylist(data);
  706.     /** @type {!Array.<!shaka.hls.Tag>} */
  707.     const variablesTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-DEFINE');
  709.     /** @type {!Array.<!shaka.extern.Variant>} */
  710.     let variants = [];
  711.     /** @type {!Array.<!shaka.extern.Stream>} */
  712.     let textStreams = [];
  713.     /** @type {!Array.<!shaka.extern.Stream>} */
  714.     let imageStreams = [];
  716.     // Parsing a media playlist results in a single-variant stream.
  717.     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
  718.       const getUris = () => {
  719.         return [uri];
  720.       };
  722.       // Get necessary info for this stream. These are things we would normally
  723.       // find from the master playlist (e.g. from values on EXT-X-MEDIA tags).
  724.       const basicInfo =
  725.           await this.getMediaPlaylistBasicInfo_(playlist, getUris);
  726.       const type = basicInfo.type;
  727.       const mimeType = basicInfo.mimeType;
  728.       const codecs = basicInfo.codecs;
  729.       const languageValue = basicInfo.language;
  730.       const height = basicInfo.height;
  731.       const width = basicInfo.width;
  732.       const channelsCount = basicInfo.channelCount;
  733.       const sampleRate = basicInfo.sampleRate;
  734.       const closedCaptions = basicInfo.closedCaptions;
  736.       // Some values we cannot figure out, and aren't important enough to ask
  737.       // the user to provide through config values. A lot of these are only
  738.       // relevant to ABR, which isn't necessary if there's only one variant.
  739.       // So these unknowns should be set to false or null, largely.
  740.       const spatialAudio = false;
  741.       const characteristics = null;
  742.       const forced = false; // Only relevant for text.
  743.       const primary = true; // This is the only stream!
  744.       const name = 'Media Playlist';
  746.       // Make the stream info, with those values.
  747.       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
  748.           this.globalId_++, playlist, getUris, uri, codecs, type,
  749.           languageValue, primary, name, channelsCount, closedCaptions,
  750.           characteristics, forced, sampleRate, spatialAudio, mimeType);
  751.       this.uriToStreamInfosMap_.set(uri, streamInfo);
  753.       if (type == 'video') {
  754.         this.addVideoAttributes_(streamInfo.stream, width, height,
  755.             /* frameRate= */ null, /* videoRange= */ null,
  756.             /* videoLayout= */ null);
  757.       }
  759.       // Wrap the stream from that stream info with a variant.
  760.       variants.push({
  761.         id: 0,
  762.         language: this.getLanguage_(languageValue),
  763.         disabledUntilTime: 0,
  764.         primary: true,
  765.         audio: type == 'audio' ? streamInfo.stream : null,
  766.         video: type == 'video' ? streamInfo.stream : null,
  767.         bandwidth: streamInfo.stream.bandwidth || 0,
  768.         allowedByApplication: true,
  769.         allowedByKeySystem: true,
  770.         decodingInfos: [],
  771.       });
  772.     } else {
  773.       this.parseMasterVariables_(variablesTags);
  775.       /** @type {!Array.<!shaka.hls.Tag>} */
  776.       const mediaTags = Utils.filterTagsByName(
  777.           playlist.tags, 'EXT-X-MEDIA');
  778.       /** @type {!Array.<!shaka.hls.Tag>} */
  779.       const variantTags = Utils.filterTagsByName(
  780.           playlist.tags, 'EXT-X-STREAM-INF');
  781.       /** @type {!Array.<!shaka.hls.Tag>} */
  782.       const imageTags = Utils.filterTagsByName(
  783.           playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
  784.       /** @type {!Array.<!shaka.hls.Tag>} */
  785.       const iFrameTags = Utils.filterTagsByName(
  786.           playlist.tags, 'EXT-X-I-FRAME-STREAM-INF');
  787.       /** @type {!Array.<!shaka.hls.Tag>} */
  788.       const sessionKeyTags = Utils.filterTagsByName(
  789.           playlist.tags, 'EXT-X-SESSION-KEY');
  790.       /** @type {!Array.<!shaka.hls.Tag>} */
  791.       const sessionDataTags = Utils.filterTagsByName(
  792.           playlist.tags, 'EXT-X-SESSION-DATA');
  793.       /** @type {!Array.<!shaka.hls.Tag>} */
  794.       const contentSteeringTags = Utils.filterTagsByName(
  795.           playlist.tags, 'EXT-X-CONTENT-STEERING');
  797.       this.processSessionData_(sessionDataTags);
  798.       await this.processContentSteering_(contentSteeringTags);
  800.       this.parseCodecs_(variantTags);
  802.       this.parseClosedCaptions_(mediaTags);
  803.       variants =
  804.           this.createVariantsForTags_(variantTags, sessionKeyTags, mediaTags);
  805.       textStreams = this.parseTexts_(mediaTags);
  806.       imageStreams = await this.parseImages_(imageTags, iFrameTags);
  807.     }
  809.     // Make sure that the parser has not been destroyed.
  810.     if (!this.playerInterface_) {
  811.       throw new shaka.util.Error(
  812.           shaka.util.Error.Severity.CRITICAL,
  813.           shaka.util.Error.Category.PLAYER,
  814.           shaka.util.Error.Code.OPERATION_ABORTED);
  815.     }
  817.     // This assert is our own sanity check.
  818.     goog.asserts.assert(this.presentationTimeline_ == null,
  819.         'Presentation timeline created early!');
  820.     // We don't know if the presentation is VOD or live until we parse at least
  821.     // one media playlist, so make a VOD-style presentation timeline for now
  822.     // and change the type later if we discover this is live.
  823.     // Since the player will load the first variant chosen early in the process,
  824.     // there isn't a window during playback where the live-ness is unknown.
  825.     this.presentationTimeline_ = new shaka.media.PresentationTimeline(
  826.         /* presentationStartTime= */ null, /* delay= */ 0);
  827.     this.presentationTimeline_.setStatic(true);
  829.     // Single-variant streams aren't lazy-loaded, so for them we already have
  830.     // enough info here to determine the presentation type and duration.
  831.     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
  832.       if (this.isLive_()) {
  833.         this.changePresentationTimelineToLive_(playlist);
  834.         const delay = this.getUpdatePlaylistDelay_();
  835.         this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
  836.       }
  837.       const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  838.       this.finalizeStreams_(streamInfos);
  839.       this.determineDuration_();
  840.     }
  842.     this.manifest_ = {
  843.       presentationTimeline: this.presentationTimeline_,
  844.       variants,
  845.       textStreams,
  846.       imageStreams,
  847.       offlineSessionIds: [],
  848.       minBufferTime: 0,
  849.       sequenceMode: this.config_.hls.sequenceMode,
  850.       ignoreManifestTimestampsInSegmentsMode:
  851.         this.config_.hls.ignoreManifestTimestampsInSegmentsMode,
  852.       type: shaka.media.ManifestParser.HLS,
  853.       serviceDescription: null,
  854.     };
  856.     // If there is no 'CODECS' attribute in the manifest and codec guessing is
  857.     // disabled, we need to create the segment indexes now so that missing info
  858.     // can be parsed from the media data and added to the stream objects.
  859.     if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
  860.       const createIndexes = [];
  861.       for (const variant of this.manifest_.variants) {
  862.         if (variant.audio && variant.audio.codecs === '') {
  863.           createIndexes.push(variant.audio.createSegmentIndex());
  864.         }
  865.         if (variant.video && variant.video.codecs === '') {
  866.           createIndexes.push(variant.video.createSegmentIndex());
  867.         }
  868.       }
  870.       await Promise.all(createIndexes);
  871.     }
  873.     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
  874.   }
  876.   /**
  877.    * @param {shaka.hls.Playlist} playlist
  878.    * @param {function():!Array.<string>} getUris
  879.    * @return {!Promise.<shaka.media.SegmentUtils.BasicInfo>}
  880.    * @private
  881.    */
  882.   async getMediaPlaylistBasicInfo_(playlist, getUris) {
  883.     const HlsParser = shaka.hls.HlsParser;
  884.     const defaultBasicInfo = shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  885.         this.config_.hls.mediaPlaylistFullMimeType);
  886.     if (!playlist.segments.length) {
  887.       return defaultBasicInfo;
  888.     }
  889.     const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
  890.     const middleSegment = playlist.segments[middleSegmentIdx];
  891.     const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
  892.         getUris(),
  893.         playlist.segments[0].verbatimSegmentUri);
  894.     const middleSegmentUri = middleSegmentUris[0];
  895.     const parsedUri = new goog.Uri(middleSegmentUri);
  896.     const extension = parsedUri.getPath().split('.').pop();
  897.     const rawMimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
  898.     if (rawMimeType) {
  899.       return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
  900.           rawMimeType);
  901.     }
  903.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  905.     let initData = null;
  906.     const initSegmentRef = this.getInitSegmentReference_(
  907.         playlist, middleSegment.tags, getUris);
  908.     if (initSegmentRef) {
  909.       const initSegmentRequest = shaka.net.NetworkingEngine.makeRequest(
  910.           initSegmentRef.getUris(), this.config_.retryParameters);
  911.       const initType =
  912.           shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
  913.       const initResponse = await this.makeNetworkRequest_(
  914.           initSegmentRequest, requestType, {type: initType});
  915.       initData = initResponse.data;
  916.     }
  918.     const segmentRequest = shaka.net.NetworkingEngine.makeRequest(
  919.         middleSegmentUris, this.config_.retryParameters);
  920.     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
  921.     const response = await this.makeNetworkRequest_(
  922.         segmentRequest, requestType, {type});
  924.     let contentMimeType = response.headers['content-type'];
  925.     if (contentMimeType) {
  926.       // Split the MIME type in case the server sent additional parameters.
  927.       contentMimeType = contentMimeType.split(';')[0].toLowerCase();
  928.     }
  930.     if (extension == 'ts' || contentMimeType == 'video/mp2t') {
  931.       const basicInfo =
  932.           shaka.media.SegmentUtils.getBasicInfoFromTs(response.data);
  933.       if (basicInfo) {
  934.         return basicInfo;
  935.       }
  936.     } else if (extension == 'mp4' || extension == 'cmfv' ||
  937.         contentMimeType == 'video/mp4' || contentMimeType == 'audio/mp4' ||
  938.         contentMimeType == 'video/iso.segment') {
  939.       const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromMp4(
  940.           initData, response.data);
  941.       if (basicInfo) {
  942.         return basicInfo;
  943.       }
  944.     }
  945.     return defaultBasicInfo;
  946.   }
  948.   /** @private */
  949.   determineDuration_() {
  950.     goog.asserts.assert(this.presentationTimeline_,
  951.         'Presentation timeline not created!');
  953.     if (this.isLive_()) {
  954.       // The spec says nothing much about seeking in live content, but Safari's
  955.       // built-in HLS implementation does not allow it.  Therefore we will set
  956.       // the availability window equal to the presentation delay.  The player
  957.       // will be able to buffer ahead three segments, but the seek window will
  958.       // be zero-sized.
  959.       const PresentationType = shaka.hls.HlsParser.PresentationType_;
  961.       if (this.presentationType_ == PresentationType.LIVE) {
  962.         let segmentAvailabilityDuration = this.getLiveDuration_();
  964.         // This defaults to the presentation delay, which has the effect of
  965.         // making the live stream unseekable.  This is consistent with Apple's
  966.         // HLS implementation.
  967.         if (this.config_.hls.useSafariBehaviorForLive) {
  968.           segmentAvailabilityDuration = this.presentationTimeline_.getDelay();
  969.         }
  971.         // The app can override that with a longer duration, to allow seeking.
  972.         if (!isNaN(this.config_.availabilityWindowOverride)) {
  973.           segmentAvailabilityDuration = this.config_.availabilityWindowOverride;
  974.         }
  976.         this.presentationTimeline_.setSegmentAvailabilityDuration(
  977.             segmentAvailabilityDuration);
  978.       }
  979.     } else {
  980.       // Use the minimum duration as the presentation duration.
  981.       this.presentationTimeline_.setDuration(this.getMinDuration_());
  982.     }
  984.     // This is the first point where we have a meaningful presentation start
  985.     // time, and we need to tell PresentationTimeline that so that it can
  986.     // maintain consistency from here on.
  987.     this.presentationTimeline_.lockStartTime();
  989.     // This asserts that the live edge is being calculated from segment times.
  990.     // For VOD and event streams, this check should still pass.
  991.     goog.asserts.assert(
  992.         !this.presentationTimeline_.usingPresentationStartTime(),
  993.         'We should not be using the presentation start time in HLS!');
  994.   }
  996.   /**
  997.    * Get the variables of each variant tag, and store in a map.
  998.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  999.    * @private
  1000.    */
  1001.   parseMasterVariables_(tags) {
  1002.     const queryParams = new goog.Uri(this.masterPlaylistUri_).getQueryData();
  1003.     for (const variableTag of tags) {
  1004.       const name = variableTag.getAttributeValue('NAME');
  1005.       const value = variableTag.getAttributeValue('VALUE');
  1006.       const queryParam = variableTag.getAttributeValue('QUERYPARAM');
  1007.       if (name && value) {
  1008.         if (!this.globalVariables_.has(name)) {
  1009.           this.globalVariables_.set(name, value);
  1010.         }
  1011.       }
  1012.       if (queryParam) {
  1013.         const queryParamValue = queryParams.get(queryParam)[0];
  1014.         if (queryParamValue && !this.globalVariables_.has(queryParamValue)) {
  1015.           this.globalVariables_.set(queryParam, queryParamValue);
  1016.         }
  1017.       }
  1018.     }
  1019.   }
  1021.   /**
  1022.    * Get the variables of each variant tag, and store in a map.
  1023.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1024.    * @param {string} uri Media playlist URI.
  1025.    * @return {!Map.<string, string>}
  1026.    * @private
  1027.    */
  1028.   parseMediaVariables_(tags, uri) {
  1029.     const queryParams = new goog.Uri(uri).getQueryData();
  1030.     const mediaVariables = new Map();
  1031.     for (const variableTag of tags) {
  1032.       const name = variableTag.getAttributeValue('NAME');
  1033.       const value = variableTag.getAttributeValue('VALUE');
  1034.       const queryParam = variableTag.getAttributeValue('QUERYPARAM');
  1035.       const mediaImport = variableTag.getAttributeValue('IMPORT');
  1036.       if (name && value) {
  1037.         if (!mediaVariables.has(name)) {
  1038.           mediaVariables.set(name, value);
  1039.         }
  1040.       }
  1041.       if (queryParam) {
  1042.         const queryParamValue = queryParams.get(queryParam)[0];
  1043.         if (queryParamValue && !mediaVariables.has(queryParamValue)) {
  1044.           mediaVariables.set(queryParam, queryParamValue);
  1045.         }
  1046.       }
  1047.       if (mediaImport) {
  1048.         const globalValue = this.globalVariables_.get(mediaImport);
  1049.         if (globalValue) {
  1050.           mediaVariables.set(mediaImport, globalValue);
  1051.         }
  1052.       }
  1053.     }
  1054.     return mediaVariables;
  1055.   }
  1057.   /**
  1058.    * Get the codecs of each variant tag, and store in a map from
  1059.    * audio/video/subtitle group id to the codecs arraylist.
  1060.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1061.    * @private
  1062.    */
  1063.   parseCodecs_(tags) {
  1064.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1066.     for (const variantTag of tags) {
  1067.       const audioGroupId = variantTag.getAttributeValue('AUDIO');
  1068.       const videoGroupId = variantTag.getAttributeValue('VIDEO');
  1069.       const subGroupId = variantTag.getAttributeValue('SUBTITLES');
  1070.       const allCodecs = this.getCodecsForVariantTag_(variantTag);
  1072.       if (subGroupId) {
  1073.         const textCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1074.             ContentType.TEXT, allCodecs);
  1075.         goog.asserts.assert(textCodecs != null, 'Text codecs should be valid.');
  1076.         this.groupIdToCodecsMap_.set(subGroupId, textCodecs);
  1077.         shaka.util.ArrayUtils.remove(allCodecs, textCodecs);
  1078.       }
  1079.       if (audioGroupId) {
  1080.         let codecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1081.             ContentType.AUDIO, allCodecs);
  1082.         if (!codecs) {
  1083.           codecs = this.config_.hls.defaultAudioCodec;
  1084.         }
  1085.         this.groupIdToCodecsMap_.set(audioGroupId, codecs);
  1086.       }
  1087.       if (videoGroupId) {
  1088.         let codecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1089.             ContentType.VIDEO, allCodecs);
  1090.         if (!codecs) {
  1091.           codecs = this.config_.hls.defaultVideoCodec;
  1092.         }
  1093.         this.groupIdToCodecsMap_.set(videoGroupId, codecs);
  1094.       }
  1095.     }
  1096.   }
  1098.   /**
  1099.    * Process EXT-X-SESSION-DATA tags.
  1100.    *
  1101.    * @param {!Array.<!shaka.hls.Tag>} tags
  1102.    * @private
  1103.    */
  1104.   processSessionData_(tags) {
  1105.     for (const tag of tags) {
  1106.       const id = tag.getAttributeValue('DATA-ID');
  1107.       const uri = tag.getAttributeValue('URI');
  1108.       const language = tag.getAttributeValue('LANGUAGE');
  1109.       const value = tag.getAttributeValue('VALUE');
  1110.       const data = (new Map()).set('id', id);
  1111.       if (uri) {
  1112.         data.set('uri', shaka.hls.Utils.constructSegmentUris(
  1113.             [this.masterPlaylistUri_], uri, this.globalVariables_)[0]);
  1114.       }
  1115.       if (language) {
  1116.         data.set('language', language);
  1117.       }
  1118.       if (value) {
  1119.         data.set('value', value);
  1120.       }
  1121.       const event = new shaka.util.FakeEvent('sessiondata', data);
  1122.       if (this.playerInterface_) {
  1123.         this.playerInterface_.onEvent(event);
  1124.       }
  1125.     }
  1126.   }
  1128.   /**
  1129.    * Process EXT-X-CONTENT-STEERING tags.
  1130.    *
  1131.    * @param {!Array.<!shaka.hls.Tag>} tags
  1132.    * @return {!Promise}
  1133.    * @private
  1134.    */
  1135.   async processContentSteering_(tags) {
  1136.     if (!this.playerInterface_ || !this.config_) {
  1137.       return;
  1138.     }
  1139.     let contentSteeringPromise;
  1140.     for (const tag of tags) {
  1141.       const defaultPathwayId = tag.getAttributeValue('PATHWAY-ID');
  1142.       const uri = tag.getAttributeValue('SERVER-URI');
  1143.       if (!defaultPathwayId || !uri) {
  1144.         continue;
  1145.       }
  1146.       this.contentSteeringManager_ =
  1147.             new shaka.util.ContentSteeringManager(this.playerInterface_);
  1148.       this.contentSteeringManager_.configure(this.config_);
  1149.       this.contentSteeringManager_.setBaseUris([this.masterPlaylistUri_]);
  1150.       this.contentSteeringManager_.setManifestType(
  1151.           shaka.media.ManifestParser.HLS);
  1152.       this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
  1153.       contentSteeringPromise =
  1154.           this.contentSteeringManager_.requestInfo(uri);
  1155.       break;
  1156.     }
  1157.     await contentSteeringPromise;
  1158.   }
  1160.   /**
  1161.    * Parse Subtitles and Closed Captions from 'EXT-X-MEDIA' tags.
  1162.    * Create text streams for Subtitles, but not Closed Captions.
  1163.    *
  1164.    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
  1165.    * @return {!Array.<!shaka.extern.Stream>}
  1166.    * @private
  1167.    */
  1168.   parseTexts_(mediaTags) {
  1169.     // Create text stream for each Subtitle media tag.
  1170.     const subtitleTags =
  1171.         shaka.hls.Utils.filterTagsByType(mediaTags, 'SUBTITLES');
  1172.     const textStreams = subtitleTags.map((tag) => {
  1173.       const disableText = this.config_.disableText;
  1174.       if (disableText) {
  1175.         return null;
  1176.       }
  1177.       try {
  1178.         return this.createStreamInfoFromMediaTags_([tag], new Map()).stream;
  1179.       } catch (e) {
  1180.         if (this.config_.hls.ignoreTextStreamFailures) {
  1181.           return null;
  1182.         }
  1183.         throw e;
  1184.       }
  1185.     });
  1187.     const type = shaka.util.ManifestParserUtils.ContentType.TEXT;
  1189.     // Set the codecs for text streams.
  1190.     for (const tag of subtitleTags) {
  1191.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1192.       const codecs = this.groupIdToCodecsMap_.get(groupId);
  1193.       if (codecs) {
  1194.         const textStreamInfos = this.groupIdToStreamInfosMap_.get(groupId);
  1195.         if (textStreamInfos) {
  1196.           for (const textStreamInfo of textStreamInfos) {
  1197.             textStreamInfo.stream.codecs = codecs;
  1198.             textStreamInfo.stream.mimeType =
  1199.                 this.guessMimeTypeBeforeLoading_(type, codecs) ||
  1200.                 this.guessMimeTypeFallback_(type);
  1201.           }
  1202.         }
  1203.       }
  1204.     }
  1206.     // Do not create text streams for Closed captions.
  1207.     return textStreams.filter((s) => s);
  1208.   }
  1210.   /**
  1211.    * @param {!Array.<!shaka.hls.Tag>} imageTags from the playlist.
  1212.    * @param {!Array.<!shaka.hls.Tag>} iFrameTags from the playlist.
  1213.    * @return {!Promise.<!Array.<!shaka.extern.Stream>>}
  1214.    * @private
  1215.    */
  1216.   async parseImages_(imageTags, iFrameTags) {
  1217.     // Create image stream for each image tag.
  1218.     const imageStreamPromises = imageTags.map(async (tag) => {
  1219.       const disableThumbnails = this.config_.disableThumbnails;
  1220.       if (disableThumbnails) {
  1221.         return null;
  1222.       }
  1223.       try {
  1224.         const streamInfo = await this.createStreamInfoFromImageTag_(tag);
  1225.         return streamInfo.stream;
  1226.       } catch (e) {
  1227.         if (this.config_.hls.ignoreImageStreamFailures) {
  1228.           return null;
  1229.         }
  1230.         throw e;
  1231.       }
  1232.     }).concat(iFrameTags.map((tag) => {
  1233.       const disableThumbnails = this.config_.disableThumbnails;
  1234.       if (disableThumbnails) {
  1235.         return null;
  1236.       }
  1237.       try {
  1238.         const streamInfo = this.createStreamInfoFromIframeTag_(tag);
  1239.         if (streamInfo.stream.codecs !== 'mjpg') {
  1240.           return null;
  1241.         }
  1242.         return streamInfo.stream;
  1243.       } catch (e) {
  1244.         if (this.config_.hls.ignoreImageStreamFailures) {
  1245.           return null;
  1246.         }
  1247.         throw e;
  1248.       }
  1249.     }));
  1250.     const imageStreams = await Promise.all(imageStreamPromises);
  1251.     return imageStreams.filter((s) => s);
  1252.   }
  1254.   /**
  1255.    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
  1256.    * @param {!Map.<string, string>} groupIdPathwayIdMapping
  1257.    * @private
  1258.    */
  1259.   createStreamInfosFromMediaTags_(mediaTags, groupIdPathwayIdMapping) {
  1260.     // Filter out subtitles and  media tags without uri.
  1261.     mediaTags = mediaTags.filter((tag) => {
  1262.       const uri = tag.getAttributeValue('URI') || '';
  1263.       const type = tag.getAttributeValue('TYPE');
  1264.       return type != 'SUBTITLES' && uri != '';
  1265.     });
  1267.     const groupedTags = {};
  1268.     for (const tag of mediaTags) {
  1269.       const key = tag.getTagKey();
  1270.       if (!groupedTags[key]) {
  1271.         groupedTags[key] = [tag];
  1272.       } else {
  1273.         groupedTags[key].push(tag);
  1274.       }
  1275.     }
  1277.     for (const key in groupedTags) {
  1278.       // Create stream info for each audio / video media grouped tag.
  1279.       this.createStreamInfoFromMediaTags_(
  1280.           groupedTags[key], groupIdPathwayIdMapping);
  1281.     }
  1282.   }
  1284.   /**
  1285.    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
  1286.    * @param {!Array.<!shaka.hls.Tag>} sessionKeyTags EXT-X-SESSION-KEY tags
  1287.    * from the playlist.
  1288.    * @param {!Array.<!shaka.hls.Tag>} mediaTags EXT-X-MEDIA tags from the
  1289.    * playlist.
  1290.    * @return {!Array.<!shaka.extern.Variant>}
  1291.    * @private
  1292.    */
  1293.   createVariantsForTags_(tags, sessionKeyTags, mediaTags) {
  1294.     // EXT-X-SESSION-KEY processing
  1295.     const drmInfos = [];
  1296.     const keyIds = new Set();
  1297.     if (sessionKeyTags.length > 0) {
  1298.       for (const drmTag of sessionKeyTags) {
  1299.         const method = drmTag.getRequiredAttrValue('METHOD');
  1300.         if (method != 'NONE' && method != 'AES-128') {
  1301.           // According to the HLS spec, KEYFORMAT is optional and implicitly
  1302.           // defaults to "identity".
  1303.           // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
  1304.           const keyFormat =
  1305.               drmTag.getAttributeValue('KEYFORMAT') || 'identity';
  1306.           const drmParser =
  1307.               shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  1309.           const drmInfo = drmParser ?
  1310.               drmParser(drmTag, /* mimeType= */ '') : null;
  1311.           if (drmInfo) {
  1312.             if (drmInfo.keyIds) {
  1313.               for (const keyId of drmInfo.keyIds) {
  1314.                 keyIds.add(keyId);
  1315.               }
  1316.             }
  1317.             drmInfos.push(drmInfo);
  1318.           } else {
  1319.             shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  1320.           }
  1321.         }
  1322.       }
  1323.     }
  1325.     const groupedTags = {};
  1326.     for (const tag of tags) {
  1327.       const key = tag.getTagKey();
  1328.       if (!groupedTags[key]) {
  1329.         groupedTags[key] = [tag];
  1330.       } else {
  1331.         groupedTags[key].push(tag);
  1332.       }
  1333.     }
  1335.     const allVariants = [];
  1336.     // Create variants for each group of variant tag.
  1337.     for (const key in groupedTags) {
  1338.       const tags = groupedTags[key];
  1339.       const firstTag = tags[0];
  1341.       const frameRate = firstTag.getAttributeValue('FRAME-RATE');
  1342.       const bandwidth =
  1343.           Number(firstTag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
  1344.           Number(firstTag.getRequiredAttrValue('BANDWIDTH'));
  1346.       const resolution = firstTag.getAttributeValue('RESOLUTION');
  1347.       const [width, height] = resolution ? resolution.split('x') : [null, null];
  1349.       const videoRange = firstTag.getAttributeValue('VIDEO-RANGE');
  1351.       let videoLayout = firstTag.getAttributeValue('REQ-VIDEO-LAYOUT');
  1352.       if (videoLayout && videoLayout.includes(',')) {
  1353.         // If multiple video layout strings are present, pick the first valid
  1354.         // one.
  1355.         const layoutStrings = videoLayout.split(',').filter((layoutString) => {
  1356.           return layoutString == 'CH-STEREO' || layoutString == 'CH-MONO';
  1357.         });
  1358.         videoLayout = layoutStrings[0];
  1359.       }
  1360.       // According to the HLS spec:
  1361.       // By default a video variant is monoscopic, so an attribute
  1362.       // consisting entirely of REQ-VIDEO-LAYOUT="CH-MONO" is unnecessary
  1363.       // and SHOULD NOT be present.
  1364.       videoLayout = videoLayout || 'CH-MONO';
  1366.       const streamInfos = this.createStreamInfosForVariantTags_(tags,
  1367.           mediaTags, resolution, frameRate);
  1369.       goog.asserts.assert(streamInfos.audio.length ||
  1370.           streamInfos.video.length, 'We should have created a stream!');
  1372.       allVariants.push(...this.createVariants_(
  1373.           streamInfos.audio,
  1374.           streamInfos.video,
  1375.           bandwidth,
  1376.           width,
  1377.           height,
  1378.           frameRate,
  1379.           videoRange,
  1380.           videoLayout,
  1381.           drmInfos,
  1382.           keyIds));
  1383.     }
  1384.     return allVariants.filter((variant) => variant != null);
  1385.   }
  1387.   /**
  1388.    * Create audio and video streamInfos from an 'EXT-X-STREAM-INF' tag and its
  1389.    * related media tags.
  1390.    *
  1391.    * @param {!Array.<!shaka.hls.Tag>} tags
  1392.    * @param {!Array.<!shaka.hls.Tag>} mediaTags
  1393.    * @param {?string} resolution
  1394.    * @param {?string} frameRate
  1395.    * @return {!shaka.hls.HlsParser.StreamInfos}
  1396.    * @private
  1397.    */
  1398.   createStreamInfosForVariantTags_(tags, mediaTags, resolution, frameRate) {
  1399.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1401.     /** @type {shaka.hls.HlsParser.StreamInfos} */
  1402.     const res = {
  1403.       audio: [],
  1404.       video: [],
  1405.     };
  1406.     const groupIdPathwayIdMapping = new Map();
  1407.     const globalGroupIds = [];
  1408.     let isAudioGroup = false;
  1409.     let isVideoGroup = false;
  1410.     for (const tag of tags) {
  1411.       const audioGroupId = tag.getAttributeValue('AUDIO');
  1412.       const videoGroupId = tag.getAttributeValue('VIDEO');
  1413.       goog.asserts.assert(audioGroupId == null || videoGroupId == null,
  1414.           'Unexpected: both video and audio described by media tags!');
  1416.       const groupId = audioGroupId || videoGroupId;
  1417.       if (!groupId) {
  1418.         continue;
  1419.       }
  1420.       if (!globalGroupIds.includes(groupId)) {
  1421.         globalGroupIds.push(groupId);
  1422.       }
  1423.       const pathwayId = tag.getAttributeValue('PATHWAY-ID');
  1424.       if (pathwayId) {
  1425.         groupIdPathwayIdMapping.set(groupId, pathwayId);
  1426.       }
  1427.       if (audioGroupId) {
  1428.         isAudioGroup = true;
  1429.       } else if (videoGroupId) {
  1430.         isVideoGroup = true;
  1431.       }
  1432.       // Make an educated guess about the stream type.
  1433.       shaka.log.debug('Guessing stream type for', tag.toString());
  1434.     }
  1435.     if (globalGroupIds.length && mediaTags.length) {
  1436.       const mediaTagsForVariant = mediaTags.filter((tag) => {
  1437.         return globalGroupIds.includes(tag.getRequiredAttrValue('GROUP-ID'));
  1438.       });
  1439.       this.createStreamInfosFromMediaTags_(
  1440.           mediaTagsForVariant, groupIdPathwayIdMapping);
  1441.     }
  1442.     const globalGroupId = globalGroupIds.sort().join(',');
  1443.     const streamInfos =
  1444.         (globalGroupId && this.groupIdToStreamInfosMap_.has(globalGroupId)) ?
  1445.         this.groupIdToStreamInfosMap_.get(globalGroupId) : [];
  1446.     if (isAudioGroup) {
  1447.       res.audio.push(...streamInfos);
  1448.     } else if (isVideoGroup) {
  1449.       res.video.push(...streamInfos);
  1450.     }
  1452.     let type;
  1453.     let ignoreStream = false;
  1455.     // The Microsoft HLS manifest generators will make audio-only variants
  1456.     // that link to their URI both directly and through an audio tag.
  1457.     // In that case, ignore the local URI and use the version in the
  1458.     // AUDIO tag, so you inherit its language.
  1459.     // As an example, see the manifest linked in issue #860.
  1460.     const allStreamUris = tags.map((tag) => tag.getRequiredAttrValue('URI'));
  1461.     const hasSameUri = res.audio.find((audio) => {
  1462.       return audio && audio.getUris().find((uri) => {
  1463.         return allStreamUris.includes(uri);
  1464.       });
  1465.     });
  1467.     /** @type {!Array.<string>} */
  1468.     let allCodecs = this.getCodecsForVariantTag_(tags[0]);
  1469.     const videoCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1470.         ContentType.VIDEO, allCodecs);
  1471.     const audioCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
  1472.         ContentType.AUDIO, allCodecs);
  1474.     if (audioCodecs && !videoCodecs) {
  1475.       // There are no associated media tags, and there's only audio codec,
  1476.       // and no video codec, so it should be audio.
  1477.       type = ContentType.AUDIO;
  1478.       shaka.log.debug('Guessing audio-only.');
  1479.       ignoreStream = res.audio.length > 0;
  1480.     } else if (!res.audio.length && !res.video.length &&
  1481.         audioCodecs && videoCodecs) {
  1482.       // There are both audio and video codecs, so assume multiplexed content.
  1483.       // Note that the default used when CODECS is missing assumes multiple
  1484.       // (and therefore multiplexed).
  1485.       // Recombine the codec strings into one so that MediaSource isn't
  1486.       // lied to later. (That would trigger an error in Chrome.)
  1487.       shaka.log.debug('Guessing multiplexed audio+video.');
  1488.       type = ContentType.VIDEO;
  1489.       allCodecs = [[videoCodecs, audioCodecs].join(',')];
  1490.     } else if (res.audio.length && hasSameUri) {
  1491.       shaka.log.debug('Guessing audio-only.');
  1492.       type = ContentType.AUDIO;
  1493.       ignoreStream = true;
  1494.     } else if (res.video.length && !res.audio.length) {
  1495.       // There are associated video streams.  Assume this is audio.
  1496.       shaka.log.debug('Guessing audio-only.');
  1497.       type = ContentType.AUDIO;
  1498.     } else {
  1499.       shaka.log.debug('Guessing video-only.');
  1500.       type = ContentType.VIDEO;
  1501.     }
  1503.     if (!ignoreStream) {
  1504.       let language = null;
  1505.       let name = null;
  1506.       let channelsCount = null;
  1507.       let spatialAudio = false;
  1508.       let characteristics = null;
  1509.       let sampleRate = null;
  1510.       if (!streamInfos.length) {
  1511.         const mediaTag = mediaTags.find((tag) => {
  1512.           const uri = tag.getAttributeValue('URI') || '';
  1513.           const type = tag.getAttributeValue('TYPE');
  1514.           const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1515.           return type != 'SUBTITLES' && uri == '' &&
  1516.               globalGroupIds.includes(groupId);
  1517.         });
  1518.         if (mediaTag) {
  1519.           language = mediaTag.getAttributeValue('LANGUAGE');
  1520.           name = mediaTag.getAttributeValue('NAME');
  1521.           channelsCount = this.getChannelsCount_(mediaTag);
  1522.           spatialAudio = this.isSpatialAudio_(mediaTag);
  1523.           characteristics = mediaTag.getAttributeValue('CHARACTERISTICS');
  1524.           sampleRate = this.getSampleRate_(mediaTag);
  1525.         }
  1526.       }
  1527.       const streamInfo = this.createStreamInfoFromVariantTags_(
  1528.           tags, allCodecs, type, language, name, channelsCount,
  1529.           characteristics, sampleRate, spatialAudio);
  1530.       if (globalGroupId) {
  1531.         streamInfo.stream.groupId = globalGroupId;
  1532.       }
  1533.       res[streamInfo.stream.type] = [streamInfo];
  1534.     }
  1535.     return res;
  1536.   }
  1539.   /**
  1540.    * Get the codecs from the 'EXT-X-STREAM-INF' tag.
  1541.    *
  1542.    * @param {!shaka.hls.Tag} tag
  1543.    * @return {!Array.<string>} codecs
  1544.    * @private
  1545.    */
  1546.   getCodecsForVariantTag_(tag) {
  1547.     let codecsString = tag.getAttributeValue('CODECS') || '';
  1549.     this.codecInfoInManifest_ = codecsString.length > 0;
  1551.     if (!this.codecInfoInManifest_ && !this.config_.hls.disableCodecGuessing) {
  1552.       // These are the default codecs to assume if none are specified.
  1553.       const defaultCodecsArray = [];
  1555.       if (!this.config_.disableVideo) {
  1556.         defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
  1557.       }
  1558.       if (!this.config_.disableAudio) {
  1559.         defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
  1560.       }
  1562.       codecsString = defaultCodecsArray.join(',');
  1563.     }
  1565.     // Strip out internal whitespace while splitting on commas:
  1566.     /** @type {!Array.<string>} */
  1567.     const codecs = codecsString.split(/\s*,\s*/);
  1569.     return this.filterDuplicateCodecs_(codecs);
  1570.   }
  1573.   /**
  1574.    * @param {!Array.<string>} codecs
  1575.    * @return {!Array.<string>} codecs
  1576.    * @private
  1577.    */
  1578.   filterDuplicateCodecs_(codecs) {
  1579.     // Filter out duplicate codecs.
  1580.     const seen = new Set();
  1581.     const ret = [];
  1582.     for (const codec of codecs) {
  1583.       // HLS says the CODECS field needs to include all codecs that appear in
  1584.       // the content. This means that if the content changes profiles, it should
  1585.       // include both. Since all known browsers support changing profiles
  1586.       // without any other work, just ignore them.  See also:
  1587.       // https://github.com/shaka-project/shaka-player/issues/1817
  1588.       const shortCodec = shaka.util.MimeUtils.getCodecBase(codec);
  1589.       if (!seen.has(shortCodec)) {
  1590.         ret.push(codec);
  1591.         seen.add(shortCodec);
  1592.       } else {
  1593.         shaka.log.debug('Ignoring duplicate codec');
  1594.       }
  1595.     }
  1596.     return ret;
  1597.   }
  1599.   /**
  1600.    * Get the channel count information for an HLS audio track.
  1601.    * CHANNELS specifies an ordered, "/" separated list of parameters.
  1602.    * If the type is audio, the first parameter will be a decimal integer
  1603.    * specifying the number of independent, simultaneous audio channels.
  1604.    * No other channels parameters are currently defined.
  1605.    *
  1606.    * @param {!shaka.hls.Tag} tag
  1607.    * @return {?number}
  1608.    * @private
  1609.    */
  1610.   getChannelsCount_(tag) {
  1611.     const channels = tag.getAttributeValue('CHANNELS');
  1612.     if (!channels) {
  1613.       return null;
  1614.     }
  1615.     const channelcountstring = channels.split('/')[0];
  1616.     const count = parseInt(channelcountstring, 10);
  1617.     return count;
  1618.   }
  1620.   /**
  1621.    * Get the sample rate information for an HLS audio track.
  1622.    *
  1623.    * @param {!shaka.hls.Tag} tag
  1624.    * @return {?number}
  1625.    * @private
  1626.    */
  1627.   getSampleRate_(tag) {
  1628.     const sampleRate = tag.getAttributeValue('SAMPLE-RATE');
  1629.     if (!sampleRate) {
  1630.       return null;
  1631.     }
  1632.     return parseInt(sampleRate, 10);
  1633.   }
  1635.   /**
  1636.    * Get the spatial audio information for an HLS audio track.
  1637.    * In HLS the channels field indicates the number of audio channels that the
  1638.    * stream has (eg: 2). In the case of Dolby Atmos, the complexity is
  1639.    * expressed with the number of channels followed by the word JOC
  1640.    * (eg: 16/JOC), so 16 would be the number of channels (eg: 7.3.6 layout),
  1641.    * and JOC indicates that the stream has spatial audio.
  1642.    * @see https://developer.apple.com/documentation/http_live_streaming/hls_authoring_specification_for_apple_devices/hls_authoring_specification_for_apple_devices_appendixes
  1643.    *
  1644.    * @param {!shaka.hls.Tag} tag
  1645.    * @return {boolean}
  1646.    * @private
  1647.    */
  1648.   isSpatialAudio_(tag) {
  1649.     const channels = tag.getAttributeValue('CHANNELS');
  1650.     if (!channels) {
  1651.       return false;
  1652.     }
  1653.     return channels.includes('/JOC');
  1654.   }
  1656.   /**
  1657.    * Get the closed captions map information for the EXT-X-STREAM-INF tag, to
  1658.    * create the stream info.
  1659.    * @param {!shaka.hls.Tag} tag
  1660.    * @param {string} type
  1661.    * @return {Map.<string, string>} closedCaptions
  1662.    * @private
  1663.    */
  1664.   getClosedCaptions_(tag, type) {
  1665.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1666.     // The attribute of closed captions is optional, and the value may be
  1667.     // 'NONE'.
  1668.     const closedCaptionsAttr = tag.getAttributeValue('CLOSED-CAPTIONS');
  1670.     // EXT-X-STREAM-INF tags may have CLOSED-CAPTIONS attributes.
  1671.     // The value can be either a quoted-string or an enumerated-string with
  1672.     // the value NONE. If the value is a quoted-string, it MUST match the
  1673.     // value of the GROUP-ID attribute of an EXT-X-MEDIA tag elsewhere in the
  1674.     // Playlist whose TYPE attribute is CLOSED-CAPTIONS.
  1675.     if (type == ContentType.VIDEO && closedCaptionsAttr &&
  1676.     closedCaptionsAttr != 'NONE') {
  1677.       return this.groupIdToClosedCaptionsMap_.get(closedCaptionsAttr);
  1678.     }
  1679.     return null;
  1680.   }
  1682.   /**
  1683.    * Get the normalized language value.
  1684.    *
  1685.    * @param {?string} languageValue
  1686.    * @return {string}
  1687.    * @private
  1688.    */
  1689.   getLanguage_(languageValue) {
  1690.     const LanguageUtils = shaka.util.LanguageUtils;
  1691.     return LanguageUtils.normalize(languageValue || 'und');
  1692.   }
  1694.   /**
  1695.    * Get the type value.
  1696.    * Shaka recognizes the content types 'audio', 'video', 'text', and 'image'.
  1697.    * The HLS 'subtitles' type needs to be mapped to 'text'.
  1698.    * @param {!shaka.hls.Tag} tag
  1699.    * @return {string}
  1700.    * @private
  1701.    */
  1702.   getType_(tag) {
  1703.     let type = tag.getRequiredAttrValue('TYPE').toLowerCase();
  1704.     if (type == 'subtitles') {
  1705.       type = shaka.util.ManifestParserUtils.ContentType.TEXT;
  1706.     }
  1707.     return type;
  1708.   }
  1710.   /**
  1711.    * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} audioInfos
  1712.    * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} videoInfos
  1713.    * @param {number} bandwidth
  1714.    * @param {?string} width
  1715.    * @param {?string} height
  1716.    * @param {?string} frameRate
  1717.    * @param {?string} videoRange
  1718.    * @param {?string} videoLayout
  1719.    * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
  1720.    * @param {!Set.<string>} keyIds
  1721.    * @return {!Array.<!shaka.extern.Variant>}
  1722.    * @private
  1723.    */
  1724.   createVariants_(
  1725.       audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange,
  1726.       videoLayout, drmInfos, keyIds) {
  1727.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1728.     const DrmEngine = shaka.media.DrmEngine;
  1730.     for (const info of videoInfos) {
  1731.       this.addVideoAttributes_(
  1732.           info.stream, width, height, frameRate, videoRange, videoLayout);
  1733.     }
  1735.     // In case of audio-only or video-only content or the audio/video is
  1736.     // disabled by the config, we create an array of one item containing
  1737.     // a null. This way, the double-loop works for all kinds of content.
  1738.     // NOTE: we currently don't have support for audio-only content.
  1739.     const disableAudio = this.config_.disableAudio;
  1740.     if (!audioInfos.length || disableAudio) {
  1741.       audioInfos = [null];
  1742.     }
  1743.     const disableVideo = this.config_.disableVideo;
  1744.     if (!videoInfos.length || disableVideo) {
  1745.       videoInfos = [null];
  1746.     }
  1748.     const variants = [];
  1749.     for (const audioInfo of audioInfos) {
  1750.       for (const videoInfo of videoInfos) {
  1751.         const audioStream = audioInfo ? audioInfo.stream : null;
  1752.         if (audioStream) {
  1753.           audioStream.drmInfos = drmInfos;
  1754.           audioStream.keyIds = keyIds;
  1755.         }
  1756.         const videoStream = videoInfo ? videoInfo.stream : null;
  1757.         if (videoStream) {
  1758.           videoStream.drmInfos = drmInfos;
  1759.           videoStream.keyIds = keyIds;
  1760.         }
  1761.         const audioDrmInfos = audioInfo ? audioInfo.stream.drmInfos : null;
  1762.         const videoDrmInfos = videoInfo ? videoInfo.stream.drmInfos : null;
  1763.         const videoStreamUri =
  1764.             videoInfo ? videoInfo.getUris().sort().join(',') : '';
  1765.         const audioStreamUri =
  1766.             audioInfo ? audioInfo.getUris().sort().join(',') : '';
  1767.         const variantUriKey = videoStreamUri + ' - ' + audioStreamUri;
  1769.         if (audioStream && videoStream) {
  1770.           if (!DrmEngine.areDrmCompatible(audioDrmInfos, videoDrmInfos)) {
  1771.             shaka.log.warning(
  1772.                 'Incompatible DRM info in HLS variant.  Skipping.');
  1773.             continue;
  1774.           }
  1775.         }
  1777.         if (this.variantUriSet_.has(variantUriKey)) {
  1778.           // This happens when two variants only differ in their text streams.
  1779.           shaka.log.debug(
  1780.               'Skipping variant which only differs in text streams.');
  1781.           continue;
  1782.         }
  1784.         // Since both audio and video are of the same type, this assertion will
  1785.         // catch certain mistakes at runtime that the compiler would miss.
  1786.         goog.asserts.assert(!audioStream ||
  1787.             audioStream.type == ContentType.AUDIO, 'Audio parameter mismatch!');
  1788.         goog.asserts.assert(!videoStream ||
  1789.             videoStream.type == ContentType.VIDEO, 'Video parameter mismatch!');
  1791.         const variant = {
  1792.           id: this.globalId_++,
  1793.           language: audioStream ? audioStream.language : 'und',
  1794.           disabledUntilTime: 0,
  1795.           primary: (!!audioStream && audioStream.primary) ||
  1796.               (!!videoStream && videoStream.primary),
  1797.           audio: audioStream,
  1798.           video: videoStream,
  1799.           bandwidth,
  1800.           allowedByApplication: true,
  1801.           allowedByKeySystem: true,
  1802.           decodingInfos: [],
  1803.         };
  1805.         variants.push(variant);
  1806.         this.variantUriSet_.add(variantUriKey);
  1807.       }
  1808.     }
  1809.     return variants;
  1810.   }
  1812.   /**
  1813.    * Parses an array of EXT-X-MEDIA tags, then stores the values of all tags
  1814.    * with TYPE="CLOSED-CAPTIONS" into a map of group id to closed captions.
  1815.    *
  1816.    * @param {!Array.<!shaka.hls.Tag>} mediaTags
  1817.    * @private
  1818.    */
  1819.   parseClosedCaptions_(mediaTags) {
  1820.     const closedCaptionsTags =
  1821.         shaka.hls.Utils.filterTagsByType(mediaTags, 'CLOSED-CAPTIONS');
  1822.     for (const tag of closedCaptionsTags) {
  1823.       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  1824.           'Should only be called on media tags!');
  1825.       const languageValue = tag.getAttributeValue('LANGUAGE');
  1826.       let language = this.getLanguage_(languageValue);
  1827.       if (!languageValue) {
  1828.         const nameValue = tag.getAttributeValue('NAME');
  1829.         if (nameValue) {
  1830.           language = nameValue;
  1831.         }
  1832.       }
  1834.       // The GROUP-ID value is a quoted-string that specifies the group to which
  1835.       // the Rendition belongs.
  1836.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1838.       // The value of INSTREAM-ID is a quoted-string that specifies a Rendition
  1839.       // within the segments in the Media Playlist. This attribute is REQUIRED
  1840.       // if the TYPE attribute is CLOSED-CAPTIONS.
  1841.       // We need replace SERVICE string by our internal svc string.
  1842.       const instreamId = tag.getRequiredAttrValue('INSTREAM-ID')
  1843.           .replace('SERVICE', 'svc');
  1844.       if (!this.groupIdToClosedCaptionsMap_.get(groupId)) {
  1845.         this.groupIdToClosedCaptionsMap_.set(groupId, new Map());
  1846.       }
  1847.       this.groupIdToClosedCaptionsMap_.get(groupId).set(instreamId, language);
  1848.     }
  1849.   }
  1851.   /**
  1852.    * Parse EXT-X-MEDIA media tag into a Stream object.
  1853.    *
  1854.    * @param {!Array.<!shaka.hls.Tag>} tags
  1855.    * @param {!Map.<string, string>} groupIdPathwayIdMapping
  1856.    * @return {!shaka.hls.HlsParser.StreamInfo}
  1857.    * @private
  1858.    */
  1859.   createStreamInfoFromMediaTags_(tags, groupIdPathwayIdMapping) {
  1860.     const verbatimMediaPlaylistUris = [];
  1861.     const globalGroupIds = [];
  1862.     const groupIdUriMappping = new Map();
  1863.     for (const tag of tags) {
  1864.       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
  1865.           'Should only be called on media tags!');
  1866.       const uri = tag.getRequiredAttrValue('URI');
  1867.       const groupId = tag.getRequiredAttrValue('GROUP-ID');
  1868.       verbatimMediaPlaylistUris.push(uri);
  1869.       globalGroupIds.push(groupId);
  1870.       groupIdUriMappping.set(groupId, uri);
  1871.     }
  1873.     const globalGroupId = globalGroupIds.sort().join(',');
  1874.     const firstTag = tags[0];
  1875.     let codecs = '';
  1876.     /** @type {string} */
  1877.     const type = this.getType_(firstTag);
  1878.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  1879.       codecs = firstTag.getAttributeValue('CODECS') || '';
  1880.     } else {
  1881.       for (const groupId of globalGroupIds) {
  1882.         if (this.groupIdToCodecsMap_.has(groupId)) {
  1883.           codecs = this.groupIdToCodecsMap_.get(groupId);
  1884.           break;
  1885.         }
  1886.       }
  1887.     }
  1889.     // Check if the stream has already been created as part of another Variant
  1890.     // and return it if it has.
  1891.     const key = verbatimMediaPlaylistUris.sort().join(',');
  1892.     if (this.uriToStreamInfosMap_.has(key)) {
  1893.       return this.uriToStreamInfosMap_.get(key);
  1894.     }
  1895.     const streamId = this.globalId_++;
  1896.     if (this.contentSteeringManager_) {
  1897.       for (const [groupId, uri] of groupIdUriMappping) {
  1898.         const pathwayId = groupIdPathwayIdMapping.get(groupId);
  1899.         if (pathwayId) {
  1900.           this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
  1901.         }
  1902.       }
  1903.     }
  1905.     const language = firstTag.getAttributeValue('LANGUAGE');
  1906.     const name = firstTag.getAttributeValue('NAME');
  1908.     // NOTE: According to the HLS spec, "DEFAULT=YES" requires "AUTOSELECT=YES".
  1909.     // However, we don't bother to validate "AUTOSELECT", since we don't
  1910.     // actually use it in our streaming model, and we treat everything as
  1911.     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
  1912.     // only be selected explicitly by the user, and we don't have a way to
  1913.     // represent that in our model.
  1914.     const defaultAttrValue = firstTag.getAttributeValue('DEFAULT');
  1915.     const primary = defaultAttrValue == 'YES';
  1917.     const channelsCount =
  1918.         type == 'audio' ? this.getChannelsCount_(firstTag) : null;
  1919.     const spatialAudio =
  1920.         type == 'audio' ? this.isSpatialAudio_(firstTag) : false;
  1921.     const characteristics = firstTag.getAttributeValue('CHARACTERISTICS');
  1923.     const forcedAttrValue = firstTag.getAttributeValue('FORCED');
  1924.     const forced = forcedAttrValue == 'YES';
  1925.     const sampleRate = type == 'audio' ? this.getSampleRate_(firstTag) : null;
  1926.     // TODO: Should we take into account some of the currently ignored
  1927.     // attributes: INSTREAM-ID, Attribute descriptions: https://bit.ly/2lpjOhj
  1928.     const streamInfo = this.createStreamInfo_(
  1929.         streamId, verbatimMediaPlaylistUris, codecs, type, language,
  1930.         primary, name, channelsCount, /* closedCaptions= */ null,
  1931.         characteristics, forced, sampleRate, spatialAudio);
  1932.     if (streamInfo.stream) {
  1933.       streamInfo.stream.groupId = globalGroupId;
  1934.     }
  1935.     if (this.groupIdToStreamInfosMap_.has(globalGroupId)) {
  1936.       this.groupIdToStreamInfosMap_.get(globalGroupId).push(streamInfo);
  1937.     } else {
  1938.       this.groupIdToStreamInfosMap_.set(globalGroupId, [streamInfo]);
  1939.     }
  1941.     this.uriToStreamInfosMap_.set(key, streamInfo);
  1942.     return streamInfo;
  1943.   }
  1945.   /**
  1946.    * Parse EXT-X-IMAGE-STREAM-INF media tag into a Stream object.
  1947.    *
  1948.    * @param {shaka.hls.Tag} tag
  1949.    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
  1950.    * @private
  1951.    */
  1952.   async createStreamInfoFromImageTag_(tag) {
  1953.     goog.asserts.assert(tag.name == 'EXT-X-IMAGE-STREAM-INF',
  1954.         'Should only be called on image tags!');
  1955.     /** @type {string} */
  1956.     const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
  1958.     const verbatimImagePlaylistUri = tag.getRequiredAttrValue('URI');
  1959.     const codecs = tag.getAttributeValue('CODECS', 'jpeg') || '';
  1961.     // Check if the stream has already been created as part of another Variant
  1962.     // and return it if it has.
  1963.     if (this.uriToStreamInfosMap_.has(verbatimImagePlaylistUri)) {
  1964.       return this.uriToStreamInfosMap_.get(verbatimImagePlaylistUri);
  1965.     }
  1967.     const language = tag.getAttributeValue('LANGUAGE');
  1968.     const name = tag.getAttributeValue('NAME');
  1970.     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
  1972.     const streamInfo = this.createStreamInfo_(
  1973.         this.globalId_++, [verbatimImagePlaylistUri], codecs, type, language,
  1974.         /* primary= */ false, name, /* channelsCount= */ null,
  1975.         /* closedCaptions= */ null, characteristics, /* forced= */ false,
  1976.         /* sampleRate= */ null, /* spatialAudio= */ false);
  1978.     // Parse misc attributes.
  1979.     const resolution = tag.getAttributeValue('RESOLUTION');
  1980.     if (resolution) {
  1981.       // The RESOLUTION tag represents the resolution of a single thumbnail, not
  1982.       // of the entire sheet at once (like we expect in the output).
  1983.       // So multiply by the layout size.
  1985.       // Since we need to have generated the segment index for this, we can't
  1986.       // lazy-load in this situation.
  1987.       await streamInfo.stream.createSegmentIndex();
  1989.       const reference = streamInfo.stream.segmentIndex.get(0);
  1990.       const layout = reference.getTilesLayout();
  1991.       if (layout) {
  1992.         streamInfo.stream.width =
  1993.             Number(resolution.split('x')[0]) * Number(layout.split('x')[0]);
  1994.         streamInfo.stream.height =
  1995.             Number(resolution.split('x')[1]) * Number(layout.split('x')[1]);
  1996.         // TODO: What happens if there are multiple grids, with different
  1997.         // layout sizes, inside this image stream?
  1998.       }
  1999.     }
  2000.     const bandwidth = tag.getAttributeValue('BANDWIDTH');
  2001.     if (bandwidth) {
  2002.       streamInfo.stream.bandwidth = Number(bandwidth);
  2003.     }
  2005.     this.uriToStreamInfosMap_.set(verbatimImagePlaylistUri, streamInfo);
  2006.     return streamInfo;
  2007.   }
  2009.   /**
  2010.    * Parse EXT-X-I-FRAME-STREAM-INF media tag into a Stream object.
  2011.    *
  2012.    * @param {shaka.hls.Tag} tag
  2013.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2014.    * @private
  2015.    */
  2016.   createStreamInfoFromIframeTag_(tag) {
  2017.     goog.asserts.assert(tag.name == 'EXT-X-I-FRAME-STREAM-INF',
  2018.         'Should only be called on iframe tags!');
  2019.     /** @type {string} */
  2020.     const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
  2022.     const verbatimIFramePlaylistUri = tag.getRequiredAttrValue('URI');
  2023.     const codecs = tag.getAttributeValue('CODECS') || '';
  2025.     // Check if the stream has already been created as part of another Variant
  2026.     // and return it if it has.
  2027.     if (this.uriToStreamInfosMap_.has(verbatimIFramePlaylistUri)) {
  2028.       return this.uriToStreamInfosMap_.get(verbatimIFramePlaylistUri);
  2029.     }
  2031.     const language = tag.getAttributeValue('LANGUAGE');
  2032.     const name = tag.getAttributeValue('NAME');
  2034.     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
  2036.     const streamInfo = this.createStreamInfo_(
  2037.         this.globalId_++, [verbatimIFramePlaylistUri], codecs, type, language,
  2038.         /* primary= */ false, name, /* channelsCount= */ null,
  2039.         /* closedCaptions= */ null, characteristics, /* forced= */ false,
  2040.         /* sampleRate= */ null, /* spatialAudio= */ false);
  2042.     // Parse misc attributes.
  2043.     const resolution = tag.getAttributeValue('RESOLUTION');
  2044.     const [width, height] = resolution ? resolution.split('x') : [null, null];
  2045.     streamInfo.stream.width = Number(width) || undefined;
  2046.     streamInfo.stream.height = Number(height) || undefined;
  2047.     const bandwidth = tag.getAttributeValue('BANDWIDTH');
  2048.     if (bandwidth) {
  2049.       streamInfo.stream.bandwidth = Number(bandwidth);
  2050.     }
  2052.     this.uriToStreamInfosMap_.set(verbatimIFramePlaylistUri, streamInfo);
  2053.     return streamInfo;
  2054.   }
  2056.   /**
  2057.    * Parse an EXT-X-STREAM-INF media tag into a Stream object.
  2058.    *
  2059.    * @param {!Array.<!shaka.hls.Tag>} tags
  2060.    * @param {!Array.<string>} allCodecs
  2061.    * @param {string} type
  2062.    * @param {?string} language
  2063.    * @param {?string} name
  2064.    * @param {?number} channelsCount
  2065.    * @param {?string} characteristics
  2066.    * @param {?number} sampleRate
  2067.    * @param {boolean} spatialAudio
  2068.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2069.    * @private
  2070.    */
  2071.   createStreamInfoFromVariantTags_(tags, allCodecs, type, language, name,
  2072.       channelsCount, characteristics, sampleRate, spatialAudio) {
  2073.     const streamId = this.globalId_++;
  2074.     const verbatimMediaPlaylistUris = [];
  2075.     for (const tag of tags) {
  2076.       goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
  2077.           'Should only be called on variant tags!');
  2078.       const uri = tag.getRequiredAttrValue('URI');
  2079.       const pathwayId = tag.getAttributeValue('PATHWAY-ID');
  2080.       if (this.contentSteeringManager_ && pathwayId) {
  2081.         this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
  2082.       }
  2083.       verbatimMediaPlaylistUris.push(uri);
  2084.     }
  2086.     const key = verbatimMediaPlaylistUris.sort().join(',');
  2087.     if (this.uriToStreamInfosMap_.has(key)) {
  2088.       return this.uriToStreamInfosMap_.get(key);
  2089.     }
  2091.     const closedCaptions = this.getClosedCaptions_(tags[0], type);
  2092.     const codecs = shaka.util.ManifestParserUtils.guessCodecs(type, allCodecs);
  2093.     const streamInfo = this.createStreamInfo_(
  2094.         streamId, verbatimMediaPlaylistUris, codecs, type, language,
  2095.         /* primary= */ false, name, channelsCount, closedCaptions,
  2096.         characteristics, /* forced= */ false, sampleRate,
  2097.         /* spatialAudio= */ false);
  2099.     this.uriToStreamInfosMap_.set(key, streamInfo);
  2100.     return streamInfo;
  2101.   }
  2104.   /**
  2105.    * @param {number} streamId
  2106.    * @param {!Array.<string>} verbatimMediaPlaylistUris
  2107.    * @param {string} codecs
  2108.    * @param {string} type
  2109.    * @param {?string} languageValue
  2110.    * @param {boolean} primary
  2111.    * @param {?string} name
  2112.    * @param {?number} channelsCount
  2113.    * @param {Map.<string, string>} closedCaptions
  2114.    * @param {?string} characteristics
  2115.    * @param {boolean} forced
  2116.    * @param {?number} sampleRate
  2117.    * @param {boolean} spatialAudio
  2118.    * @return {!shaka.hls.HlsParser.StreamInfo}
  2119.    * @private
  2120.    */
  2121.   createStreamInfo_(streamId, verbatimMediaPlaylistUris, codecs, type,
  2122.       languageValue, primary, name, channelsCount, closedCaptions,
  2123.       characteristics, forced, sampleRate, spatialAudio) {
  2124.     // TODO: Refactor, too many parameters
  2126.     // This stream is lazy-loaded inside the createSegmentIndex function.
  2127.     // So we start out with a stream object that does not contain the actual
  2128.     // segment index, then download when createSegmentIndex is called.
  2129.     const stream = this.makeStreamObject_(streamId, codecs, type,
  2130.         languageValue, primary, name, channelsCount, closedCaptions,
  2131.         characteristics, forced, sampleRate, spatialAudio);
  2133.     const redirectUris = [];
  2134.     const getUris = () => {
  2135.       if (this.contentSteeringManager_ &&
  2136.           verbatimMediaPlaylistUris.length > 1) {
  2137.         return this.contentSteeringManager_.getLocations(streamId);
  2138.       }
  2139.       return redirectUris.concat(shaka.hls.Utils.constructUris(
  2140.           [this.masterPlaylistUri_], verbatimMediaPlaylistUris,
  2141.           this.globalVariables_));
  2142.     };
  2143.     const streamInfo = {
  2144.       stream,
  2145.       type,
  2146.       redirectUris,
  2147.       getUris,
  2148.       // These values are filled out or updated after lazy-loading:
  2149.       minTimestamp: 0,
  2150.       maxTimestamp: 0,
  2151.       mediaSequenceToStartTime: new Map(),
  2152.       canSkipSegments: false,
  2153.       canBlockReload: false,
  2154.       hasEndList: false,
  2155.       firstSequenceNumber: -1,
  2156.       nextMediaSequence: -1,
  2157.       nextPart: -1,
  2158.       loadedOnce: false,
  2159.     };
  2161.     /** @param {!AbortSignal} abortSignal */
  2162.     const downloadSegmentIndex = async (abortSignal) => {
  2163.       const uris = streamInfo.getUris();
  2164.       // Download the actual manifest.
  2165.       const response = await this.requestManifest_(
  2166.           streamInfo.getUris(), /* isPlaylist= */ true);
  2167.       if (abortSignal.aborted) {
  2168.         return;
  2169.       }
  2171.       // Record the final URI after redirects.
  2172.       const responseUri = response.uri;
  2173.       if (responseUri != response.originalUri && !uris.includes(responseUri)) {
  2174.         redirectUris.push(responseUri);
  2175.       }
  2177.       // Record the redirected, final URI of this media playlist when we parse
  2178.       // it.
  2179.       /** @type {!shaka.hls.Playlist} */
  2180.       const playlist = this.manifestTextParser_.parsePlaylist(response.data);
  2182.       let mimeType = undefined;
  2184.       // If no codec info was provided in the manifest and codec guessing is
  2185.       // disabled we try to get necessary info from the media data.
  2186.       if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
  2187.         const basicInfo =
  2188.             await this.getMediaPlaylistBasicInfo_(playlist, getUris);
  2190.         goog.asserts.assert(
  2191.             type === basicInfo.type, 'Media types should match!');
  2193.         mimeType = basicInfo.mimeType;
  2194.         codecs = basicInfo.codecs;
  2195.       }
  2197.       const wasLive = this.isLive_();
  2198.       const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
  2199.           streamId, playlist, getUris, responseUri, codecs,
  2200.           type, languageValue, primary, name, channelsCount, closedCaptions,
  2201.           characteristics, forced, sampleRate, spatialAudio, mimeType);
  2202.       if (abortSignal.aborted) {
  2203.         return;
  2204.       }
  2206.       const realStream = realStreamInfo.stream;
  2208.       if (this.isLive_() && !wasLive) {
  2209.         // Now that we know that the presentation is live, convert the timeline
  2210.         // to live.
  2211.         this.changePresentationTimelineToLive_(playlist);
  2212.       }
  2214.       // Copy values from the real stream info to our initial one.
  2215.       streamInfo.minTimestamp = realStreamInfo.minTimestamp;
  2216.       streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
  2217.       streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
  2218.       streamInfo.canBlockReload = realStreamInfo.canBlockReload;
  2219.       streamInfo.hasEndList = realStreamInfo.hasEndList;
  2220.       streamInfo.mediaSequenceToStartTime =
  2221.           realStreamInfo.mediaSequenceToStartTime;
  2222.       streamInfo.nextMediaSequence = realStreamInfo.nextMediaSequence;
  2223.       streamInfo.nextPart = realStreamInfo.nextPart;
  2224.       streamInfo.loadedOnce = true;
  2225.       stream.segmentIndex = realStream.segmentIndex;
  2226.       stream.encrypted = realStream.encrypted;
  2227.       stream.drmInfos = realStream.drmInfos;
  2228.       stream.keyIds = realStream.keyIds;
  2229.       stream.mimeType = realStream.mimeType;
  2230.       stream.bandwidth = realStream.bandwidth;
  2231.       stream.codecs = realStream.codecs || stream.codecs;
  2233.       // Since we lazy-loaded this content, the player may need to create new
  2234.       // sessions for the DRM info in this stream.
  2235.       if (stream.drmInfos.length) {
  2236.         this.playerInterface_.newDrmInfo(stream);
  2237.       }
  2239.       const ContentType = shaka.util.ManifestParserUtils.ContentType;
  2240.       if (type == ContentType.VIDEO || type == ContentType.AUDIO) {
  2241.         for (const otherStreamInfo of this.uriToStreamInfosMap_.values()) {
  2242.           if (!otherStreamInfo.loadedOnce && otherStreamInfo.type == type) {
  2243.             // To aid manifest filtering, assume before loading that all video
  2244.             // renditions have the same MIME type.  (And likewise for audio.)
  2245.             otherStreamInfo.stream.mimeType = realStream.mimeType;
  2246.           }
  2247.         }
  2248.       }
  2250.       if (type == ContentType.TEXT) {
  2251.         const firstSegment = realStream.segmentIndex.get(0);
  2252.         if (firstSegment && firstSegment.initSegmentReference) {
  2253.           stream.mimeType = 'application/mp4';
  2254.         }
  2255.       }
  2257.       // Add finishing touches to the stream that can only be done once we have
  2258.       // more full context on the media as a whole.
  2259.       if (this.hasEnoughInfoToFinalizeStreams_()) {
  2260.         if (!this.streamsFinalized_) {
  2261.           // Mark this manifest as having been finalized, so we don't go through
  2262.           // this whole process of finishing touches a second time.
  2263.           this.streamsFinalized_ = true;
  2264.           // Finalize all of the currently-loaded streams.
  2265.           const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
  2266.           const activeStreamInfos =
  2267.               streamInfos.filter((s) => s.stream.segmentIndex);
  2268.           this.finalizeStreams_(activeStreamInfos);
  2269.           // With the addition of this new stream, we now have enough info to
  2270.           // figure out how long the streams should be. So process all streams
  2271.           // we have downloaded up until this point.
  2272.           this.determineDuration_();
  2273.           // Finally, start the update timer, if this asset has been determined
  2274.           // to be a livestream.
  2275.           const delay = this.getUpdatePlaylistDelay_();
  2276.           if (delay > 0) {
  2277.             this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
  2278.           }
  2279.         } else {
  2280.           // We don't need to go through the full process; just finalize this
  2281.           // single stream.
  2282.           this.finalizeStreams_([streamInfo]);
  2283.         }
  2284.       }
  2285.     };
  2287.     /** @type {Promise} */
  2288.     let creationPromise = null;
  2289.     /** @type {!AbortController} */
  2290.     let abortController = new AbortController();
  2291.     const safeCreateSegmentIndex = () => {
  2292.       // An operation is already in progress.  The second and subsequent
  2293.       // callers receive the same Promise as the first caller, and only one
  2294.       // download operation will occur.
  2295.       if (creationPromise) {
  2296.         return creationPromise;
  2297.       }
  2299.       // Create a new AbortController to be able to cancel this specific
  2300.       // download.
  2301.       abortController = new AbortController();
  2303.       // Create a Promise tied to the outcome of downloadSegmentIndex().  If
  2304.       // downloadSegmentIndex is rejected, creationPromise will also be
  2305.       // rejected.
  2306.       creationPromise = new Promise((resolve) => {
  2307.         resolve(downloadSegmentIndex(abortController.signal));
  2308.       });
  2309.       return creationPromise;
  2310.     };
  2312.     stream.createSegmentIndex = safeCreateSegmentIndex;
  2314.     stream.closeSegmentIndex = () => {
  2315.       // If we're mid-creation, cancel it.
  2316.       if (creationPromise && !stream.segmentIndex) {
  2317.         abortController.abort();
  2318.       }
  2319.       // If we have a segment index, release it.
  2320.       if (stream.segmentIndex) {
  2321.         stream.segmentIndex.release();
  2322.         stream.segmentIndex = null;
  2323.       }
  2324.       // Clear the creation Promise so that a new operation can begin.
  2325.       creationPromise = null;
  2326.     };
  2328.     return streamInfo;
  2329.   }
  2331.   /**
  2332.    * @return {number}
  2333.    * @private
  2334.    */
  2335.   getMinDuration_() {
  2336.     let minDuration = Infinity;
  2337.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  2338.       if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text') {
  2339.         // Since everything is already offset to 0 (either by sync or by being
  2340.         // VOD), only maxTimestamp is necessary to compute the duration.
  2341.         minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
  2342.       }
  2343.     }
  2344.     return minDuration;
  2345.   }
  2347.   /**
  2348.    * @return {number}
  2349.    * @private
  2350.    */
  2351.   getLiveDuration_() {
  2352.     let maxTimestamp = Infinity;
  2353.     let minTimestamp = Infinity;
  2354.     for (const streamInfo of this.uriToStreamInfosMap_.values()) {
  2355.       if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text') {
  2356.         maxTimestamp = Math.min(maxTimestamp, streamInfo.maxTimestamp);
  2357.         minTimestamp = Math.min(minTimestamp, streamInfo.minTimestamp);
  2358.       }
  2359.     }
  2360.     return maxTimestamp - minTimestamp;
  2361.   }
  2363.   /**
  2364.    * @param {!Array.<!shaka.extern.Stream>} streams
  2365.    * @private
  2366.    */
  2367.   notifySegmentsForStreams_(streams) {
  2368.     const references = [];
  2369.     for (const stream of streams) {
  2370.       if (!stream.segmentIndex) {
  2371.         // The stream was closed since the list of streams was built.
  2372.         continue;
  2373.       }
  2374.       stream.segmentIndex.forEachTopLevelReference((reference) => {
  2375.         references.push(reference);
  2376.       });
  2377.     }
  2378.     this.presentationTimeline_.notifySegments(references);
  2379.   }
  2381.   /**
  2382.    * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
  2383.    * @private
  2384.    */
  2385.   finalizeStreams_(streamInfos) {
  2386.     if (!this.isLive_()) {
  2387.       const minDuration = this.getMinDuration_();
  2388.       for (const streamInfo of streamInfos) {
  2389.         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
  2390.       }
  2391.     }
  2392.     this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
  2393.     if (this.config_.hls.ignoreManifestProgramDateTime) {
  2394.       this.syncStreamsWithSequenceNumber_(streamInfos);
  2395.     } else {
  2396.       this.syncStreamsWithProgramDateTime_(streamInfos);
  2397.     }
  2398.   }
  2400.   /**
  2401.    * There are some values on streams that can only be set once we know about
  2402.    * both the video and audio content, if present.
  2403.    * This checks if there is at least one video downloaded (if the media has
  2404.    * video), and that there is at least one audio downloaded (if the media has
  2405.    * audio).
  2406.    * @return {boolean}
  2407.    * @private
  2408.    */
  2409.   hasEnoughInfoToFinalizeStreams_() {
  2410.     if (!this.manifest_) {
  2411.       return false;
  2412.     }
  2413.     const videos = [];
  2414.     const audios = [];
  2415.     for (const variant of this.manifest_.variants) {
  2416.       if (variant.video) {
  2417.         videos.push(variant.video);
  2418.       }
  2419.       if (variant.audio) {
  2420.         audios.push(variant.audio);
  2421.       }
  2422.     }
  2423.     if (videos.length > 0 && !videos.some((stream) => stream.segmentIndex)) {
  2424.       return false;
  2425.     }
  2426.     if (audios.length > 0 && !audios.some((stream) => stream.segmentIndex)) {
  2427.       return false;
  2428.     }
  2429.     return true;
  2430.   }
  2432.   /**
  2433.    * @param {number} streamId
  2434.    * @param {!shaka.hls.Playlist} playlist
  2435.    * @param {function():!Array.<string>} getUris
  2436.    * @param {string} responseUri
  2437.    * @param {string} codecs
  2438.    * @param {string} type
  2439.    * @param {?string} languageValue
  2440.    * @param {boolean} primary
  2441.    * @param {?string} name
  2442.    * @param {?number} channelsCount
  2443.    * @param {Map.<string, string>} closedCaptions
  2444.    * @param {?string} characteristics
  2445.    * @param {boolean} forced
  2446.    * @param {?number} sampleRate
  2447.    * @param {boolean} spatialAudio
  2448.    * @param {(string|undefined)} mimeType
  2449.    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
  2450.    * @private
  2451.    */
  2452.   async convertParsedPlaylistIntoStreamInfo_(streamId, playlist,
  2453.       getUris, responseUri, codecs, type, languageValue, primary, name,
  2454.       channelsCount, closedCaptions, characteristics, forced, sampleRate,
  2455.       spatialAudio, mimeType = undefined) {
  2456.     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
  2457.       // EXT-X-MEDIA and EXT-X-IMAGE-STREAM-INF tags should point to media
  2458.       // playlists.
  2459.       throw new shaka.util.Error(
  2460.           shaka.util.Error.Severity.CRITICAL,
  2461.           shaka.util.Error.Category.MANIFEST,
  2462.           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
  2463.     }
  2465.     /** @type {!Array.<!shaka.hls.Tag>} */
  2466.     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
  2467.         'EXT-X-DEFINE');
  2469.     const mediaVariables =
  2470.         this.parseMediaVariables_(variablesTags, responseUri);
  2472.     goog.asserts.assert(playlist.segments != null,
  2473.         'Media playlist should have segments!');
  2475.     this.determinePresentationType_(playlist);
  2477.     if (this.isLive_()) {
  2478.       this.determineLastTargetDuration_(playlist);
  2479.     }
  2481.     if (!mimeType) {
  2482.       mimeType = await this.guessMimeType_(type, codecs, playlist,
  2483.           mediaVariables, getUris);
  2484.     }
  2486.     const {drmInfos, keyIds, encrypted, aesEncrypted} =
  2487.                         this.parseDrmInfo_(playlist, mimeType);
  2489.     if (encrypted && !drmInfos.length && !aesEncrypted) {
  2490.       throw new shaka.util.Error(
  2491.           shaka.util.Error.Severity.CRITICAL,
  2492.           shaka.util.Error.Category.MANIFEST,
  2493.           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
  2494.     }
  2496.     const stream = this.makeStreamObject_(streamId, codecs, type,
  2497.         languageValue, primary, name, channelsCount, closedCaptions,
  2498.         characteristics, forced, sampleRate, spatialAudio);
  2499.     stream.encrypted = encrypted;
  2500.     stream.drmInfos = drmInfos;
  2501.     stream.keyIds = keyIds;
  2502.     stream.mimeType = mimeType;
  2504.     const mediaSequenceToStartTime = this.isLive_() ?
  2505.         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
  2507.     const {segments, bandwidth} = this.createSegments_(
  2508.         playlist, stream, mediaSequenceToStartTime, mediaVariables, getUris);
  2509.     stream.bandwidth = bandwidth;
  2511.     // This new calculation is necessary for Low Latency streams.
  2512.     if (this.isLive_()) {
  2513.       this.determineLastTargetDuration_(playlist);
  2514.     }
  2516.     const firstStartTime = segments[0].startTime;
  2517.     const lastSegment = segments[segments.length - 1];
  2518.     const lastEndTime = lastSegment.endTime;
  2519.     /** @type {!shaka.media.SegmentIndex} */
  2520.     const segmentIndex = new shaka.media.SegmentIndex(segments);
  2521.     stream.segmentIndex = segmentIndex;
  2523.     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
  2524.         playlist.tags, 'EXT-X-SERVER-CONTROL');
  2525.     const canSkipSegments = serverControlTag ?
  2526.           serverControlTag.getAttribute('CAN-SKIP-UNTIL') != null : false;
  2527.     const canBlockReload = serverControlTag ?
  2528.           serverControlTag.getAttribute('CAN-BLOCK-RELOAD') != null : false;
  2530.     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  2531.         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  2533.     const {nextMediaSequence, nextPart} =
  2534.         this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
  2536.     return {
  2537.       stream,
  2538.       type,
  2539.       redirectUris: [],
  2540.       getUris,
  2541.       minTimestamp: firstStartTime,
  2542.       maxTimestamp: lastEndTime,
  2543.       canSkipSegments,
  2544.       canBlockReload,
  2545.       hasEndList: false,
  2546.       firstSequenceNumber: -1,
  2547.       nextMediaSequence,
  2548.       nextPart,
  2549.       mediaSequenceToStartTime,
  2550.       loadedOnce: false,
  2551.     };
  2552.   }
  2554.   /**
  2555.    * Get the next msn and part
  2556.    *
  2557.    * @param {number} mediaSequenceNumber
  2558.    * @param {!Array.<!shaka.media.SegmentReference>} segments
  2559.    * @return {{nextMediaSequence: number, nextPart:number}}}
  2560.    * @private
  2561.    */
  2562.   getNextMediaSequenceAndPart_(mediaSequenceNumber, segments) {
  2563.     const currentMediaSequence = mediaSequenceNumber + segments.length - 1;
  2564.     let nextMediaSequence = currentMediaSequence;
  2565.     let nextPart = -1;
  2566.     if (!segments.length) {
  2567.       nextMediaSequence++;
  2568.       return {
  2569.         nextMediaSequence,
  2570.         nextPart,
  2571.       };
  2572.     }
  2573.     const lastSegment = segments[segments.length - 1];
  2574.     const partialReferences = lastSegment.partialReferences;
  2575.     if (!lastSegment.partialReferences.length) {
  2576.       nextMediaSequence++;
  2577.       if (lastSegment.hasByterangeOptimization()) {
  2578.         nextPart = 0;
  2579.       }
  2580.       return {
  2581.         nextMediaSequence,
  2582.         nextPart,
  2583.       };
  2584.     }
  2585.     nextPart = partialReferences.length - 1;
  2586.     const lastPartialReference =
  2587.         partialReferences[partialReferences.length - 1];
  2588.     if (!lastPartialReference.isPreload()) {
  2589.       nextMediaSequence++;
  2590.       nextPart = 0;
  2591.     }
  2592.     return {
  2593.       nextMediaSequence,
  2594.       nextPart,
  2595.     };
  2596.   }
  2599.   /**
  2600.    * Creates a stream object with the given parameters.
  2601.    * The parameters that are passed into here are only the things that can be
  2602.    * known without downloading the media playlist; other values must be set
  2603.    * manually on the object after creation.
  2604.    * @param {number} id
  2605.    * @param {string} codecs
  2606.    * @param {string} type
  2607.    * @param {?string} languageValue
  2608.    * @param {boolean} primary
  2609.    * @param {?string} name
  2610.    * @param {?number} channelsCount
  2611.    * @param {Map.<string, string>} closedCaptions
  2612.    * @param {?string} characteristics
  2613.    * @param {boolean} forced
  2614.    * @param {?number} sampleRate
  2615.    * @param {boolean} spatialAudio
  2616.    * @return {!shaka.extern.Stream}
  2617.    * @private
  2618.    */
  2619.   makeStreamObject_(id, codecs, type, languageValue, primary, name,
  2620.       channelsCount, closedCaptions, characteristics, forced, sampleRate,
  2621.       spatialAudio) {
  2622.     // Fill out a "best-guess" mimeType, for now. It will be replaced once the
  2623.     // stream is lazy-loaded.
  2624.     const mimeType = this.guessMimeTypeBeforeLoading_(type, codecs) ||
  2625.         this.guessMimeTypeFallback_(type);
  2626.     const roles = [];
  2627.     if (characteristics) {
  2628.       for (const characteristic of characteristics.split(',')) {
  2629.         roles.push(characteristic);
  2630.       }
  2631.     }
  2633.     let kind = undefined;
  2634.     let accessibilityPurpose = null;
  2635.     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  2636.       if (roles.includes('public.accessibility.transcribes-spoken-dialog') &&
  2637.           roles.includes('public.accessibility.describes-music-and-sound')) {
  2638.         kind = shaka.util.ManifestParserUtils.TextStreamKind.CLOSED_CAPTION;
  2639.       } else {
  2640.         kind = shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE;
  2641.       }
  2642.     } else {
  2643.       if (roles.includes('public.accessibility.describes-video')) {
  2644.         accessibilityPurpose =
  2645.               shaka.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED;
  2646.       }
  2647.     }
  2649.     // If there are no roles, and we have defaulted to the subtitle "kind" for
  2650.     // this track, add the implied subtitle role.
  2651.     if (!roles.length &&
  2652.         kind === shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE) {
  2653.       roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
  2654.     }
  2656.     return {
  2657.       id: this.globalId_++,
  2658.       originalId: name,
  2659.       groupId: null,
  2660.       createSegmentIndex: () => Promise.resolve(),
  2661.       segmentIndex: null,
  2662.       mimeType,
  2663.       codecs,
  2664.       kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
  2665.           shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
  2666.       encrypted: false,
  2667.       drmInfos: [],
  2668.       keyIds: new Set(),
  2669.       language: this.getLanguage_(languageValue),
  2670.       originalLanguage: languageValue,
  2671.       label: name,  // For historical reasons, since before "originalId".
  2672.       type,
  2673.       primary,
  2674.       // TODO: trick mode
  2675.       trickModeVideo: null,
  2676.       emsgSchemeIdUris: null,
  2677.       frameRate: undefined,
  2678.       pixelAspectRatio: undefined,
  2679.       width: undefined,
  2680.       height: undefined,
  2681.       bandwidth: undefined,
  2682.       roles,
  2683.       forced,
  2684.       channelsCount,
  2685.       audioSamplingRate: sampleRate,
  2686.       spatialAudio,
  2687.       closedCaptions,
  2688.       hdr: undefined,
  2689.       videoLayout: undefined,
  2690.       tilesLayout: undefined,
  2691.       accessibilityPurpose: accessibilityPurpose,
  2692.       external: false,
  2693.       fastSwitching: false,
  2694.     };
  2695.   }
  2697.   /**
  2698.    * @param {!shaka.hls.Playlist} playlist
  2699.    * @param {string} mimeType
  2700.    * @return {{
  2701.    *   drmInfos: !Array.<shaka.extern.DrmInfo>,
  2702.    *   keyIds: !Set.<string>,
  2703.    *   encrypted: boolean,
  2704.    *   aesEncrypted: boolean
  2705.    * }}
  2706.    * @private
  2707.    */
  2708.   parseDrmInfo_(playlist, mimeType) {
  2709.     /** @type {!Array.<!shaka.hls.Tag>} */
  2710.     const drmTags = [];
  2711.     if (playlist.segments) {
  2712.       for (const segment of playlist.segments) {
  2713.         const segmentKeyTags = shaka.hls.Utils.filterTagsByName(segment.tags,
  2714.             'EXT-X-KEY');
  2715.         drmTags.push(...segmentKeyTags);
  2716.       }
  2717.     }
  2719.     let encrypted = false;
  2720.     let aesEncrypted = false;
  2722.     /** @type {!Array.<shaka.extern.DrmInfo>}*/
  2723.     const drmInfos = [];
  2724.     const keyIds = new Set();
  2726.     for (const drmTag of drmTags) {
  2727.       const method = drmTag.getRequiredAttrValue('METHOD');
  2728.       if (method != 'NONE') {
  2729.         encrypted = true;
  2731.         if (method == 'AES-128') {
  2732.           // These keys are handled separately.
  2733.           aesEncrypted = true;
  2734.         } else {
  2735.           // According to the HLS spec, KEYFORMAT is optional and implicitly
  2736.           // defaults to "identity".
  2737.           // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
  2738.           const keyFormat =
  2739.               drmTag.getAttributeValue('KEYFORMAT') || 'identity';
  2740.           const drmParser =
  2741.               shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
  2743.           const drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
  2744.           if (drmInfo) {
  2745.             if (drmInfo.keyIds) {
  2746.               for (const keyId of drmInfo.keyIds) {
  2747.                 keyIds.add(keyId);
  2748.               }
  2749.             }
  2750.             drmInfos.push(drmInfo);
  2751.           } else {
  2752.             shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
  2753.           }
  2754.         }
  2755.       }
  2756.     }
  2758.     return {drmInfos, keyIds, encrypted, aesEncrypted};
  2759.   }
  2761.   /**
  2762.    * @param {!shaka.hls.Tag} drmTag
  2763.    * @param {!shaka.hls.Playlist} playlist
  2764.    * @param {function():!Array.<string>} getUris
  2765.    * @param {?Map.<string, string>=} variables
  2766.    * @return {!shaka.extern.aes128Key}
  2767.    * @private
  2768.    */
  2769.   parseAES128DrmTag_(drmTag, playlist, getUris, variables) {
  2770.     // Check if the Web Crypto API is available.
  2771.     if (!window.crypto || !window.crypto.subtle) {
  2772.       shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
  2773.           'AES-128. (Web Crypto only exists in secure origins like https)');
  2774.       throw new shaka.util.Error(
  2775.           shaka.util.Error.Severity.CRITICAL,
  2776.           shaka.util.Error.Category.MANIFEST,
  2777.           shaka.util.Error.Code.NO_WEB_CRYPTO_API);
  2778.     }
  2780.     // HLS RFC 8216 Section 5.2:
  2781.     // An EXT-X-KEY tag with a KEYFORMAT of "identity" that does not have an IV
  2782.     // attribute indicates that the Media Sequence Number is to be used as the
  2783.     // IV when decrypting a Media Segment, by putting its big-endian binary
  2784.     // representation into a 16-octet (128-bit) buffer and padding (on the left)
  2785.     // with zeros.
  2786.     let firstMediaSequenceNumber = 0;
  2787.     let iv;
  2788.     const ivHex = drmTag.getAttributeValue('IV', '');
  2789.     if (!ivHex) {
  2790.       // Media Sequence Number will be used as IV.
  2791.       firstMediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  2792.           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  2793.     } else {
  2794.       // Exclude 0x at the start of string.
  2795.       iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
  2796.       if (iv.byteLength != 16) {
  2797.         throw new shaka.util.Error(
  2798.             shaka.util.Error.Severity.CRITICAL,
  2799.             shaka.util.Error.Category.MANIFEST,
  2800.             shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
  2801.       }
  2802.     }
  2804.     const keyInfo = {method: 'AES-128', iv, firstMediaSequenceNumber};
  2806.     // Don't download the key object until the segment is parsed, to avoid a
  2807.     // startup delay for long manifests with lots of keys.
  2808.     keyInfo.fetchKey = async () => {
  2809.       const keyUri = shaka.hls.Utils.constructSegmentUris(
  2810.           getUris(), drmTag.getRequiredAttrValue('URI'), variables);
  2812.       const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
  2813.       const request = shaka.net.NetworkingEngine.makeRequest(
  2814.           [keyUri], this.config_.retryParameters);
  2815.       const keyResponse = await this.makeNetworkRequest_(request, requestType);
  2817.       // keyResponse.status is undefined when URI is "data:text/plain;base64,"
  2818.       if (!keyResponse.data || keyResponse.data.byteLength != 16) {
  2819.         throw new shaka.util.Error(
  2820.             shaka.util.Error.Severity.CRITICAL,
  2821.             shaka.util.Error.Category.MANIFEST,
  2822.             shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
  2823.       }
  2825.       const algorithm = {
  2826.         name: 'AES-CBC',
  2827.       };
  2828.       keyInfo.cryptoKey = await window.crypto.subtle.importKey(
  2829.           'raw', keyResponse.data, algorithm, true, ['decrypt']);
  2830.       keyInfo.fetchKey = undefined; // No longer needed.
  2831.     };
  2833.     return keyInfo;
  2834.   }
  2837.   /**
  2838.    * @param {!shaka.hls.Playlist} playlist
  2839.    * @private
  2840.    */
  2841.   determinePresentationType_(playlist) {
  2842.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  2843.     const presentationTypeTag =
  2844.         shaka.hls.Utils.getFirstTagWithName(playlist.tags,
  2845.             'EXT-X-PLAYLIST-TYPE');
  2846.     const endListTag =
  2847.         shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-ENDLIST');
  2849.     const isVod = (presentationTypeTag && presentationTypeTag.value == 'VOD') ||
  2850.         endListTag;
  2851.     const isEvent = presentationTypeTag &&
  2852.         presentationTypeTag.value == 'EVENT' && !isVod;
  2853.     const isLive = !isVod && !isEvent;
  2855.     if (isVod) {
  2856.       this.setPresentationType_(PresentationType.VOD);
  2857.     } else {
  2858.       // If it's not VOD, it must be presentation type LIVE or an ongoing EVENT.
  2859.       if (isLive) {
  2860.         this.setPresentationType_(PresentationType.LIVE);
  2861.       } else {
  2862.         this.setPresentationType_(PresentationType.EVENT);
  2863.       }
  2864.     }
  2865.   }
  2868.   /**
  2869.    * @param {!shaka.hls.Playlist} playlist
  2870.    * @private
  2871.    */
  2872.   determineLastTargetDuration_(playlist) {
  2873.     let lastTargetDuration = Infinity;
  2874.     const segments = playlist.segments;
  2875.     if (segments.length) {
  2876.       let segmentIndex = segments.length - 1;
  2877.       while (segmentIndex >= 0) {
  2878.         const segment = segments[segmentIndex];
  2879.         const extinfTag =
  2880.             shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXTINF');
  2881.         if (extinfTag) {
  2882.           // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  2883.           // We're interested in the duration part.
  2884.           const extinfValues = extinfTag.value.split(',');
  2885.           lastTargetDuration = Number(extinfValues[0]);
  2886.           break;
  2887.         }
  2888.         segmentIndex--;
  2889.       }
  2890.     }
  2892.     const targetDurationTag = this.getRequiredTag_(playlist.tags,
  2893.         'EXT-X-TARGETDURATION');
  2894.     const targetDuration = Number(targetDurationTag.value);
  2895.     const partialTargetDurationTag =
  2896.       shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-PART-INF');
  2897.     if (partialTargetDurationTag) {
  2898.       this.partialTargetDuration_ = Number(
  2899.           partialTargetDurationTag.getRequiredAttrValue('PART-TARGET'));
  2900.     }
  2901.     // Get the server-recommended min distance from the live edge.
  2902.     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
  2903.         playlist.tags, 'EXT-X-SERVER-CONTROL');
  2904.     // According to the HLS spec, updates should not happen more often than
  2905.     // once in targetDuration.  It also requires us to only update the active
  2906.     // variant.  We might implement that later, but for now every variant
  2907.     // will be updated.  To get the update period, choose the smallest
  2908.     // targetDuration value across all playlists.
  2909.     // 1. Update the shortest one to use as update period and segment
  2910.     // availability time (for LIVE).
  2911.     if (this.lowLatencyMode_ && this.partialTargetDuration_) {
  2912.       // For low latency streaming, use the partial segment target duration.
  2913.       if (this.lowLatencyByterangeOptimization_) {
  2914.         // We always have at least 1 partial segment part, and most servers
  2915.         // allow you to make a request with _HLS_msn=X&_HLS_part=0 with a
  2916.         // distance of 4 partial segments.  With this we ensure that we
  2917.         // obtain the minimum latency in this type of case.
  2918.         if (this.partialTargetDuration_ * 5 <= lastTargetDuration) {
  2919.           this.lastTargetDuration_ = Math.min(
  2920.               this.partialTargetDuration_, this.lastTargetDuration_);
  2921.         } else {
  2922.           this.lastTargetDuration_ = Math.min(
  2923.               lastTargetDuration, this.lastTargetDuration_);
  2924.         }
  2925.       } else {
  2926.         this.lastTargetDuration_ = Math.min(
  2927.             this.partialTargetDuration_, this.lastTargetDuration_);
  2928.       }
  2929.       // Use 'PART-HOLD-BACK' as the presentation delay for low latency mode.
  2930.       this.lowLatencyPresentationDelay_ = serverControlTag ? Number(
  2931.           serverControlTag.getRequiredAttrValue('PART-HOLD-BACK')) : 0;
  2932.     } else {
  2933.       this.lastTargetDuration_ = Math.min(
  2934.           lastTargetDuration, this.lastTargetDuration_);
  2935.       // Use 'HOLD-BACK' as the presentation delay for default if defined.
  2936.       const holdBack = serverControlTag ?
  2937.           serverControlTag.getAttribute('HOLD-BACK') : null;
  2938.       this.presentationDelay_ = holdBack ? Number(holdBack.value) : 0;
  2939.     }
  2940.     // 2. Update the longest target duration if need be to use as a
  2941.     // presentation delay later.
  2942.     this.maxTargetDuration_ = Math.max(
  2943.         targetDuration, this.maxTargetDuration_);
  2944.   }
  2947.   /**
  2948.    * @param {!shaka.hls.Playlist} playlist
  2949.    * @private
  2950.    */
  2951.   changePresentationTimelineToLive_(playlist) {
  2952.     // The live edge will be calculated from segments, so we don't need to
  2953.     // set a presentation start time.  We will assert later that this is
  2954.     // working as expected.
  2956.     // The HLS spec (RFC 8216) states in 6.3.3:
  2957.     //
  2958.     // "The client SHALL choose which Media Segment to play first ... the
  2959.     // client SHOULD NOT choose a segment that starts less than three target
  2960.     // durations from the end of the Playlist file.  Doing so can trigger
  2961.     // playback stalls."
  2962.     //
  2963.     // We accomplish this in our DASH-y model by setting a presentation
  2964.     // delay of configured value, or 3 segments duration if not configured.
  2965.     // This will be the "live edge" of the presentation.
  2966.     let presentationDelay;
  2967.     if (this.config_.defaultPresentationDelay) {
  2968.       presentationDelay = this.config_.defaultPresentationDelay;
  2969.     } else if (this.lowLatencyPresentationDelay_) {
  2970.       presentationDelay = this.lowLatencyPresentationDelay_;
  2971.     } else if (this.presentationDelay_) {
  2972.       presentationDelay = this.presentationDelay_;
  2973.     } else {
  2974.       const playlistSegments = playlist.segments.length;
  2975.       let delaySegments = this.config_.hls.liveSegmentsDelay;
  2976.       if (delaySegments > (playlistSegments - 2)) {
  2977.         delaySegments = Math.max(1, playlistSegments - 2);
  2978.       }
  2979.       presentationDelay = this.maxTargetDuration_ * delaySegments;
  2980.     }
  2982.     this.presentationTimeline_.setPresentationStartTime(0);
  2983.     this.presentationTimeline_.setDelay(presentationDelay);
  2984.     this.presentationTimeline_.setStatic(false);
  2985.   }
  2987.   /**
  2988.    * Get the InitSegmentReference for a segment if it has a EXT-X-MAP tag.
  2989.    * @param {!shaka.hls.Playlist} playlist
  2990.    * @param {!Array.<!shaka.hls.Tag>} tags Segment tags
  2991.    * @param {function():!Array.<string>} getUris
  2992.    * @param {?Map.<string, string>=} variables
  2993.    * @return {shaka.media.InitSegmentReference}
  2994.    * @private
  2995.    */
  2996.   getInitSegmentReference_(playlist, tags, getUris, variables) {
  2997.     /** @type {?shaka.hls.Tag} */
  2998.     const mapTag = shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-MAP');
  3000.     if (!mapTag) {
  3001.       return null;
  3002.     }
  3003.     // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
  3004.     const verbatimInitSegmentUri = mapTag.getRequiredAttrValue('URI');
  3005.     const absoluteInitSegmentUris = shaka.hls.Utils.constructSegmentUris(
  3006.         getUris(), verbatimInitSegmentUri, variables);
  3008.     const mapTagKey = [
  3009.       absoluteInitSegmentUris.toString(),
  3010.       mapTag.getAttributeValue('BYTERANGE', ''),
  3011.     ].join('-');
  3012.     if (!this.mapTagToInitSegmentRefMap_.has(mapTagKey)) {
  3013.       /** @type {shaka.extern.aes128Key|undefined} */
  3014.       let aes128Key = undefined;
  3015.       let byteRangeTag = null;
  3016.       for (const tag of tags) {
  3017.         if (tag.name == 'EXT-X-KEY') {
  3018.           if (tag.getRequiredAttrValue('METHOD') == 'AES-128' &&
  3019.               tag.id < mapTag.id) {
  3020.             aes128Key =
  3021.                 this.parseAES128DrmTag_(tag, playlist, getUris, variables);
  3022.           }
  3023.         } else if (tag.name == 'EXT-X-BYTERANGE' && tag.id < mapTag.id) {
  3024.           byteRangeTag = tag;
  3025.         }
  3026.       }
  3027.       const initSegmentRef = this.createInitSegmentReference_(
  3028.           absoluteInitSegmentUris, mapTag, byteRangeTag, aes128Key);
  3029.       this.mapTagToInitSegmentRefMap_.set(mapTagKey, initSegmentRef);
  3030.     }
  3031.     return this.mapTagToInitSegmentRefMap_.get(mapTagKey);
  3032.   }
  3034.   /**
  3035.    * Create an InitSegmentReference object for the EXT-X-MAP tag in the media
  3036.    * playlist.
  3037.    * @param {!Array.<string>} absoluteInitSegmentUris
  3038.    * @param {!shaka.hls.Tag} mapTag EXT-X-MAP
  3039.    * @param {shaka.hls.Tag=} byteRangeTag EXT-X-BYTERANGE
  3040.    * @param {shaka.extern.aes128Key=} aes128Key
  3041.    * @return {!shaka.media.InitSegmentReference}
  3042.    * @private
  3043.    */
  3044.   createInitSegmentReference_(absoluteInitSegmentUris, mapTag, byteRangeTag,
  3045.       aes128Key) {
  3046.     let startByte = 0;
  3047.     let endByte = null;
  3048.     let byterange = mapTag.getAttributeValue('BYTERANGE');
  3049.     if (!byterange && byteRangeTag) {
  3050.       byterange = byteRangeTag.value;
  3051.     }
  3052.     // If a BYTERANGE attribute is not specified, the segment consists
  3053.     // of the entire resource.
  3054.     if (byterange) {
  3055.       const blocks = byterange.split('@');
  3056.       const byteLength = Number(blocks[0]);
  3057.       startByte = Number(blocks[1]);
  3058.       endByte = startByte + byteLength - 1;
  3060.       if (aes128Key) {
  3061.         // MAP segment encrypted with method 'AES-128', when served with
  3062.         // HTTP Range, has the unencrypted size specified in the range.
  3063.         // See: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
  3064.         const length = (endByte + 1) - startByte;
  3065.         if (length % 16) {
  3066.           endByte += (16 - (length % 16));
  3067.         }
  3068.       }
  3069.     }
  3071.     const initSegmentRef = new shaka.media.InitSegmentReference(
  3072.         () => absoluteInitSegmentUris,
  3073.         startByte,
  3074.         endByte,
  3075.         /* mediaQuality= */ null,
  3076.         /* timescale= */ null,
  3077.         /* segmentData= */ null,
  3078.         aes128Key);
  3079.     return initSegmentRef;
  3080.   }
  3082.   /**
  3083.    * Parses one shaka.hls.Segment object into a shaka.media.SegmentReference.
  3084.    *
  3085.    * @param {shaka.media.InitSegmentReference} initSegmentReference
  3086.    * @param {shaka.media.SegmentReference} previousReference
  3087.    * @param {!shaka.hls.Segment} hlsSegment
  3088.    * @param {number} startTime
  3089.    * @param {!Map.<string, string>} variables
  3090.    * @param {!shaka.hls.Playlist} playlist
  3091.    * @param {shaka.extern.Stream} stream
  3092.    * @param {function():!Array.<string>} getUris
  3093.    * @param {shaka.extern.aes128Key=} aes128Key
  3094.    * @return {shaka.media.SegmentReference}
  3095.    * @private
  3096.    */
  3097.   createSegmentReference_(
  3098.       initSegmentReference, previousReference, hlsSegment, startTime,
  3099.       variables, playlist, stream, getUris, aes128Key) {
  3100.     const tags = hlsSegment.tags;
  3101.     const extinfTag =
  3102.         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
  3104.     let endTime = 0;
  3105.     let startByte = 0;
  3106.     let endByte = null;
  3108.     if (hlsSegment.partialSegments.length && !this.lowLatencyMode_) {
  3109.       shaka.log.alwaysWarn('Low-latency HLS live stream detected, but ' +
  3110.                 'low-latency streaming mode is not enabled in Shaka ' +
  3111.                 'Player. Set streaming.lowLatencyMode configuration to ' +
  3112.                 'true, and see https://bit.ly/3clctcj for details.');
  3113.     }
  3115.     let syncTime = null;
  3116.     if (!this.config_.hls.ignoreManifestProgramDateTime) {
  3117.       const dateTimeTag =
  3118.           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
  3119.       if (dateTimeTag && dateTimeTag.value) {
  3120.         syncTime = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
  3121.         goog.asserts.assert(syncTime != null,
  3122.             'EXT-X-PROGRAM-DATE-TIME format not valid');
  3123.       }
  3124.     }
  3126.     let status = shaka.media.SegmentReference.Status.AVAILABLE;
  3127.     if (shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-GAP')) {
  3128.       status = shaka.media.SegmentReference.Status.MISSING;
  3129.     }
  3131.     if (!extinfTag) {
  3132.       if (hlsSegment.partialSegments.length == 0) {
  3133.         // EXTINF tag must be available if the segment has no partial segments.
  3134.         throw new shaka.util.Error(
  3135.             shaka.util.Error.Severity.CRITICAL,
  3136.             shaka.util.Error.Category.MANIFEST,
  3137.             shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, 'EXTINF');
  3138.       } else if (!this.lowLatencyMode_) {
  3139.         // Without EXTINF and without low-latency mode, partial segments get
  3140.         // ignored.
  3141.         return null;
  3142.       }
  3143.     }
  3145.     // Create SegmentReferences for the partial segments.
  3146.     let partialSegmentRefs = [];
  3148.     // Optimization for LL-HLS with byterange
  3149.     // More info in https://tinyurl.com/hls-open-byte-range
  3150.     let segmentWithByteRangeOptimization = false;
  3151.     let getUrisOptimization = null;
  3152.     let somePartialSegmentWithGap = false;
  3153.     let isPreloadSegment = false;
  3155.     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
  3156.       const byterangeOptimizationSupport = (stream.mimeType == 'video/mp4' ||
  3157.           stream.mimeType == 'audio/mp4') && window.ReadableStream &&
  3158.           this.config_.hls.allowLowLatencyByteRangeOptimization;
  3160.       let partialSyncTime = syncTime;
  3161.       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
  3162.         const item = hlsSegment.partialSegments[i];
  3163.         const pPreviousReference = i == 0 ?
  3164.           previousReference : partialSegmentRefs[partialSegmentRefs.length - 1];
  3165.         const pStartTime = (i == 0) ? startTime : pPreviousReference.endTime;
  3167.         // If DURATION is missing from this partial segment, use the target
  3168.         // partial duration from the top of the playlist, which is a required
  3169.         // attribute for content with partial segments.
  3170.         const pDuration = Number(item.getAttributeValue('DURATION')) ||
  3171.             this.partialTargetDuration_;
  3173.         // If for some reason we have neither an explicit duration, nor a target
  3174.         // partial duration, we should SKIP this partial segment to avoid
  3175.         // duplicating content in the presentation timeline.
  3176.         if (!pDuration) {
  3177.           continue;
  3178.         }
  3180.         const pEndTime = pStartTime + pDuration;
  3182.         let pStartByte = 0;
  3183.         let pEndByte = null;
  3184.         if (item.name == 'EXT-X-PRELOAD-HINT') {
  3185.           // A preload hinted partial segment may have byterange start info.
  3186.           const pByterangeStart = item.getAttributeValue('BYTERANGE-START');
  3187.           pStartByte = pByterangeStart ? Number(pByterangeStart) : 0;
  3188.           // A preload hinted partial segment may have byterange length info.
  3189.           const pByterangeLength = item.getAttributeValue('BYTERANGE-LENGTH');
  3190.           if (pByterangeLength) {
  3191.             pEndByte = pStartByte + Number(pByterangeLength) - 1;
  3192.           } else if (pStartByte) {
  3193.             // If we have a non-zero start byte, but no end byte, follow the
  3194.             // recommendation of https://tinyurl.com/hls-open-byte-range and
  3195.             // set the end byte explicitly to a large integer.
  3196.             pEndByte = Number.MAX_SAFE_INTEGER;
  3197.           }
  3198.         } else {
  3199.           const pByterange = item.getAttributeValue('BYTERANGE');
  3200.           [pStartByte, pEndByte] =
  3201.             this.parseByteRange_(pPreviousReference, pByterange);
  3202.         }
  3203.         const pUri = item.getAttributeValue('URI');
  3204.         if (!pUri) {
  3205.           continue;
  3206.         }
  3208.         let partialStatus = shaka.media.SegmentReference.Status.AVAILABLE;
  3209.         if (item.getAttributeValue('GAP') == 'YES') {
  3210.           partialStatus = shaka.media.SegmentReference.Status.MISSING;
  3211.           somePartialSegmentWithGap = true;
  3212.         }
  3214.         let uris = null;
  3215.         const getPartialUris = () => {
  3216.           if (uris == null) {
  3217.             goog.asserts.assert(pUri, 'Partial uri should be defined!');
  3218.             uris = shaka.hls.Utils.constructSegmentUris(
  3219.                 getUris(), pUri, variables);
  3220.           }
  3221.           return uris;
  3222.         };
  3224.         if (byterangeOptimizationSupport &&
  3225.             pStartByte >= 0 && pEndByte != null) {
  3226.           getUrisOptimization = getPartialUris;
  3227.           segmentWithByteRangeOptimization = true;
  3228.         }
  3230.         const partial = new shaka.media.SegmentReference(
  3231.             pStartTime,
  3232.             pEndTime,
  3233.             getPartialUris,
  3234.             pStartByte,
  3235.             pEndByte,
  3236.             initSegmentReference,
  3237.             /* timestampOffset= */ 0,
  3238.             /* appendWindowStart= */ 0,
  3239.             /* appendWindowEnd= */ Infinity,
  3240.             /* partialReferences= */ [],
  3241.             /* tilesLayout= */ '',
  3242.             /* tileDuration= */ null,
  3243.             partialSyncTime,
  3244.             partialStatus,
  3245.             aes128Key);
  3246.         if (item.name == 'EXT-X-PRELOAD-HINT') {
  3247.           partial.markAsPreload();
  3248.           isPreloadSegment = true;
  3249.         }
  3250.         // The spec doesn't say that we can assume INDEPENDENT=YES for the
  3251.         // first partial segment. It does call the flag "optional", though, and
  3252.         // that cases where there are no such flags on any partial segments, it
  3253.         // is sensible to assume the first one is independent.
  3254.         if (item.getAttributeValue('INDEPENDENT') != 'YES' && i > 0) {
  3255.           partial.markAsNonIndependent();
  3256.         }
  3257.         partialSegmentRefs.push(partial);
  3259.         if (partialSyncTime) {
  3260.           partialSyncTime += pDuration;
  3261.         }
  3262.       } // for-loop of hlsSegment.partialSegments
  3263.     }
  3265.     // If the segment has EXTINF tag, set the segment's end time, start byte
  3266.     // and end byte based on the duration and byterange information.
  3267.     // Otherwise, calculate the end time, start / end byte based on its partial
  3268.     // segments.
  3269.     // Note that the sum of partial segments durations may be slightly different
  3270.     // from the parent segment's duration. In this case, use the duration from
  3271.     // the parent segment tag.
  3272.     if (extinfTag) {
  3273.       // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
  3274.       // We're interested in the duration part.
  3275.       const extinfValues = extinfTag.value.split(',');
  3276.       const duration = Number(extinfValues[0]);
  3277.       // Skip segments without duration
  3278.       if (duration == 0) {
  3279.         return null;
  3280.       }
  3281.       endTime = startTime + duration;
  3282.     } else if (partialSegmentRefs.length) {
  3283.       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
  3284.     } else {
  3285.       // Skip segments without duration and without partialsegments
  3286.       return null;
  3287.     }
  3289.     if (segmentWithByteRangeOptimization) {
  3290.       // We cannot optimize segments with gaps, or with a start byte that is
  3291.       // not 0.
  3292.       if (somePartialSegmentWithGap || partialSegmentRefs[0].startByte != 0) {
  3293.         segmentWithByteRangeOptimization = false;
  3294.         getUrisOptimization = null;
  3295.       } else {
  3296.         partialSegmentRefs = [];
  3297.       }
  3298.     }
  3300.     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
  3301.     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
  3302.     // and has partial segments, set the start byte and end byte base on the
  3303.     // partial segments.
  3304.     const byterangeTag =
  3305.          shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-BYTERANGE');
  3306.     if (byterangeTag) {
  3307.       [startByte, endByte] =
  3308.           this.parseByteRange_(previousReference, byterangeTag.value);
  3309.     } else if (partialSegmentRefs.length) {
  3310.       startByte = partialSegmentRefs[0].startByte;
  3311.       endByte = partialSegmentRefs[partialSegmentRefs.length - 1].endByte;
  3312.     }
  3314.     let tilesLayout = '';
  3315.     let tileDuration = null;
  3316.     if (stream.type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
  3317.       // By default in HLS the tilesLayout is 1x1
  3318.       tilesLayout = '1x1';
  3319.       const tilesTag =
  3320.           shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-TILES');
  3321.       if (tilesTag) {
  3322.         tilesLayout = tilesTag.getRequiredAttrValue('LAYOUT');
  3323.         const duration = tilesTag.getAttributeValue('DURATION');
  3324.         if (duration) {
  3325.           tileDuration = Number(duration);
  3326.         }
  3327.       }
  3328.     }
  3330.     let uris = null;
  3331.     const getSegmentUris = () => {
  3332.       if (getUrisOptimization) {
  3333.         return getUrisOptimization();
  3334.       }
  3335.       if (uris == null) {
  3336.         uris = shaka.hls.Utils.constructSegmentUris(getUris(),
  3337.             hlsSegment.verbatimSegmentUri, variables);
  3338.       }
  3339.       return uris || [];
  3340.     };
  3342.     const allPartialSegments = partialSegmentRefs.length > 0 &&
  3343.         !!hlsSegment.verbatimSegmentUri;
  3345.     const reference = new shaka.media.SegmentReference(
  3346.         startTime,
  3347.         endTime,
  3348.         getSegmentUris,
  3349.         startByte,
  3350.         endByte,
  3351.         initSegmentReference,
  3352.         /* timestampOffset= */ 0,
  3353.         /* appendWindowStart= */ 0,
  3354.         /* appendWindowEnd= */ Infinity,
  3355.         partialSegmentRefs,
  3356.         tilesLayout,
  3357.         tileDuration,
  3358.         syncTime,
  3359.         status,
  3360.         aes128Key,
  3361.         allPartialSegments,
  3362.     );
  3364.     if (segmentWithByteRangeOptimization) {
  3365.       this.lowLatencyByterangeOptimization_ = true;
  3366.       reference.markAsByterangeOptimization();
  3368.       if (isPreloadSegment) {
  3369.         reference.markAsPreload();
  3370.       }
  3371.     }
  3373.     return reference;
  3374.   }
  3377.   /**
  3378.    * Parse the startByte and endByte.
  3379.    * @param {shaka.media.SegmentReference} previousReference
  3380.    * @param {?string} byterange
  3381.    * @return {!Array.<number>} An array with the start byte and end byte.
  3382.    * @private
  3383.    */
  3384.   parseByteRange_(previousReference, byterange) {
  3385.     let startByte = 0;
  3386.     let endByte = null;
  3387.     // If BYTERANGE is not specified, the segment consists of the entire
  3388.     // resource.
  3389.     if (byterange) {
  3390.       const blocks = byterange.split('@');
  3391.       const byteLength = Number(blocks[0]);
  3392.       if (blocks[1]) {
  3393.         startByte = Number(blocks[1]);
  3394.       } else {
  3395.         goog.asserts.assert(previousReference,
  3396.             'Cannot refer back to previous HLS segment!');
  3397.         startByte = previousReference.endByte + 1;
  3398.       }
  3399.       endByte = startByte + byteLength - 1;
  3400.     }
  3401.     return [startByte, endByte];
  3402.   }
  3404.   /**
  3405.    * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences and
  3406.    * get the bandwidth necessary for this segments If it's defined in the
  3407.    * playlist.
  3408.    *
  3409.    * @param {!shaka.hls.Playlist} playlist
  3410.    * @param {shaka.extern.Stream} stream
  3411.    * @param {!Map.<number, number>} mediaSequenceToStartTime
  3412.    * @param {!Map.<string, string>} variables
  3413.    * @param {function():!Array.<string>} getUris
  3414.    * @return {{segments: !Array.<!shaka.media.SegmentReference>,
  3415.    *          bandwidth: (number|undefined)}}
  3416.    * @private
  3417.    */
  3418.   createSegments_(playlist, stream, mediaSequenceToStartTime, variables,
  3419.       getUris) {
  3420.     /** @type {Array.<!shaka.hls.Segment>} */
  3421.     const hlsSegments = playlist.segments;
  3422.     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
  3424.     /** @type {shaka.media.InitSegmentReference} */
  3425.     let initSegmentRef;
  3427.     /** @type {shaka.extern.aes128Key|undefined} */
  3428.     let aes128Key = undefined;
  3430.     let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3431.         playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', 0);
  3432.     const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3433.         playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
  3434.     const skipTag = shaka.hls.Utils.getFirstTagWithName(
  3435.         playlist.tags, 'EXT-X-SKIP');
  3436.     const skippedSegments =
  3437.         skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
  3438.     let position = mediaSequenceNumber + skippedSegments;
  3439.     let firstStartTime = 0;
  3441.     // For live stream, use the cached value in the mediaSequenceToStartTime
  3442.     // map if available.
  3443.     if (this.isLive_() && mediaSequenceToStartTime.has(position)) {
  3444.       firstStartTime = mediaSequenceToStartTime.get(position);
  3445.     }
  3447.     /** @type {!Array.<!shaka.media.SegmentReference>} */
  3448.     const references = [];
  3450.     let previousReference = null;
  3452.     /** @type {!Array.<{bitrate: number, duration: number}>} */
  3453.     const bitrates = [];
  3455.     for (let i = 0; i < hlsSegments.length; i++) {
  3456.       const item = hlsSegments[i];
  3457.       const startTime =
  3458.           (i == 0) ? firstStartTime : previousReference.endTime;
  3459.       position = mediaSequenceNumber + skippedSegments + i;
  3461.       const discontinuityTag = shaka.hls.Utils.getFirstTagWithName(
  3462.           item.tags, 'EXT-X-DISCONTINUITY');
  3463.       if (discontinuityTag) {
  3464.         discontinuitySequence++;
  3465.       }
  3467.       // Apply new AES-128 tags as you see them, keeping a running total.
  3468.       for (const drmTag of item.tags) {
  3469.         if (drmTag.name == 'EXT-X-KEY') {
  3470.           if (drmTag.getRequiredAttrValue('METHOD') == 'AES-128') {
  3471.             aes128Key =
  3472.                 this.parseAES128DrmTag_(drmTag, playlist, getUris, variables);
  3473.           } else {
  3474.             aes128Key = undefined;
  3475.           }
  3476.         }
  3477.       }
  3479.       mediaSequenceToStartTime.set(position, startTime);
  3481.       initSegmentRef = this.getInitSegmentReference_(playlist,
  3482.           item.tags, getUris, variables);
  3484.       // If the stream is low latency and the user has not configured the
  3485.       // lowLatencyMode, but if it has been configured to activate the
  3486.       // lowLatencyMode if a stream of this type is detected, we automatically
  3487.       // activate the lowLatencyMode.
  3488.       if (!this.lowLatencyMode_) {
  3489.         const autoLowLatencyMode = this.playerInterface_.isAutoLowLatencyMode();
  3490.         if (autoLowLatencyMode) {
  3491.           this.playerInterface_.enableLowLatencyMode();
  3492.           this.lowLatencyMode_ = this.playerInterface_.isLowLatencyMode();
  3493.         }
  3494.       }
  3496.       const reference = this.createSegmentReference_(
  3497.           initSegmentRef,
  3498.           previousReference,
  3499.           item,
  3500.           startTime,
  3501.           variables,
  3502.           playlist,
  3503.           stream,
  3504.           getUris,
  3505.           aes128Key);
  3507.       if (reference) {
  3508.         const bitrate = shaka.hls.Utils.getFirstTagWithNameAsNumber(
  3509.             item.tags, 'EXT-X-BITRATE');
  3510.         if (bitrate) {
  3511.           bitrates.push({
  3512.             bitrate,
  3513.             duration: reference.endTime - reference.startTime,
  3514.           });
  3515.         } else if (bitrates.length) {
  3516.           // It applies to every segment between it and the next EXT-X-BITRATE,
  3517.           // so we use the latest bitrate value
  3518.           const prevBitrate = bitrates.pop();
  3519.           prevBitrate.duration += reference.endTime - reference.startTime;
  3520.           bitrates.push(prevBitrate);
  3521.         }
  3523.         previousReference = reference;
  3524.         reference.discontinuitySequence = discontinuitySequence;
  3526.         if (this.config_.hls.ignoreManifestProgramDateTime &&
  3527.             this.minSequenceNumber_ != null &&
  3528.             position < this.minSequenceNumber_) {
  3529.           // This segment is ignored as part of our fallback synchronization
  3530.           // method.
  3531.         } else {
  3532.           references.push(reference);
  3533.         }
  3534.       }
  3535.     }
  3537.     let bandwidth = undefined;
  3538.     if (bitrates.length) {
  3539.       const duration = bitrates.reduce((sum, value) => {
  3540.         return sum + value.duration;
  3541.       }, 0);
  3542.       bandwidth = Math.round(bitrates.reduce((sum, value) => {
  3543.         return sum + value.bitrate * value.duration;
  3544.       }, 0) / duration * 1000);
  3545.     }
  3547.     // If some segments have sync times, but not all, extrapolate the sync
  3548.     // times of the ones with none.
  3549.     const someSyncTime = references.some((ref) => ref.syncTime != null);
  3550.     if (someSyncTime) {
  3551.       for (let i = 0; i < references.length; i++) {
  3552.         const reference = references[i];
  3553.         if (reference.syncTime != null) {
  3554.           // No need to extrapolate.
  3555.           continue;
  3556.         }
  3557.         // Find the nearest segment with syncTime, in either direction.
  3558.         // This looks forward and backward simultaneously, keeping track of what
  3559.         // to offset the syncTime it finds by as it goes.
  3560.         let forwardAdd = 0;
  3561.         let forwardI = i;
  3562.         /**
  3563.          * Look forwards one reference at a time, summing all durations as we
  3564.          * go, until we find a reference with a syncTime to use as a basis.
  3565.          * This DOES count the original reference, but DOESN'T count the first
  3566.          * reference with a syncTime (as we approach it from behind).
  3567.          * @return {?number}
  3568.          */
  3569.         const lookForward = () => {
  3570.           const other = references[forwardI];
  3571.           if (other) {
  3572.             if (other.syncTime != null) {
  3573.               return other.syncTime + forwardAdd;
  3574.             }
  3575.             forwardAdd -= other.endTime - other.startTime;
  3576.             forwardI += 1;
  3577.           }
  3578.           return null;
  3579.         };
  3580.         let backwardAdd = 0;
  3581.         let backwardI = i;
  3582.         /**
  3583.          * Look backwards one reference at a time, summing all durations as we
  3584.          * go, until we find a reference with a syncTime to use as a basis.
  3585.          * This DOESN'T count the original reference, but DOES count the first
  3586.          * reference with a syncTime (as we approach it from ahead).
  3587.          * @return {?number}
  3588.          */
  3589.         const lookBackward = () => {
  3590.           const other = references[backwardI];
  3591.           if (other) {
  3592.             if (other != reference) {
  3593.               backwardAdd += other.endTime - other.startTime;
  3594.             }
  3595.             if (other.syncTime != null) {
  3596.               return other.syncTime + backwardAdd;
  3597.             }
  3598.             backwardI -= 1;
  3599.           }
  3600.           return null;
  3601.         };
  3602.         while (reference.syncTime == null) {
  3603.           reference.syncTime = lookBackward();
  3604.           if (reference.syncTime == null) {
  3605.             reference.syncTime = lookForward();
  3606.           }
  3607.         }
  3608.       }
  3609.     }
  3611.     // Split the sync times properly among partial segments.
  3612.     if (someSyncTime) {
  3613.       for (const reference of references) {
  3614.         let syncTime = reference.syncTime;
  3615.         for (const partial of reference.partialReferences) {
  3616.           partial.syncTime = syncTime;
  3617.           syncTime += partial.endTime - partial.startTime;
  3618.         }
  3619.       }
  3620.     }
  3622.     // lowestSyncTime is a value from a previous playlist update.  Use it to
  3623.     // set reference start times.  If this is the first playlist parse, we will
  3624.     // skip this step, and wait until we have sync time across stream types.
  3625.     const lowestSyncTime = this.lowestSyncTime_;
  3626.     if (someSyncTime && lowestSyncTime != Infinity) {
  3627.       for (const reference of references) {
  3628.         reference.syncAgainst(lowestSyncTime);
  3629.       }
  3630.     }
  3632.     return {
  3633.       segments: references,
  3634.       bandwidth,
  3635.     };
  3636.   }
  3638.   /**
  3639.    * Attempts to guess stream's mime type based on content type and URI.
  3640.    *
  3641.    * @param {string} contentType
  3642.    * @param {string} codecs
  3643.    * @return {?string}
  3644.    * @private
  3645.    */
  3646.   guessMimeTypeBeforeLoading_(contentType, codecs) {
  3647.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  3648.       if (codecs == 'vtt' || codecs == 'wvtt') {
  3649.         // If codecs is 'vtt', it's WebVTT.
  3650.         return 'text/vtt';
  3651.       } else if (codecs && codecs !== '') {
  3652.         // Otherwise, assume MP4-embedded text, since text-based formats tend
  3653.         // not to have a codecs string at all.
  3654.         return 'application/mp4';
  3655.       }
  3656.     }
  3658.     if (contentType == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
  3659.       if (!codecs || codecs == 'jpeg') {
  3660.         return 'image/jpeg';
  3661.       }
  3662.     }
  3664.     if (contentType == shaka.util.ManifestParserUtils.ContentType.AUDIO) {
  3665.       // See: https://bugs.chromium.org/p/chromium/issues/detail?id=489520
  3666.       if (codecs == 'mp4a.40.34') {
  3667.         return 'audio/mpeg';
  3668.       }
  3669.     }
  3671.     if (codecs == 'mjpg') {
  3672.       return 'application/mp4';
  3673.     }
  3675.     // Not enough information to guess from the content type and codecs.
  3676.     return null;
  3677.   }
  3679.   /**
  3680.    * Get a fallback mime type for the content. Used if all the better methods
  3681.    * for determining the mime type have failed.
  3682.    *
  3683.    * @param {string} contentType
  3684.    * @return {string}
  3685.    * @private
  3686.    */
  3687.   guessMimeTypeFallback_(contentType) {
  3688.     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
  3689.       // If there was no codecs string and no content-type, assume HLS text
  3690.       // streams are WebVTT.
  3691.       return 'text/vtt';
  3692.     }
  3693.     // If the HLS content is lacking in both MIME type metadata and
  3694.     // segment file extensions, we fall back to assuming it's MP4.
  3695.     const map = shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
  3696.     return map['mp4'];
  3697.   }
  3699.   /**
  3700.    * Attempts to guess stream's mime type based on content type, URI, and
  3701.    * contents of the playlist.
  3702.    *
  3703.    * @param {string} contentType
  3704.    * @param {string} codecs
  3705.    * @param {!shaka.hls.Playlist} playlist
  3706.    * @param {!Map.<string, string>} variables
  3707.    * @param {function():!Array.<string>} getUris
  3708.    * @return {!Promise.<string>}
  3709.    * @private
  3710.    */
  3711.   async guessMimeType_(contentType, codecs, playlist, variables, getUris) {
  3712.     const HlsParser = shaka.hls.HlsParser;
  3713.     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
  3715.     // If you wait long enough, requesting the first segment can fail
  3716.     // because it has fallen off the left edge of DVR, so to be safer,
  3717.     // let's request the middle segment.
  3718.     goog.asserts.assert(playlist.segments.length,
  3719.         'Playlist should have segments!');
  3720.     const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
  3722.     const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
  3723.         getUris(),
  3724.         playlist.segments[middleSegmentIdx].verbatimSegmentUri,
  3725.         variables);
  3727.     const parsedUri = new goog.Uri(middleSegmentUris[0]);
  3728.     const extension = parsedUri.getPath().split('.').pop();
  3729.     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
  3731.     let mimeType = map[extension];
  3732.     if (mimeType) {
  3733.       return mimeType;
  3734.     }
  3736.     mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
  3737.     if (mimeType) {
  3738.       return mimeType;
  3739.     }
  3741.     // The extension map didn't work, so guess based on codecs.
  3742.     mimeType = this.guessMimeTypeBeforeLoading_(contentType, codecs);
  3743.     if (mimeType) {
  3744.       return mimeType;
  3745.     }
  3747.     // If unable to guess mime type, request a segment and try getting it
  3748.     // from the response.
  3749.     const headRequest = shaka.net.NetworkingEngine.makeRequest(
  3750.         middleSegmentUris, this.config_.retryParameters);
  3751.     headRequest.method = 'HEAD';
  3752.     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
  3753.     const response = await this.makeNetworkRequest_(
  3754.         headRequest, requestType, {type});
  3756.     const contentMimeType = response.headers['content-type'];
  3757.     if (contentMimeType) {
  3758.       // Split the MIME type in case the server sent additional parameters.
  3759.       return contentMimeType.split(';')[0];
  3760.     }
  3762.     return this.guessMimeTypeFallback_(contentType);
  3763.   }
  3765.   /**
  3766.    * Returns a tag with a given name.
  3767.    * Throws an error if tag was not found.
  3768.    *
  3769.    * @param {!Array.<shaka.hls.Tag>} tags
  3770.    * @param {string} tagName
  3771.    * @return {!shaka.hls.Tag}
  3772.    * @private
  3773.    */
  3774.   getRequiredTag_(tags, tagName) {
  3775.     const tag = shaka.hls.Utils.getFirstTagWithName(tags, tagName);
  3776.     if (!tag) {
  3777.       throw new shaka.util.Error(
  3778.           shaka.util.Error.Severity.CRITICAL,
  3779.           shaka.util.Error.Category.MANIFEST,
  3780.           shaka.util.Error.Code.HLS_REQUIRED_TAG_MISSING, tagName);
  3781.     }
  3783.     return tag;
  3784.   }
  3786.   /**
  3787.    * @param {shaka.extern.Stream} stream
  3788.    * @param {?string} width
  3789.    * @param {?string} height
  3790.    * @param {?string} frameRate
  3791.    * @param {?string} videoRange
  3792.    * @param {?string} videoLayout
  3793.    * @private
  3794.    */
  3795.   addVideoAttributes_(stream, width, height, frameRate, videoRange,
  3796.       videoLayout) {
  3797.     if (stream) {
  3798.       stream.width = Number(width) || undefined;
  3799.       stream.height = Number(height) || undefined;
  3800.       stream.frameRate = Number(frameRate) || undefined;
  3801.       stream.hdr = videoRange || undefined;
  3802.       stream.videoLayout = videoLayout || undefined;
  3803.     }
  3804.   }
  3806.   /**
  3807.    * Makes a network request for the manifest and returns a Promise
  3808.    * with the resulting data.
  3809.    *
  3810.    * @param {!Array.<string>} uris
  3811.    * @param {boolean=} isPlaylist
  3812.    * @return {!Promise.<!shaka.extern.Response>}
  3813.    * @private
  3814.    */
  3815.   requestManifest_(uris, isPlaylist) {
  3816.     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
  3818.     const request = shaka.net.NetworkingEngine.makeRequest(
  3819.         uris, this.config_.retryParameters);
  3821.     const type = isPlaylist ?
  3822.         shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_PLAYLIST :
  3823.         shaka.net.NetworkingEngine.AdvancedRequestType.MASTER_PLAYLIST;
  3824.     return this.makeNetworkRequest_(request, requestType, {type});
  3825.   }
  3827.   /**
  3828.    * Called when the update timer ticks. Because parsing a manifest is async,
  3829.    * this method is async. To work with this, this method will schedule the next
  3830.    * update when it finished instead of using a repeating-start.
  3831.    *
  3832.    * @return {!Promise}
  3833.    * @private
  3834.    */
  3835.   async onUpdate_() {
  3836.     shaka.log.info('Updating manifest...');
  3838.     goog.asserts.assert(
  3839.         this.getUpdatePlaylistDelay_() > 0,
  3840.         'We should only call |onUpdate_| when we are suppose to be updating.');
  3842.     // Detect a call to stop()
  3843.     if (!this.playerInterface_) {
  3844.       return;
  3845.     }
  3847.     try {
  3848.       const startTime = Date.now();
  3849.       await this.update();
  3851.       // Keep track of how long the longest manifest update took.
  3852.       const endTime = Date.now();
  3854.       // This may have converted to VOD, in which case we stop updating.
  3855.       if (this.isLive_()) {
  3856.         const updateDuration = (endTime - startTime) / 1000.0;
  3857.         this.averageUpdateDuration_.sample(1, updateDuration);
  3858.         const delay = this.getUpdatePlaylistDelay_();
  3859.         const finalDelay = Math.max(0,
  3860.             delay - this.averageUpdateDuration_.getEstimate());
  3861.         this.updatePlaylistTimer_.tickAfter(/* seconds= */ finalDelay);
  3862.       }
  3863.     } catch (error) {
  3864.       // Detect a call to stop() during this.update()
  3865.       if (!this.playerInterface_) {
  3866.         return;
  3867.       }
  3869.       goog.asserts.assert(error instanceof shaka.util.Error,
  3870.           'Should only receive a Shaka error');
  3872.       if (this.config_.raiseFatalErrorOnManifestUpdateRequestFailure) {
  3873.         this.playerInterface_.onError(error);
  3874.         return;
  3875.       }
  3877.       // We will retry updating, so override the severity of the error.
  3878.       error.severity = shaka.util.Error.Severity.RECOVERABLE;
  3879.       this.playerInterface_.onError(error);
  3881.       // Try again very soon.
  3882.       this.updatePlaylistTimer_.tickAfter(/* seconds= */ 0.1);
  3883.     }
  3885.     // Detect a call to stop()
  3886.     if (!this.playerInterface_) {
  3887.       return;
  3888.     }
  3890.     this.playerInterface_.onManifestUpdated();
  3891.   }
  3894.   /**
  3895.    * @return {boolean}
  3896.    * @private
  3897.    */
  3898.   isLive_() {
  3899.     const PresentationType = shaka.hls.HlsParser.PresentationType_;
  3900.     return this.presentationType_ != PresentationType.VOD;
  3901.   }
  3904.   /**
  3905.    * @return {number}
  3906.    * @private
  3907.    */
  3908.   getUpdatePlaylistDelay_() {
  3909.     // The HLS spec (RFC 8216) states in 6.3.4:
  3910.     // "the client MUST wait for at least the target duration before
  3911.     // attempting to reload the Playlist file again".
  3912.     // For LL-HLS, the server must add a new partial segment to the Playlist
  3913.     // every part target duration.
  3914.     return this.lastTargetDuration_;
  3915.   }
  3918.   /**
  3919.    * @param {shaka.hls.HlsParser.PresentationType_} type
  3920.    * @private
  3921.    */
  3922.   setPresentationType_(type) {
  3923.     this.presentationType_ = type;
  3925.     if (this.presentationTimeline_) {
  3926.       this.presentationTimeline_.setStatic(!this.isLive_());
  3927.     }
  3929.     // If this manifest is not for live content, then we have no reason to
  3930.     // update it.
  3931.     if (!this.isLive_()) {
  3932.       this.updatePlaylistTimer_.stop();
  3933.     }
  3934.   }
  3937.   /**
  3938.    * Create a networking request. This will manage the request using the
  3939.    * parser's operation manager. If the parser has already been stopped, the
  3940.    * request will not be made.
  3941.    *
  3942.    * @param {shaka.extern.Request} request
  3943.    * @param {shaka.net.NetworkingEngine.RequestType} type
  3944.    * @param {shaka.extern.RequestContext=} context
  3945.    * @return {!Promise.<shaka.extern.Response>}
  3946.    * @private
  3947.    */
  3948.   makeNetworkRequest_(request, type, context) {
  3949.     if (!this.operationManager_) {
  3950.       throw new shaka.util.Error(
  3951.           shaka.util.Error.Severity.CRITICAL,
  3952.           shaka.util.Error.Category.PLAYER,
  3953.           shaka.util.Error.Code.OPERATION_ABORTED);
  3954.     }
  3956.     const op = this.playerInterface_.networkingEngine.request(
  3957.         type, request, context);
  3958.     this.operationManager_.manage(op);
  3960.     return op.promise;
  3961.   }
  3963.   /**
  3964.    * @param {!shaka.hls.Tag} drmTag
  3965.    * @param {string} mimeType
  3966.    * @return {?shaka.extern.DrmInfo}
  3967.    * @private
  3968.    */
  3969.   static fairplayDrmParser_(drmTag, mimeType) {
  3970.     if (mimeType == 'video/mp2t') {
  3971.       throw new shaka.util.Error(
  3972.           shaka.util.Error.Severity.CRITICAL,
  3973.           shaka.util.Error.Category.MANIFEST,
  3974.           shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
  3975.     }
  3977.     if (shaka.util.Platform.isMediaKeysPolyfilled()) {
  3978.       throw new shaka.util.Error(
  3979.           shaka.util.Error.Severity.CRITICAL,
  3980.           shaka.util.Error.Category.MANIFEST,
  3981.           shaka.util.Error.Code
  3982.               .HLS_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
  3983.     }
  3985.     /*
  3986.      * Even if we're not able to construct initData through the HLS tag, adding
  3987.      * a DRMInfo will allow DRM Engine to request a media key system access
  3988.      * with the correct keySystem and initDataType
  3989.      */
  3990.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  3991.         'com.apple.fps', [
  3992.           {initDataType: 'sinf', initData: new Uint8Array(0), keyId: null},
  3993.         ]);
  3995.     return drmInfo;
  3996.   }
  3998.   /**
  3999.    * @param {!shaka.hls.Tag} drmTag
  4000.    * @return {?shaka.extern.DrmInfo}
  4001.    * @private
  4002.    */
  4003.   static widevineDrmParser_(drmTag) {
  4004.     const method = drmTag.getRequiredAttrValue('METHOD');
  4005.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4006.     if (!VALID_METHODS.includes(method)) {
  4007.       shaka.log.error('Widevine in HLS is only supported with [',
  4008.           VALID_METHODS.join(', '), '], not', method);
  4009.       return null;
  4010.     }
  4012.     const uri = drmTag.getRequiredAttrValue('URI');
  4013.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri);
  4015.     // The data encoded in the URI is a PSSH box to be used as init data.
  4016.     const pssh = shaka.util.BufferUtils.toUint8(parsedData.data);
  4017.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4018.         'com.widevine.alpha', [
  4019.           {initDataType: 'cenc', initData: pssh},
  4020.         ]);
  4022.     const keyId = drmTag.getAttributeValue('KEYID');
  4023.     if (keyId) {
  4024.       const keyIdLowerCase = keyId.toLowerCase();
  4025.       // This value should begin with '0x':
  4026.       goog.asserts.assert(
  4027.           keyIdLowerCase.startsWith('0x'), 'Incorrect KEYID format!');
  4028.       // But the output should not contain the '0x':
  4029.       drmInfo.keyIds = new Set([keyIdLowerCase.substr(2)]);
  4030.     }
  4031.     return drmInfo;
  4032.   }
  4034.   /**
  4035.    * See: https://docs.microsoft.com/en-us/playready/packaging/mp4-based-formats-supported-by-playready-clients?tabs=case4
  4036.    *
  4037.    * @param {!shaka.hls.Tag} drmTag
  4038.    * @return {?shaka.extern.DrmInfo}
  4039.    * @private
  4040.    */
  4041.   static playreadyDrmParser_(drmTag) {
  4042.     const method = drmTag.getRequiredAttrValue('METHOD');
  4043.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4044.     if (!VALID_METHODS.includes(method)) {
  4045.       shaka.log.error('PlayReady in HLS is only supported with [',
  4046.           VALID_METHODS.join(', '), '], not', method);
  4047.       return null;
  4048.     }
  4050.     const uri = drmTag.getRequiredAttrValue('URI');
  4051.     const parsedData = shaka.net.DataUriPlugin.parseRaw(uri);
  4053.     // The data encoded in the URI is a PlayReady Pro Object, so we need
  4054.     // convert it to pssh.
  4055.     const data = shaka.util.BufferUtils.toUint8(parsedData.data);
  4056.     const systemId = new Uint8Array([
  4057.       0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
  4058.       0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
  4059.     ]);
  4060.     const keyIds = new Set();
  4061.     const psshVersion = 0;
  4062.     const pssh =
  4063.         shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  4064.     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
  4065.         'com.microsoft.playready', [
  4066.           {initDataType: 'cenc', initData: pssh},
  4067.         ]);
  4069.     return drmInfo;
  4070.   }
  4072.   /**
  4073.    * See: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-5.1
  4074.    *
  4075.    * @param {!shaka.hls.Tag} drmTag
  4076.    * @return {?shaka.extern.DrmInfo}
  4077.    * @private
  4078.    */
  4079.   static identityDrmParser_(drmTag) {
  4080.     const method = drmTag.getRequiredAttrValue('METHOD');
  4081.     const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
  4082.     if (!VALID_METHODS.includes(method)) {
  4083.       shaka.log.error('Identity (ClearKey) in HLS is only supported with [',
  4084.           VALID_METHODS.join(', '), '], not', method);
  4085.       return null;
  4086.     }
  4088.     // NOTE: The ClearKey CDM requires a key-id to key mapping.  HLS doesn't
  4089.     // provide a key ID anywhere.  So although we could use the 'URI' attribute
  4090.     // to fetch the actual 16-byte key, without a key ID, we can't provide this
  4091.     // automatically to the ClearKey CDM.  Instead, the application will have
  4092.     // to use player.configure('drm.clearKeys', { ... }) to provide the key IDs
  4093.     // and keys or player.configure('drm.servers.org\.w3\.clearkey', ...) to
  4094.     // provide a ClearKey license server URI.
  4095.     return shaka.util.ManifestParserUtils.createDrmInfo(
  4096.         'org.w3.clearkey', /* initDatas= */ null);
  4097.   }
  4098. };
  4101. /**
  4102.  * @typedef {{
  4103.  *   stream: !shaka.extern.Stream,
  4104.  *   type: string,
  4105.  *   redirectUris: !Array.<string>,
  4106.  *   getUris: function():!Array.<string>,
  4107.  *   minTimestamp: number,
  4108.  *   maxTimestamp: number,
  4109.  *   mediaSequenceToStartTime: !Map.<number, number>,
  4110.  *   canSkipSegments: boolean,
  4111.  *   canBlockReload: boolean,
  4112.  *   hasEndList: boolean,
  4113.  *   firstSequenceNumber: number,
  4114.  *   nextMediaSequence: number,
  4115.  *   nextPart: number,
  4116.  *   loadedOnce: boolean
  4117.  * }}
  4118.  *
  4119.  * @description
  4120.  * Contains a stream and information about it.
  4121.  *
  4122.  * @property {!shaka.extern.Stream} stream
  4123.  *   The Stream itself.
  4124.  * @property {string} type
  4125.  *   The type value. Could be 'video', 'audio', 'text', or 'image'.
  4126.  * @property {!Array.<string>} redirectUris
  4127.  *   The redirect URIs.
  4128.  * @property {function():!Array.<string>} getUris
  4129.  *   The verbatim media playlist URIs, as it appeared in the master playlist.
  4130.  * @property {number} minTimestamp
  4131.  *   The minimum timestamp found in the stream.
  4132.  * @property {number} maxTimestamp
  4133.  *   The maximum timestamp found in the stream.
  4134.  * @property {!Map.<number, number>} mediaSequenceToStartTime
  4135.  *   A map of media sequence numbers to media start times.
  4136.  *   Only used for VOD content.
  4137.  * @property {boolean} canSkipSegments
  4138.  *   True if the server supports delta playlist updates, and we can send a
  4139.  *   request for a playlist that can skip older media segments.
  4140.  * @property {boolean} canBlockReload
  4141.  *   True if the server supports blocking playlist reload, and we can send a
  4142.  *   request for a playlist that can block reload until some segments are
  4143.  *   present.
  4144.  * @property {boolean} hasEndList
  4145.  *   True if the stream has an EXT-X-ENDLIST tag.
  4146.  * @property {number} firstSequenceNumber
  4147.  *   The sequence number of the first reference. Only calculated if needed.
  4148.  * @property {number} nextMediaSequence
  4149.  *   The next media sequence.
  4150.  * @property {number} nextPart
  4151.  *   The next part.
  4152.  * @property {boolean} loadedOnce
  4153.  *   True if the stream has been loaded at least once.
  4154.  */
  4155. shaka.hls.HlsParser.StreamInfo;
  4158. /**
  4159.  * @typedef {{
  4160.  *   audio: !Array.<shaka.hls.HlsParser.StreamInfo>,
  4161.  *   video: !Array.<shaka.hls.HlsParser.StreamInfo>
  4162.  * }}
  4163.  *
  4164.  * @description Audio and video stream infos.
  4165.  * @property {!Array.<shaka.hls.HlsParser.StreamInfo>} audio
  4166.  * @property {!Array.<shaka.hls.HlsParser.StreamInfo>} video
  4167.  */
  4168. shaka.hls.HlsParser.StreamInfos;
  4171. /**
  4172.  * @const {!Object.<string, string>}
  4173.  * @private
  4174.  */
  4175. shaka.hls.HlsParser.RAW_FORMATS_TO_MIME_TYPES_ = {
  4176.   'aac': 'audio/aac',
  4177.   'ac3': 'audio/ac3',
  4178.   'ec3': 'audio/ec3',
  4179.   'mp3': 'audio/mpeg',
  4180. };
  4183. /**
  4184.  * @const {!Object.<string, string>}
  4185.  * @private
  4186.  */
  4187. shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
  4188.   'mp4': 'audio/mp4',
  4189.   'mp4a': 'audio/mp4',
  4190.   'm4s': 'audio/mp4',
  4191.   'm4i': 'audio/mp4',
  4192.   'm4a': 'audio/mp4',
  4193.   'm4f': 'audio/mp4',
  4194.   'cmfa': 'audio/mp4',
  4195.   // MPEG2-TS also uses video/ for audio: https://bit.ly/TsMse
  4196.   'ts': 'video/mp2t',
  4197.   'tsa': 'video/mp2t',
  4198. };
  4201. /**
  4202.  * @const {!Object.<string, string>}
  4203.  * @private
  4204.  */
  4205. shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_ = {
  4206.   'mp4': 'video/mp4',
  4207.   'mp4v': 'video/mp4',
  4208.   'm4s': 'video/mp4',
  4209.   'm4i': 'video/mp4',
  4210.   'm4v': 'video/mp4',
  4211.   'm4f': 'video/mp4',
  4212.   'cmfv': 'video/mp4',
  4213.   'ts': 'video/mp2t',
  4214.   'tsv': 'video/mp2t',
  4215. };
  4218. /**
  4219.  * @const {!Object.<string, string>}
  4220.  * @private
  4221.  */
  4222. shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_ = {
  4223.   'mp4': 'application/mp4',
  4224.   'm4s': 'application/mp4',
  4225.   'm4i': 'application/mp4',
  4226.   'm4f': 'application/mp4',
  4227.   'cmft': 'application/mp4',
  4228.   'vtt': 'text/vtt',
  4229.   'webvtt': 'text/vtt',
  4230.   'ttml': 'application/ttml+xml',
  4231. };
  4234. /**
  4235.  * @const {!Object.<string, string>}
  4236.  * @private
  4237.  */
  4238. shaka.hls.HlsParser.IMAGE_EXTENSIONS_TO_MIME_TYPES_ = {
  4239.   'jpg': 'image/jpeg',
  4240.   'png': 'image/png',
  4241.   'svg': 'image/svg+xml',
  4242.   'webp': 'image/webp',
  4243.   'avif': 'image/avif',
  4244. };
  4247. /**
  4248.  * @const {!Object.<string, !Object.<string, string>>}
  4249.  * @private
  4250.  */
  4251. shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_ = {
  4252.   'audio': shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_,
  4253.   'video': shaka.hls.HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_,
  4254.   'text': shaka.hls.HlsParser.TEXT_EXTENSIONS_TO_MIME_TYPES_,
  4255.   'image': shaka.hls.HlsParser.IMAGE_EXTENSIONS_TO_MIME_TYPES_,
  4256. };
  4259. /**
  4260.  * @typedef {function(!shaka.hls.Tag, string):?shaka.extern.DrmInfo}
  4261.  * @private
  4262.  */
  4263. shaka.hls.HlsParser.DrmParser_;
  4266. /**
  4267.  * @const {!Object.<string, shaka.hls.HlsParser.DrmParser_>}
  4268.  * @private
  4269.  */
  4270. shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
  4271.   'com.apple.streamingkeydelivery':
  4272.       shaka.hls.HlsParser.fairplayDrmParser_,
  4273.   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
  4274.       shaka.hls.HlsParser.widevineDrmParser_,
  4275.   'com.microsoft.playready':
  4276.       shaka.hls.HlsParser.playreadyDrmParser_,
  4277.   'identity':
  4278.       shaka.hls.HlsParser.identityDrmParser_,
  4279. };
  4282. /**
  4283.  * @enum {string}
  4284.  * @private
  4285.  */
  4286. shaka.hls.HlsParser.PresentationType_ = {
  4287.   VOD: 'VOD',
  4288.   EVENT: 'EVENT',
  4289.   LIVE: 'LIVE',
  4290. };
  4292. shaka.media.ManifestParser.registerParserByMime(
  4293.     'application/x-mpegurl', () => new shaka.hls.HlsParser());
  4294. shaka.media.ManifestParser.registerParserByMime(
  4295.     'application/vnd.apple.mpegurl', () => new shaka.hls.HlsParser());