shaka-player 4.2.5 → 4.3.1

package/lib/hls/hls_parser.js

@@ -71,6 +71,24 @@ shaka.hls.HlsParser = class {
      */
     this.groupIdToStreamInfosMap_ = new Map();
 
+    /**
+     * For media playlist lazy-loading to work in livestreams, we have to assume
+     * that each stream of a type (video, audio, etc) has the same mappings of
+     * sequence number to start time.
+     * This map stores those relationships.
+     * Only used during livestreams; we do not assume that VOD content is
+     * aligned in that way.
+     * @private {!Map.<string, !Map.<number, number>>}
+     */
+    this.mediaSequenceToStartTimeByType_ = new Map();
+
+    // Set initial maps.
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    this.mediaSequenceToStartTimeByType_.set(ContentType.VIDEO, new Map());
+    this.mediaSequenceToStartTimeByType_.set(ContentType.AUDIO, new Map());
+    this.mediaSequenceToStartTimeByType_.set(ContentType.TEXT, new Map());
+    this.mediaSequenceToStartTimeByType_.set(ContentType.IMAGE, new Map());
+
     /**
      * The values are strings of the form "<VIDEO URI> - <AUDIO URI>",
      * where the URIs are the verbatim media playlist URIs as they appeared in
@@ -122,19 +140,29 @@ shaka.hls.HlsParser = class {
     this.updatePlaylistDelay_ = 0;
 
     /**
-     * If true, we have already calculated offsets to synchronize streams.
-     * Offsets are computed in syncStreams*_().
-     * @private {boolean}
+     * The minimum sequence number for generated segments, when ignoring
+     * EXT-X-PROGRAM-DATE-TIME.
+     *
+     * @private {number}
      */
-    this.streamsSynced_ = false;
+    this.minSequenceNumber_ = -1;
 
     /**
-     * The minimum sequence number for generated segments, when ignoring
-     * EXT-X-PROGRAM-DATE-TIME.
+     * The lowest time value for any of the streams, as defined by the
+     * EXT-X-PROGRAM-DATE-TIME value. Measured in seconds since January 1, 1970.
+     *
+     * @private {number}
+     */
+    this.lowestSyncTime_ = Infinity;
+
+    /**
+     * Whether the streams have previously been "finalized"; that is to say,
+     * whether we have loaded enough streams to know information about the asset
+     * such as timing information, live status, etc.
      *
-     * @private {?number}
+     * @private {boolean}
      */
-    this.minSequenceNumber_ = null;
+    this.streamsFinalized_ = false;
 
     /**
      * This timer is used to trigger the start of a manifest update. A manifest
@@ -171,9 +199,6 @@ shaka.hls.HlsParser = class {
     /** @private {shaka.util.OperationManager} */
     this.operationManager_ = new shaka.util.OperationManager();
 
-    /** @private {!Array.<!Array.<!shaka.media.SegmentReference>>} */
-    this.segmentsToNotifyByStream_ = [];
-
     /** A map from closed captions' group id, to a map of closed captions info.
      * {group id -> {closed captions channel id -> language}}
      * @private {Map.<string, Map.<string, string>>}
@@ -220,12 +245,6 @@ shaka.hls.HlsParser = class {
     goog.asserts.assert(response.data, 'Response data should be non-null!');
     await this.parseManifest_(response.data, uri);
 
-    // Start the update timer if we want updates.
-    const delay = this.updatePlaylistDelay_;
-    if (delay > 0) {
-      this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
-    }
-
     goog.asserts.assert(this.manifest_, 'Manifest should be non-null');
     return this.manifest_;
   }
@@ -274,22 +293,20 @@ shaka.hls.HlsParser = class {
     /** @type {!Array.<!Promise>} */
     const updates = [];
     const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
-    // Wait for the first stream info created, so that the start time is fetched
-    // and can be reused.
-    if (streamInfos.length) {
-      await this.updateStream_(streamInfos[0]);
-    }
-    for (let i = 1; i < streamInfos.length; i++) {
-      updates.push(this.updateStream_(streamInfos[i]));
-    }
 
+    // Only update active streams.
+    const activeStreamInfos = streamInfos.filter((s) => s.stream.segmentIndex);
+    for (const streamInfo of activeStreamInfos) {
+      updates.push(this.updateStream_(streamInfo));
+    }
     await Promise.all(updates);
 
-    this.notifySegments_();
+    // Now that streams have been updated, notify the presentation timeline.
+    this.notifySegmentsForStreams_(activeStreamInfos.map((s) => s.stream));
 
     // If any hasEndList is false, the stream is still live.
-    const stillLive = streamInfos.some((s) => s.hasEndList == false);
-    if (!stillLive) {
+    const stillLive = activeStreamInfos.some((s) => s.hasEndList == false);
+    if (activeStreamInfos.length && !stillLive) {
       // Convert the presentation to VOD and set the duration.
       const PresentationType = shaka.hls.HlsParser.PresentationType_;
       this.setPresentationType_(PresentationType.VOD);
@@ -301,6 +318,19 @@ shaka.hls.HlsParser = class {
     }
   }
 
+  /**
+   * @param {!shaka.hls.HlsParser.StreamInfo} streamInfo
+   * @return {!Map.<number, number>}
+   * @private
+   */
+  getMediaSequenceToStartTimeFor_(streamInfo) {
+    if (this.isLive_()) {
+      return this.mediaSequenceToStartTimeByType_.get(streamInfo.type);
+    } else {
+      return streamInfo.mediaSequenceToStartTime;
+    }
+  }
+
   /**
    * Updates a stream.
    *
@@ -317,6 +347,10 @@ shaka.hls.HlsParser = class {
       uriObj.setQueryData(new goog.Uri.QueryData('_HLS_skip=YES'));
     }
     const response = await this.requestManifest_(uriObj.toString());
+    if (!streamInfo.stream.segmentIndex) {
+      // The stream was closed since the update was first requested.
+      return;
+    }
 
     /** @type {shaka.hls.Playlist} */
     const playlist = this.manifestTextParser_.parsePlaylist(
@@ -337,18 +371,29 @@ shaka.hls.HlsParser = class {
 
     const stream = streamInfo.stream;
 
+    const mediaSequenceToStartTime =
+        this.getMediaSequenceToStartTimeFor_(streamInfo);
+    const {keyIds, drmInfos} = this.parseDrmInfo_(playlist, stream.mimeType);
+
+    const keysAreEqual =
+      (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
+
+    if (!keysAreEqual(stream.keyIds, keyIds)) {
+      stream.keyIds = keyIds;
+      stream.drmInfos = drmInfos;
+      this.playerInterface_.newDrmInfo(stream);
+    }
+
     const segments = this.createSegments_(
         streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
-        stream.mimeType, streamInfo.mediaSequenceToStartTime, mediaVariables,
-        stream.codecs);
-    this.segmentsToNotifyByStream_.push(segments);
+        stream.mimeType, mediaSequenceToStartTime, mediaVariables);
 
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
     if (segments.length) {
       const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
-      const playlistStartTime = streamInfo.mediaSequenceToStartTime.get(
+      const playlistStartTime = mediaSequenceToStartTime.get(
           mediaSequenceNumber);
       stream.segmentIndex.evict(playlistStartTime);
     }
@@ -379,68 +424,70 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * Align all streams by sequence number by dropping early segments.  Then
-   * offset all streams to begin at presentation time 0.
+   * Align the streams by sequence number by dropping early segments.  Then
+   * offset the streams to begin at presentation time 0.
+   * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
    * @private
    */
-  syncStreamsWithSequenceNumber_() {
-    if (this.streamsSynced_) {
-      return;
-    }
-
+  syncStreamsWithSequenceNumber_(streamInfos) {
+    // We assume that, when this is first called, we have enough info to
+    // determine how to use the program date times (e.g. we have both a video
+    // and an audio, and all other videos and audios match those).
+    // Thus, we only need to calculate this once.
+    const updateMinSequenceNumber = this.minSequenceNumber_ == -1;
     // Sync using media sequence number.  Find the highest starting sequence
     // number among all streams.  Later, we will drop any references to
     // earlier segments in other streams, then offset everything back to 0.
-    let highestStartingSequenceNumber = -1;
-    const firstSequenceNumberMap = new Map();
-
-    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+    for (const streamInfo of streamInfos) {
       const segmentIndex = streamInfo.stream.segmentIndex;
-      if (segmentIndex) {
-        const segment0 = segmentIndex.earliestReference();
-        if (segment0) {
-          // This looks inefficient, but iteration order is insertion order.
-          // So the very first entry should be the one we want.
-          // We assert that this holds true so that we are alerted by debug
-          // builds and tests if it changes.  We still do a loop, though, so
-          // that the code functions correctly in production no matter what.
-          if (goog.DEBUG) {
-            const firstSequenceStartTime =
-                streamInfo.mediaSequenceToStartTime.values().next().value;
-            goog.asserts.assert(
-                firstSequenceStartTime == segment0.startTime,
-                'Sequence number map is not ordered as expected!');
-          }
-          for (const [sequence, start] of streamInfo.mediaSequenceToStartTime) {
-            if (start == segment0.startTime) {
-              firstSequenceNumberMap.set(streamInfo, sequence);
-
-              highestStartingSequenceNumber = Math.max(
-                  highestStartingSequenceNumber, sequence);
-              break;
+      goog.asserts.assert(segmentIndex,
+          'Only loaded streams should be synced');
+      const mediaSequenceToStartTime =
+          this.getMediaSequenceToStartTimeFor_(streamInfo);
+      const segment0 = segmentIndex.earliestReference();
+      if (segment0) {
+        // This looks inefficient, but iteration order is insertion order.
+        // So the very first entry should be the one we want.
+        // We assert that this holds true so that we are alerted by debug
+        // builds and tests if it changes.  We still do a loop, though, so
+        // that the code functions correctly in production no matter what.
+        if (goog.DEBUG) {
+          const firstSequenceStartTime =
+              mediaSequenceToStartTime.values().next().value;
+          goog.asserts.assert(
+              firstSequenceStartTime == segment0.startTime,
+              'Sequence number map is not ordered as expected!');
+        }
+        for (const [sequence, start] of mediaSequenceToStartTime) {
+          if (start == segment0.startTime) {
+            if (updateMinSequenceNumber) {
+              this.minSequenceNumber_ = Math.max(
+                  this.minSequenceNumber_, sequence);
             }
+            // Even if we already have decided on a value for
+            // |this.minSequenceNumber_|, we still need to determine the first
+            // sequence number for the stream, to offset it in the code below.
+            streamInfo.firstSequenceNumber = sequence;
+            break;
           }
         }
       }
     }
 
-    if (highestStartingSequenceNumber < 0) {
+    if (this.minSequenceNumber_ < 0) {
       // Nothing to sync.
       return;
     }
 
-    // From now on, updates will ignore any references before this number.
-    this.minSequenceNumber_ = highestStartingSequenceNumber;
-
     shaka.log.debug('Syncing HLS streams against base sequence number:',
         this.minSequenceNumber_);
 
-    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+    for (const streamInfo of streamInfos) {
       const segmentIndex = streamInfo.stream.segmentIndex;
       if (segmentIndex) {
         // Drop any earlier references.
-        const numSegmentsToDrop = this.minSequenceNumber_ -
-            firstSequenceNumberMap.get(streamInfo);
+        const numSegmentsToDrop =
+            this.minSequenceNumber_ - streamInfo.firstSequenceNumber;
         segmentIndex.dropFirstReferences(numSegmentsToDrop);
 
         // Now adjust timestamps back to begin at 0.
@@ -450,33 +497,34 @@ shaka.hls.HlsParser = class {
         }
       }
     }
-
-    this.streamsSynced_ = true;
   }
 
   /**
    * Synchronize streams by the EXT-X-PROGRAM-DATE-TIME tags attached to their
    * segments.  Also normalizes segment times so that the earliest segment in
    * any stream is at time 0.
+   * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
    * @private
    */
-  syncStreamsWithProgramDateTime_() {
-    if (this.streamsSynced_) {
-      return;
-    }
-
-    let lowestSyncTime = Infinity;
-
-    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-      const segmentIndex = streamInfo.stream.segmentIndex;
-      if (segmentIndex) {
+  syncStreamsWithProgramDateTime_(streamInfos) {
+    // We assume that, when this is first called, we have enough info to
+    // determine how to use the program date times (e.g. we have both a video
+    // and an audio, and all other videos and audios match those).
+    // Thus, we only need to calculate this once.
+    if (this.lowestSyncTime_ == Infinity) {
+      for (const streamInfo of streamInfos) {
+        const segmentIndex = streamInfo.stream.segmentIndex;
+        goog.asserts.assert(segmentIndex,
+            'Only loaded streams should be synced');
         const segment0 = segmentIndex.earliestReference();
         if (segment0 != null && segment0.syncTime != null) {
-          lowestSyncTime = Math.min(lowestSyncTime, segment0.syncTime);
+          this.lowestSyncTime_ =
+              Math.min(this.lowestSyncTime_, segment0.syncTime);
         }
       }
     }
 
+    const lowestSyncTime = this.lowestSyncTime_;
     if (lowestSyncTime == Infinity) {
       // Nothing to sync.
       return;
@@ -506,8 +554,6 @@ shaka.hls.HlsParser = class {
         }
       }
     }
-
-    this.streamsSynced_ = true;
   }
 
   /**
@@ -522,8 +568,10 @@ shaka.hls.HlsParser = class {
     goog.asserts.assert(streamInfo.maxTimestamp >= 0,
         'Negative maxTimestamp after adjustment!');
 
-    for (const [key, value] of streamInfo.mediaSequenceToStartTime) {
-      streamInfo.mediaSequenceToStartTime.set(key, value + offset);
+    const mediaSequenceToStartTime =
+        this.getMediaSequenceToStartTimeFor_(streamInfo);
+    for (const [key, value] of mediaSequenceToStartTime) {
+      mediaSequenceToStartTime.set(key, value + offset);
     }
 
     shaka.log.debug('Offset', offset, 'applied to',
@@ -539,6 +587,7 @@ shaka.hls.HlsParser = class {
    * @private
    */
   async parseManifest_(data, uri) {
+    const HlsParser = shaka.hls.HlsParser;
     const Utils = shaka.hls.Utils;
 
     goog.asserts.assert(this.masterPlaylistUri_,
@@ -564,7 +613,31 @@ shaka.hls.HlsParser = class {
       // Get necessary info for this stream, from the config. These are things
       // we would normally find from the master playlist (e.g. from values on
       // EXT-X-MEDIA tags).
-      const fullMimeType = this.config_.hls.mediaPlaylistFullMimeType;
+      let fullMimeType = this.config_.hls.mediaPlaylistFullMimeType;
+      // Try to infer the full mimetype better.
+      if (playlist.segments.length) {
+        const parsedUri = new goog.Uri(playlist.segments[0].absoluteUri);
+        const extension = parsedUri.getPath().split('.').pop();
+        let mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
+        if (mimeType) {
+          fullMimeType = mimeType;
+        } else if (extension === 'ts') {
+          // TODO: Fetch one segment a use the TsParser to analize if there is
+          // video, audio or both.
+        } else if (extension === 'mp4') {
+          // TODO: Fetch one segment a use the Mp4Parser to analize if there is
+          // video, audio or both.
+        } else if (HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_[extension]) {
+          mimeType = HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_[extension];
+          const defaultAudioCodec = this.config_.hls.defaultAudioCodec;
+          fullMimeType = `${mimeType}; codecs="${defaultAudioCodec}"`;
+        } else if (HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_[extension]) {
+          mimeType = HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_[extension];
+          const defaultVideoCodec = this.config_.hls.defaultVideoCodec;
+          fullMimeType = `${mimeType}; codecs="${defaultVideoCodec}"`;
+        }
+      }
+
       const mimeType = shaka.util.MimeUtils.getBasicType(fullMimeType);
       const type = mimeType.split('/')[0];
       const codecs = shaka.util.MimeUtils.getCodecs(fullMimeType);
@@ -611,6 +684,9 @@ shaka.hls.HlsParser = class {
       /** @type {!Array.<!shaka.hls.Tag>} */
       const imageTags = Utils.filterTagsByName(
           playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const sessionKeyTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-SESSION-KEY');
 
       this.parseCodecs_(variantTags);
 
@@ -641,10 +717,10 @@ shaka.hls.HlsParser = class {
 
       // Parse audio and video media tags first, so that we can extract segment
       // start time from audio/video streams and reuse for text streams.
-      await this.createStreamInfosFromMediaTags_(mediaTags);
+      this.createStreamInfosFromMediaTags_(mediaTags);
       this.parseClosedCaptions_(mediaTags);
-      variants = await this.createVariantsForTags_(variantTags);
-      textStreams = await this.parseTexts_(mediaTags);
+      variants = this.createVariantsForTags_(variantTags, sessionKeyTags);
+      textStreams = this.parseTexts_(mediaTags);
       imageStreams = await this.parseImages_(imageTags);
     }
 
@@ -656,32 +732,45 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.OPERATION_ABORTED);
     }
 
-    // Now that we have generated all streams, we can determine the offset to
-    // apply to sync times.
-    if (this.config_.hls.ignoreManifestProgramDateTime) {
-      this.syncStreamsWithSequenceNumber_();
-    } else {
-      this.syncStreamsWithProgramDateTime_();
-    }
-
-    // Find the min and max timestamp of the earliest segment in all streams.
-    // Find the minimum duration of all streams as well.
-    let minDuration = Infinity;
-    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-      if (streamInfo.stream.type != 'text') {
-        // Since everything is already offset to 0 (either by sync or by being
-        // VOD), only maxTimestamp is necessary to compute the duration.
-        minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
-      }
-    }
-
     // This assert is our own sanity check.
     goog.asserts.assert(this.presentationTimeline_ == null,
         'Presentation timeline created early!');
-    this.createPresentationTimeline_();
+    // We don't know if the presentation is VOD or live until we parse at least
+    // one media playlist, so make a VOD-style presentation timeline for now
+    // and change the type later if we discover this is live.
+    // Since the player will load the first variant chosen early in the process,
+    // there isn't a window during playback where the live-ness is unknown.
+    this.presentationTimeline_ = new shaka.media.PresentationTimeline(
+        /* presentationStartTime= */ null, /* delay= */ 0);
+    this.presentationTimeline_.setStatic(true);
+
+    // Single-variant streams aren't lazy-loaded, so for them we already have
+    // enough info here to determine the presentation type and duration.
+    if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
+      if (this.isLive_()) {
+        this.changePresentationTimelineToLive_();
+        const delay = this.updatePlaylistDelay_;
+        this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+      }
+      const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
+      this.finalizeStreams_(streamInfos);
+      this.determineDuration_();
+    }
 
-    // This assert satisfies the compiler that it is not null for the rest of
-    // the method.
+    this.manifest_ = {
+      presentationTimeline: this.presentationTimeline_,
+      variants,
+      textStreams,
+      imageStreams,
+      offlineSessionIds: [],
+      minBufferTime: 0,
+      sequenceMode: true,
+    };
+    this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
+  }
+
+  /** @private */
+  determineDuration_() {
     goog.asserts.assert(this.presentationTimeline_,
         'Presentation timeline not created!');
 
@@ -701,10 +790,14 @@ shaka.hls.HlsParser = class {
       const PresentationType = shaka.hls.HlsParser.PresentationType_;
 
       if (this.presentationType_ == PresentationType.LIVE) {
+        let segmentAvailabilityDuration = this.getMinDuration_();
+
         // This defaults to the presentation delay, which has the effect of
         // making the live stream unseekable.  This is consistent with Apple's
         // HLS implementation.
-        let segmentAvailabilityDuration = this.presentationTimeline_.getDelay();
+        if (this.config_.hls.useSafariBehaviorForLive) {
+          segmentAvailabilityDuration = this.presentationTimeline_.getDelay();
+        }
 
         // The app can override that with a longer duration, to allow seeking.
         if (!isNaN(this.config_.availabilityWindowOverride)) {
@@ -716,33 +809,9 @@ shaka.hls.HlsParser = class {
       }
     } else {
       // Use the minimum duration as the presentation duration.
-      this.presentationTimeline_.setDuration(minDuration);
-
-      for (const streamInfo of this.uriToStreamInfosMap_.values()) {
-        // Fit the segments to the playlist duration.
-        streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
-      }
+      this.presentationTimeline_.setDuration(this.getMinDuration_());
     }
 
-    // Now that the content has been fit, notify segments.
-    this.segmentsToNotifyByStream_ = [];
-    const streamsToNotify = [];
-    for (const variant of variants) {
-      for (const stream of [variant.video, variant.audio]) {
-        if (stream) {
-          streamsToNotify.push(stream);
-        }
-      }
-    }
-    await Promise.all(streamsToNotify.map(async (stream) => {
-      await stream.createSegmentIndex();
-    }));
-    for (const stream of streamsToNotify) {
-      this.segmentsToNotifyByStream_.push(stream.segmentIndex.references);
-    }
-
-    this.notifySegments_();
-
     // This is the first point where we have a meaningful presentation start
     // time, and we need to tell PresentationTimeline that so that it can
     // maintain consistency from here on.
@@ -753,17 +822,6 @@ shaka.hls.HlsParser = class {
     goog.asserts.assert(
         !this.presentationTimeline_.usingPresentationStartTime(),
         'We should not be using the presentation start time in HLS!');
-
-    this.manifest_ = {
-      presentationTimeline: this.presentationTimeline_,
-      variants,
-      textStreams,
-      imageStreams,
-      offlineSessionIds: [],
-      minBufferTime: 0,
-      sequenceMode: true,
-    };
-    this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
   }
 
   /**
@@ -854,21 +912,20 @@ shaka.hls.HlsParser = class {
    * Create text streams for Subtitles, but not Closed Captions.
    *
    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
-   * @return {!Promise.<!Array.<!shaka.extern.Stream>>}
+   * @return {!Array.<!shaka.extern.Stream>}
    * @private
    */
-  async parseTexts_(mediaTags) {
+  parseTexts_(mediaTags) {
     // Create text stream for each Subtitle media tag.
     const subtitleTags =
         shaka.hls.Utils.filterTagsByType(mediaTags, 'SUBTITLES');
-    const textStreamPromises = subtitleTags.map(async (tag) => {
+    const textStreams = subtitleTags.map((tag) => {
       const disableText = this.config_.disableText;
       if (disableText) {
         return null;
       }
       try {
-        const streamInfo = await this.createStreamInfoFromMediaTag_(tag);
-        return streamInfo.stream;
+        return this.createStreamInfoFromMediaTag_(tag).stream;
       } catch (e) {
         if (this.config_.hls.ignoreTextStreamFailures) {
           return null;
@@ -876,7 +933,6 @@ shaka.hls.HlsParser = class {
         throw e;
       }
     });
-    const textStreams = await Promise.all(textStreamPromises);
 
     // Set the codecs for text streams.
     for (const tag of subtitleTags) {
@@ -926,7 +982,7 @@ shaka.hls.HlsParser = class {
    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
    * @private
    */
-  async createStreamInfosFromMediaTags_(mediaTags) {
+  createStreamInfosFromMediaTags_(mediaTags) {
     // Filter out subtitles and  media tags without uri.
     mediaTags = mediaTags.filter((tag) => {
       const uri = tag.getAttributeValue('URI') || '';
@@ -935,20 +991,52 @@ shaka.hls.HlsParser = class {
     });
 
     // Create stream info for each audio / video media tag.
-    const promises = mediaTags.map((tag) => {
-      return this.createStreamInfoFromMediaTag_(tag);
-    });
-    await Promise.all(promises);
+    for (const tag of mediaTags) {
+      this.createStreamInfoFromMediaTag_(tag);
+    }
   }
 
   /**
    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
-   * @return {!Promise.<!Array.<!shaka.extern.Variant>>}
+   * @param {!Array.<!shaka.hls.Tag>} sessionKeyTags EXT-X-SESSION-KEY tags
+   * from the playlist.
+   * @return {!Array.<!shaka.extern.Variant>}
    * @private
    */
-  async createVariantsForTags_(tags) {
+  createVariantsForTags_(tags, sessionKeyTags) {
+    // EXT-X-SESSION-KEY processing
+    const drmInfos = [];
+    const keyIds = new Set();
+    if (sessionKeyTags.length > 0) {
+      for (const drmTag of sessionKeyTags) {
+        const method = drmTag.getRequiredAttrValue('METHOD');
+        if (method != 'NONE' && method != 'AES-128') {
+          // According to the HLS spec, KEYFORMAT is optional and implicitly
+          // defaults to "identity".
+          // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
+          const keyFormat =
+              drmTag.getAttributeValue('KEYFORMAT') || 'identity';
+          const drmParser =
+              shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
+
+          const drmInfo = drmParser ?
+              drmParser(drmTag, /* mimeType= */ '') : null;
+          if (drmInfo) {
+            if (drmInfo.keyIds) {
+              for (const keyId of drmInfo.keyIds) {
+                keyIds.add(keyId);
+              }
+            }
+            drmInfos.push(drmInfo);
+          } else {
+            shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
+          }
+        }
+      }
+    }
+
     // Create variants for each variant tag.
-    const variantsPromises = tags.map(async (tag) => {
+    const allVariants = tags.map((tag) => {
       const frameRate = tag.getAttributeValue('FRAME-RATE');
       const bandwidth = Number(tag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
         Number(tag.getRequiredAttrValue('BANDWIDTH'));
@@ -958,7 +1046,7 @@ shaka.hls.HlsParser = class {
 
       const videoRange = tag.getAttributeValue('VIDEO-RANGE');
 
-      const streamInfos = await this.createStreamInfosForVariantTag_(tag,
+      const streamInfos = this.createStreamInfosForVariantTag_(tag,
           resolution, frameRate);
 
       goog.asserts.assert(streamInfos.audio.length ||
@@ -971,10 +1059,10 @@ shaka.hls.HlsParser = class {
           width,
           height,
           frameRate,
-          videoRange);
+          videoRange,
+          drmInfos,
+          keyIds);
     });
-
-    const allVariants = await Promise.all(variantsPromises);
     let variants = allVariants.reduce(shaka.util.Functional.collapseArrays, []);
     // Filter out null variants.
     variants = variants.filter((variant) => variant != null);
@@ -988,10 +1076,10 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {?string} resolution
    * @param {?string} frameRate
-   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfos>}
+   * @return {!shaka.hls.HlsParser.StreamInfos}
    * @private
    */
-  async createStreamInfosForVariantTag_(tag, resolution, frameRate) {
+  createStreamInfosForVariantTag_(tag, resolution, frameRate) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     /** @type {!Array.<string>} */
     let allCodecs = this.getCodecsForVariantTag_(tag);
@@ -1060,10 +1148,9 @@ shaka.hls.HlsParser = class {
 
     if (!ignoreStream) {
       const streamInfo =
-          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
+          this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
       res[streamInfo.stream.type] = [streamInfo];
     }
-    this.filterLegacyCodecs_(res);
     return res;
   }
 
@@ -1194,7 +1281,7 @@ shaka.hls.HlsParser = class {
 
   /**
    * Get the type value.
-   * Shaka recognizes the content types 'audio', 'video' and 'text'.
+   * Shaka recognizes the content types 'audio', 'video', 'text', and 'image'.
    * The HLS 'subtitles' type needs to be mapped to 'text'.
    * @param {!shaka.hls.Tag} tag
    * @return {string}
@@ -1208,28 +1295,6 @@ shaka.hls.HlsParser = class {
     return type;
   }
 
-  /**
-   * Filters out unsupported codec strings from an array of stream infos.
-   * @param {shaka.hls.HlsParser.StreamInfos} streamInfos
-   * @private
-   */
-  filterLegacyCodecs_(streamInfos) {
-    for (const streamInfo of streamInfos.audio.concat(streamInfos.video)) {
-      if (!streamInfo) {
-        continue;
-      }
-      let codecs = streamInfo.stream.codecs.split(',');
-      codecs = codecs.filter((codec) => {
-        // mp4a.40.34 is a nonstandard codec string that is sometimes used in
-        // HLS for legacy reasons.  It is not recognized by non-Apple MSE.
-        // See https://bugs.chromium.org/p/chromium/issues/detail?id=489520
-        // Therefore, ignore this codec string.
-        return codec != 'mp4a.40.34';
-      });
-      streamInfo.stream.codecs = codecs.join(',');
-    }
-  }
-
   /**
    * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} audioInfos
    * @param {!Array.<shaka.hls.HlsParser.StreamInfo>} videoInfos
@@ -1238,11 +1303,14 @@ shaka.hls.HlsParser = class {
    * @param {?string} height
    * @param {?string} frameRate
    * @param {?string} videoRange
+   * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
+   * @param {!Set.<string>} keyIds
    * @return {!Array.<!shaka.extern.Variant>}
    * @private
    */
   createVariants_(
-      audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange) {
+      audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange,
+      drmInfos, keyIds) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const DrmEngine = shaka.media.DrmEngine;
 
@@ -1268,7 +1336,15 @@ shaka.hls.HlsParser = class {
     for (const audioInfo of audioInfos) {
       for (const videoInfo of videoInfos) {
         const audioStream = audioInfo ? audioInfo.stream : null;
+        if (audioStream) {
+          audioStream.drmInfos = drmInfos;
+          audioStream.keyIds = keyIds;
+        }
         const videoStream = videoInfo ? videoInfo.stream : null;
+        if (videoStream) {
+          videoStream.drmInfos = drmInfos;
+          videoStream.keyIds = keyIds;
+        }
         const audioDrmInfos = audioInfo ? audioInfo.stream.drmInfos : null;
         const videoDrmInfos = videoInfo ? videoInfo.stream.drmInfos : null;
         const videoStreamUri =
@@ -1353,10 +1429,10 @@ shaka.hls.HlsParser = class {
    * Parse EXT-X-MEDIA media tag into a Stream object.
    *
    * @param {shaka.hls.Tag} tag
-   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
+   * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  async createStreamInfoFromMediaTag_(tag) {
+  createStreamInfoFromMediaTag_(tag) {
     goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
         'Should only be called on media tags!');
     const groupId = tag.getRequiredAttrValue('GROUP-ID');
@@ -1398,7 +1474,7 @@ shaka.hls.HlsParser = class {
     const forced = forcedAttrValue == 'YES';
     // TODO: Should we take into account some of the currently ignored
     // attributes: INSTREAM-ID, Attribute descriptions: https://bit.ly/2lpjOhj
-    const streamInfo = await this.createStreamInfo_(
+    const streamInfo = this.createStreamInfo_(
         verbatimMediaPlaylistUri, codecs, type, language, primary, name,
         channelsCount, /* closedCaptions= */ null, characteristics, forced,
         spatialAudio);
@@ -1445,7 +1521,7 @@ shaka.hls.HlsParser = class {
 
     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
 
-    const streamInfo = await this.createStreamInfo_(
+    const streamInfo = this.createStreamInfo_(
         verbatimImagePlaylistUri, codecs, type, language, /* primary= */ false,
         name, /* channelsCount= */ null, /* closedCaptions= */ null,
         characteristics, /* forced= */ false, /* spatialAudio= */ false);
@@ -1463,6 +1539,10 @@ shaka.hls.HlsParser = class {
       // of the entire sheet at once (like we expect in the output).
       // So multiply by the layout size.
 
+      // Since we need to have generated the segment index for this, we can't
+      // lazy-load in this situation.
+      await streamInfo.stream.createSegmentIndex();
+
       const reference = streamInfo.stream.segmentIndex.get(0);
       const layout = reference.getTilesLayout();
       if (layout) {
@@ -1489,10 +1569,10 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {!Array.<string>} allCodecs
    * @param {string} type
-   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
+   * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  async createStreamInfoFromVariantTag_(tag, allCodecs, type) {
+  createStreamInfoFromVariantTag_(tag, allCodecs, type) {
     goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
         'Should only be called on variant tags!');
     const verbatimMediaPlaylistUri = this.variableSubstitution_(
@@ -1504,7 +1584,7 @@ shaka.hls.HlsParser = class {
 
     const closedCaptions = this.getClosedCaptions_(tag, type);
     const codecs = shaka.util.ManifestParserUtils.guessCodecs(type, allCodecs);
-    const streamInfo = await this.createStreamInfo_(verbatimMediaPlaylistUri,
+    const streamInfo = this.createStreamInfo_(verbatimMediaPlaylistUri,
         codecs, type, /* language= */ 'und', /* primary= */ false,
         /* name= */ null, /* channelcount= */ null, closedCaptions,
         /* characteristics= */ null, /* forced= */ false,
@@ -1532,29 +1612,275 @@ shaka.hls.HlsParser = class {
    * @param {?string} characteristics
    * @param {boolean} forced
    * @param {boolean} spatialAudio
-   * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
+   * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  async createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
+  createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
       primary, name, channelsCount, closedCaptions, characteristics, forced,
       spatialAudio) {
     // TODO: Refactor, too many parameters
-    let absoluteMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
+    const initialMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
         this.masterPlaylistUri_, verbatimMediaPlaylistUri);
 
-    const response = await this.requestManifest_(absoluteMediaPlaylistUri);
-    // Record the final URI after redirects.
-    absoluteMediaPlaylistUri = response.uri;
+    // This stream is lazy-loaded inside the createSegmentIndex function.
+    // So we start out with a stream object that does not contain the actual
+    // segment index, then download when createSegmentIndex is called.
+    const stream = this.makeStreamObject_(codecs, type, language, primary, name,
+        channelsCount, closedCaptions, characteristics, forced, spatialAudio);
+    if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
+      stream.codecs = '';
+    }
+    const streamInfo = {
+      stream,
+      type,
+      verbatimMediaPlaylistUri,
+      // These values are filled out or updated after lazy-loading:
+      absoluteMediaPlaylistUri: initialMediaPlaylistUri,
+      maxTimestamp: 0,
+      mediaSequenceToStartTime: new Map(),
+      canSkipSegments: false,
+      hasEndList: false,
+      firstSequenceNumber: -1,
+      loadedOnce: false,
+    };
 
-    // Record the redirected, final URI of this media playlist when we parse it.
-    /** @type {!shaka.hls.Playlist} */
-    const playlist = this.manifestTextParser_.parsePlaylist(
-        response.data, absoluteMediaPlaylistUri);
+    /** @param {!AbortSignal} abortSignal */
+    const downloadSegmentIndex = async (abortSignal) => {
+      // Download the actual manifest.
+      const response = await this.requestManifest_(
+          streamInfo.absoluteMediaPlaylistUri);
+      if (abortSignal.aborted) {
+        return;
+      }
+
+      // Record the final URI after redirects.
+      const absoluteMediaPlaylistUri = response.uri;
+
+      // Record the redirected, final URI of this media playlist when we parse
+      // it.
+      /** @type {!shaka.hls.Playlist} */
+      const playlist = this.manifestTextParser_.parsePlaylist(
+          response.data, absoluteMediaPlaylistUri);
+
+      const wasLive = this.isLive_();
+      const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
+          playlist, verbatimMediaPlaylistUri, absoluteMediaPlaylistUri, codecs,
+          type, language, primary, name, channelsCount, closedCaptions,
+          characteristics, forced, spatialAudio);
+      if (abortSignal.aborted) {
+        return;
+      }
+
+      const realStream = realStreamInfo.stream;
+
+      if (this.isLive_() && !wasLive) {
+        // Now that we know that the presentation is live, convert the timeline
+        // to live.
+        this.changePresentationTimelineToLive_();
+      }
+
+      // Copy values from the real stream info to our initial one.
+      streamInfo.absoluteMediaPlaylistUri = absoluteMediaPlaylistUri;
+      streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
+      streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
+      streamInfo.hasEndList = realStreamInfo.hasEndList;
+      streamInfo.mediaSequenceToStartTime =
+          realStreamInfo.mediaSequenceToStartTime;
+      streamInfo.loadedOnce = true;
+      stream.segmentIndex = realStream.segmentIndex;
+      stream.encrypted = realStream.encrypted;
+      stream.drmInfos = realStream.drmInfos;
+      stream.keyIds = realStream.keyIds;
+      stream.mimeType = realStream.mimeType;
+      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
+        stream.codecs = '';
+      }
+
+      // Since we lazy-loaded this content, the player may need to create new
+      // sessions for the DRM info in this stream.
+      if (stream.drmInfos.length) {
+        this.playerInterface_.newDrmInfo(stream);
+      }
+
+      const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      if (type == ContentType.VIDEO || type == ContentType.AUDIO) {
+        for (const otherStreamInfo of this.uriToStreamInfosMap_.values()) {
+          if (!otherStreamInfo.loadedOnce && otherStreamInfo.type == type) {
+            // To aid manifest filtering, assume before loading that all video
+            // renditions have the same MIME type.  (And likewise for audio.)
+            otherStreamInfo.stream.mimeType = realStream.mimeType;
+            if (shaka.media.MediaSourceEngine.RAW_FORMATS
+                .includes(otherStreamInfo.stream.mimeType)) {
+              otherStreamInfo.stream.codecs = '';
+            }
+          }
+        }
+      }
+
+      // Add finishing touches to the stream that can only be done once we have
+      // more full context on the media as a whole.
+      if (this.hasEnoughInfoToFinalizeStreams_()) {
+        if (!this.streamsFinalized_) {
+          // Mark this manifest as having been finalized, so we don't go through
+          // this whole process of finishing touches a second time.
+          this.streamsFinalized_ = true;
+          // Finalize all of the currently-loaded streams.
+          const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
+          const activeStreamInfos =
+              streamInfos.filter((s) => s.stream.segmentIndex);
+          this.finalizeStreams_(activeStreamInfos);
+          // With the addition of this new stream, we now have enough info to
+          // figure out how long the streams should be. So process all streams
+          // we have downloaded up until this point.
+          this.determineDuration_();
+          // Finally, start the update timer, if this asset has been determined
+          // to be a livestream.
+          const delay = this.updatePlaylistDelay_;
+          if (delay > 0) {
+            this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+          }
+        } else {
+          // We don't need to go through the full process; just finalize this
+          // single stream.
+          this.finalizeStreams_([streamInfo]);
+        }
+      }
+    };
+
+    /** @type {Promise} */
+    let creationPromise = null;
+    /** @type {!AbortController} */
+    let abortController = new AbortController();
+    const safeCreateSegmentIndex = () => {
+      // An operation is already in progress.  The second and subsequent
+      // callers receive the same Promise as the first caller, and only one
+      // download operation will occur.
+      if (creationPromise) {
+        return creationPromise;
+      }
+
+      // Create a new AbortController to be able to cancel this specific
+      // download.
+      abortController = new AbortController();
+
+      // Create a Promise tied to the outcome of downloadSegmentIndex().  If
+      // downloadSegmentIndex is rejected, creationPromise will also be
+      // rejected.
+      creationPromise = new Promise((resolve) => {
+        resolve(downloadSegmentIndex(abortController.signal));
+      });
+      return creationPromise;
+    };
+
+    stream.createSegmentIndex = safeCreateSegmentIndex;
+
+    stream.closeSegmentIndex = () => {
+      // If we're mid-creation, cancel it.
+      if (creationPromise && !stream.segmentIndex) {
+        abortController.abort();
+      }
+      // If we have a segment index, release it.
+      if (stream.segmentIndex) {
+        stream.segmentIndex.release();
+        stream.segmentIndex = null;
+      }
+      // Clear the creation Promise so that a new operation can begin.
+      creationPromise = null;
+    };
 
-    return this.convertParsedPlaylistIntoStreamInfo_(playlist,
-        verbatimMediaPlaylistUri, absoluteMediaPlaylistUri, codecs, type,
-        language, primary, name, channelsCount, closedCaptions, characteristics,
-        forced, spatialAudio);
+    return streamInfo;
+  }
+
+  /**
+   * @return {number}
+   * @private
+   */
+  getMinDuration_() {
+    let minDuration = Infinity;
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text') {
+        // Since everything is already offset to 0 (either by sync or by being
+        // VOD), only maxTimestamp is necessary to compute the duration.
+        minDuration = Math.min(minDuration, streamInfo.maxTimestamp);
+      }
+    }
+    return minDuration;
+  }
+
+  /**
+   * @param {!Array.<!shaka.extern.Stream>} streams
+   * @private
+   */
+  notifySegmentsForStreams_(streams) {
+    const references = [];
+    for (const stream of streams) {
+      if (!stream.segmentIndex) {
+        // The stream was closed since the list of streams was built.
+        continue;
+      }
+      stream.segmentIndex.forEachTopLevelReference((reference) => {
+        references.push(reference);
+      });
+    }
+    this.presentationTimeline_.notifySegments(references);
+  }
+
+  /**
+   * @param {!Array.<!shaka.hls.HlsParser.StreamInfo>} streamInfos
+   * @private
+   */
+  finalizeStreams_(streamInfos) {
+    if (!this.isLive_()) {
+      const minDuration = this.getMinDuration_();
+      for (const streamInfo of streamInfos) {
+        streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
+      }
+    }
+    // MediaSource expects no codec strings combined with raw formats.
+    for (const streamInfo of streamInfos) {
+      const stream = streamInfo.stream;
+      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
+        stream.codecs = '';
+      }
+    }
+    this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
+    if (this.config_.hls.ignoreManifestProgramDateTime) {
+      this.syncStreamsWithSequenceNumber_(streamInfos);
+    } else {
+      this.syncStreamsWithProgramDateTime_(streamInfos);
+    }
+  }
+
+  /**
+   * There are some values on streams that can only be set once we know about
+   * both the video and audio content, if present.
+   * This checks if there is at least one video downloaded (if the media has
+   * video), and that there is at least one audio downloaded (if the media has
+   * audio).
+   * @return {boolean}
+   * @private
+   */
+  hasEnoughInfoToFinalizeStreams_() {
+    if (!this.manifest_) {
+      return false;
+    }
+    const videos = [];
+    const audios = [];
+    for (const variant of this.manifest_.variants) {
+      if (variant.video) {
+        videos.push(variant.video);
+      }
+      if (variant.audio) {
+        audios.push(variant.audio);
+      }
+    }
+    if (videos.length > 0 && !videos.some((stream) => stream.segmentIndex)) {
+      return false;
+    }
+    if (audios.length > 0 && !audios.some((stream) => stream.segmentIndex)) {
+      return false;
+    }
+    return true;
   }
 
   /**
@@ -1604,51 +1930,8 @@ shaka.hls.HlsParser = class {
           mediaVariables);
     }
 
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const drmTags = [];
-    if (playlist.segments) {
-      for (const segment of playlist.segments) {
-        const segmentKeyTags = shaka.hls.Utils.filterTagsByName(segment.tags,
-            'EXT-X-KEY');
-        drmTags.push(...segmentKeyTags);
-      }
-    }
-
-    let encrypted = false;
-    let aesEncrypted = false;
-
-    /** @type {!Array.<shaka.extern.DrmInfo>}*/
-    const drmInfos = [];
-    const keyIds = new Set();
-
-    // TODO: May still need changes to support key rotation.
-    for (const drmTag of drmTags) {
-      const method = drmTag.getRequiredAttrValue('METHOD');
-      if (method != 'NONE') {
-        encrypted = true;
-
-        if (method == 'AES-128') {
-          // These keys are handled separately.
-          aesEncrypted = true;
-        } else {
-          const keyFormat = drmTag.getRequiredAttrValue('KEYFORMAT');
-          const drmParser =
-              shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
-
-          const drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
-          if (drmInfo) {
-            if (drmInfo.keyIds) {
-              for (const keyId of drmInfo.keyIds) {
-                keyIds.add(keyId);
-              }
-            }
-            drmInfos.push(drmInfo);
-          } else {
-            shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
-          }
-        }
-      }
-    }
+    const {drmInfos, keyIds, encrypted, aesEncrypted} =
+                        this.parseDrmInfo_(playlist, mimeType);
 
     if (encrypted && !drmInfos.length && !aesEncrypted) {
       throw new shaka.util.Error(
@@ -1657,17 +1940,11 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
     }
 
-    // MediaSource expects no codec strings combined with raw formats.
-    if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(mimeType)) {
-      codecs = '';
-    }
-
-    /** @type {!Map.<number, number>} */
-    const mediaSequenceToStartTime = new Map();
-
+    const mediaSequenceToStartTime = this.isLive_() ?
+        this.mediaSequenceToStartTimeByType_.get(type) : new Map();
     const prevLowLatencyMode = this.lowLatencyMode_;
     const segments = this.createSegments_(verbatimMediaPlaylistUri, playlist,
-        type, mimeType, mediaSequenceToStartTime, mediaVariables, codecs);
+        type, mimeType, mediaSequenceToStartTime, mediaVariables);
 
     // This happens when autoLowLatencyMode is true, so we need set the
     // correct lowLatencyPresentationDelay_
@@ -1679,33 +1956,71 @@ shaka.hls.HlsParser = class {
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
 
-    const kind = (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
-        shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined;
-
-    const roles = [];
-    if (characteristics) {
-      for (const characteristic of characteristics.split(',')) {
-        roles.push(characteristic);
-      }
-    }
-
     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
         playlist.tags, 'EXT-X-SERVER-CONTROL');
     const canSkipSegments = serverControlTag ?
           serverControlTag.getAttribute('CAN-SKIP-UNTIL') != null : false;
 
-    /** @type {shaka.extern.Stream} */
-    const stream = {
+    const stream = this.makeStreamObject_(codecs, type, language, primary, name,
+        channelsCount, closedCaptions, characteristics, forced, spatialAudio);
+    stream.segmentIndex = segmentIndex;
+    stream.encrypted = encrypted;
+    stream.drmInfos = drmInfos;
+    stream.keyIds = keyIds;
+    stream.mimeType = mimeType;
+
+    return {
+      stream,
+      type,
+      verbatimMediaPlaylistUri,
+      absoluteMediaPlaylistUri,
+      maxTimestamp: lastEndTime,
+      canSkipSegments,
+      hasEndList: false,
+      firstSequenceNumber: -1,
+      mediaSequenceToStartTime,
+      loadedOnce: false,
+    };
+  }
+
+
+  /**
+   * Creates a stream object with the given parameters.
+   * The parameters that are passed into here are only the things that can be
+   * known without downloading the media playlist; other values must be set
+   * manually on the object after creation.
+   * @param {string} codecs
+   * @param {string} type
+   * @param {string} language
+   * @param {boolean} primary
+   * @param {?string} name
+   * @param {?number} channelsCount
+   * @param {Map.<string, string>} closedCaptions
+   * @param {?string} characteristics
+   * @param {boolean} forced
+   * @param {boolean} spatialAudio
+   * @return {!shaka.extern.Stream}
+   * @private
+   */
+  makeStreamObject_(codecs, type, language, primary, name, channelsCount,
+      closedCaptions, characteristics, forced, spatialAudio) {
+    // Fill out a "best-guess" mimeType, for now. It will be replaced once the
+    // stream is lazy-loaded.
+    const mimeType = this.guessMimeTypeBeforeLoading_(type, codecs) ||
+        this.guessMimeTypeFallback_(type);
+
+    return {
       id: this.globalId_++,
       originalId: name,
       createSegmentIndex: () => Promise.resolve(),
-      segmentIndex,
+      segmentIndex: null,
       mimeType,
       codecs,
-      kind,
-      encrypted,
-      drmInfos,
-      keyIds,
+      kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
+          shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
+      encrypted: false,
+      drmInfos: [],
+      keyIds: new Set(),
       language,
       label: name,  // For historical reasons, since before "originalId".
       type,
@@ -1718,27 +2033,80 @@ shaka.hls.HlsParser = class {
       width: undefined,
       height: undefined,
       bandwidth: undefined,
-      roles: roles,
-      forced: forced,
+      roles: characteristics ? characteristics.split(',') : [],
+      forced,
       channelsCount,
       audioSamplingRate: null,
-      spatialAudio: spatialAudio,
+      spatialAudio,
       closedCaptions,
       hdr: undefined,
       tilesLayout: undefined,
     };
-
-    return {
-      stream,
-      verbatimMediaPlaylistUri,
-      absoluteMediaPlaylistUri,
-      maxTimestamp: lastEndTime,
-      mediaSequenceToStartTime,
-      canSkipSegments,
-      hasEndList: false,
-    };
   }
 
+  /**
+   * @param {!shaka.hls.Playlist} playlist
+   * @param {string} mimeType
+   * @return {{
+   *   drmInfos: !Array.<shaka.extern.DrmInfo>,
+   *   keyIds: !Set.<string>,
+   *   encrypted: boolean,
+   *   aesEncrypted: boolean
+   * }}
+   * @private
+   */
+  parseDrmInfo_(playlist, mimeType) {
+    /** @type {!Array.<!shaka.hls.Tag>} */
+    const drmTags = [];
+    if (playlist.segments) {
+      for (const segment of playlist.segments) {
+        const segmentKeyTags = shaka.hls.Utils.filterTagsByName(segment.tags,
+            'EXT-X-KEY');
+        drmTags.push(...segmentKeyTags);
+      }
+    }
+
+    let encrypted = false;
+    let aesEncrypted = false;
+
+    /** @type {!Array.<shaka.extern.DrmInfo>}*/
+    const drmInfos = [];
+    const keyIds = new Set();
+
+    for (const drmTag of drmTags) {
+      const method = drmTag.getRequiredAttrValue('METHOD');
+      if (method != 'NONE') {
+        encrypted = true;
+
+        if (method == 'AES-128') {
+          // These keys are handled separately.
+          aesEncrypted = true;
+        } else {
+          // According to the HLS spec, KEYFORMAT is optional and implicitly
+          // defaults to "identity".
+          // https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-4.4.4.4
+          const keyFormat =
+              drmTag.getAttributeValue('KEYFORMAT') || 'identity';
+          const drmParser =
+              shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
+
+          const drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
+          if (drmInfo) {
+            if (drmInfo.keyIds) {
+              for (const keyId of drmInfo.keyIds) {
+                keyIds.add(keyId);
+              }
+            }
+            drmInfos.push(drmInfo);
+          } else {
+            shaka.log.warning('Unsupported HLS KEYFORMAT', keyFormat);
+          }
+        }
+      }
+    }
+
+    return {drmInfos, keyIds, encrypted, aesEncrypted};
+  }
 
   /**
    * @param {!shaka.hls.Tag} drmTag
@@ -1882,39 +2250,34 @@ shaka.hls.HlsParser = class {
   /**
    * @private
    */
-  createPresentationTimeline_() {
-    if (this.isLive_()) {
-      // The live edge will be calculated from segments, so we don't need to
-      // set a presentation start time.  We will assert later that this is
-      // working as expected.
-
-      // The HLS spec (RFC 8216) states in 6.3.3:
-      //
-      // "The client SHALL choose which Media Segment to play first ... the
-      // client SHOULD NOT choose a segment that starts less than three target
-      // durations from the end of the Playlist file.  Doing so can trigger
-      // playback stalls."
-      //
-      // We accomplish this in our DASH-y model by setting a presentation
-      // delay of configured value, or 3 segments duration if not configured.
-      // This will be the "live edge" of the presentation.
-      let presentationDelay;
-      if (this.config_.defaultPresentationDelay) {
-        presentationDelay = this.config_.defaultPresentationDelay;
-      } else if (this.lowLatencyPresentationDelay_) {
-        presentationDelay = this.lowLatencyPresentationDelay_;
-      } else {
-        presentationDelay = this.maxTargetDuration_ * 3;
-      }
-
-      this.presentationTimeline_ = new shaka.media.PresentationTimeline(
-      /* presentationStartTime= */ 0, /* delay= */ presentationDelay);
-      this.presentationTimeline_.setStatic(false);
+  changePresentationTimelineToLive_() {
+    // The live edge will be calculated from segments, so we don't need to
+    // set a presentation start time.  We will assert later that this is
+    // working as expected.
+
+    // The HLS spec (RFC 8216) states in 6.3.3:
+    //
+    // "The client SHALL choose which Media Segment to play first ... the
+    // client SHOULD NOT choose a segment that starts less than three target
+    // durations from the end of the Playlist file.  Doing so can trigger
+    // playback stalls."
+    //
+    // We accomplish this in our DASH-y model by setting a presentation
+    // delay of configured value, or 3 segments duration if not configured.
+    // This will be the "live edge" of the presentation.
+    let presentationDelay;
+    if (this.config_.defaultPresentationDelay) {
+      presentationDelay = this.config_.defaultPresentationDelay;
+    } else if (this.lowLatencyPresentationDelay_) {
+      presentationDelay = this.lowLatencyPresentationDelay_;
     } else {
-      this.presentationTimeline_ = new shaka.media.PresentationTimeline(
-      /* presentationStartTime= */ null, /* delay= */ 0);
-      this.presentationTimeline_.setStatic(true);
+      const numberOfSegments = this.config_.hls.liveSegmentsDelay;
+      presentationDelay = this.maxTargetDuration_ * numberOfSegments;
     }
+
+    this.presentationTimeline_.setPresentationStartTime(0);
+    this.presentationTimeline_.setDelay(presentationDelay);
+    this.presentationTimeline_.setStatic(false);
   }
 
   /**
@@ -2205,19 +2568,6 @@ shaka.hls.HlsParser = class {
     return [startByte, endByte];
   }
 
-  /** @private */
-  notifySegments_() {
-    // The presentation timeline may or may not be set yet.
-    // If it does not yet exist, hold onto the segments until it does.
-    if (!this.presentationTimeline_) {
-      return;
-    }
-    for (const segments of this.segmentsToNotifyByStream_) {
-      this.presentationTimeline_.notifySegments(segments);
-    }
-    this.segmentsToNotifyByStream_ = [];
-  }
-
   /**
    * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences.
    *
@@ -2227,12 +2577,11 @@ shaka.hls.HlsParser = class {
    * @param {string} mimeType
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
-   * @param {string} codecs
    * @return {!Array.<!shaka.media.SegmentReference>}
    * @private
    */
   createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
-      mediaSequenceToStartTime, variables, codecs) {
+      mediaSequenceToStartTime, variables) {
     /** @type {Array.<!shaka.hls.Segment>} */
     const hlsSegments = playlist.segments;
     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
@@ -2435,6 +2784,64 @@ shaka.hls.HlsParser = class {
    *
    * @param {string} contentType
    * @param {string} codecs
+   * @return {?string}
+   * @private
+   */
+  guessMimeTypeBeforeLoading_(contentType, codecs) {
+    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      if (codecs == 'vtt' || codecs == 'wvtt') {
+        // If codecs is 'vtt', it's WebVTT.
+        return 'text/vtt';
+      } else if (codecs && codecs !== '') {
+        // Otherwise, assume MP4-embedded text, since text-based formats tend
+        // not to have a codecs string at all.
+        return 'application/mp4';
+      }
+    }
+
+    if (contentType == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
+      if (!codecs || codecs == 'jpeg') {
+        return 'image/jpeg';
+      }
+    }
+
+    if (contentType == shaka.util.ManifestParserUtils.ContentType.AUDIO) {
+      // See: https://bugs.chromium.org/p/chromium/issues/detail?id=489520
+      if (codecs == 'mp4a.40.34') {
+        return 'audio/mpeg';
+      }
+    }
+
+    // Not enough information to guess from the content type and codecs.
+    return null;
+  }
+
+  /**
+   * Get a fallback mime type for the content. Used if all the better methods
+   * for determining the mime type have failed.
+   *
+   * @param {string} contentType
+   * @return {string}
+   * @private
+   */
+  guessMimeTypeFallback_(contentType) {
+    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      // If there was no codecs string and no content-type, assume HLS text
+      // streams are WebVTT.
+      return 'text/vtt';
+    }
+    // If the HLS content is lacking in both MIME type metadata and
+    // segment file extensions, we fall back to assuming it's MP4.
+    const map = shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
+    return map['mp4'];
+  }
+
+  /**
+   * Attempts to guess stream's mime type based on content type, URI, and
+   * contents of the playlist.
+   *
+   * @param {string} contentType
+   * @param {string} codecs
    * @param {!shaka.hls.Playlist} playlist
    * @param {!Map.<string, string>} variables
    * @return {!Promise.<string>}
@@ -2442,7 +2849,6 @@ shaka.hls.HlsParser = class {
    */
   async guessMimeType_(contentType, codecs, playlist, variables) {
     const HlsParser = shaka.hls.HlsParser;
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
     // If you wait long enough, requesting the first segment can fail
@@ -2468,22 +2874,10 @@ shaka.hls.HlsParser = class {
       return mimeType;
     }
 
-    if (contentType == ContentType.TEXT) {
-      // The extension map didn't work.
-      if (codecs == 'vtt' || codecs == 'wvtt') {
-        // If codecs is 'vtt', it's WebVTT.
-        return 'text/vtt';
-      } else if (codecs && codecs !== '') {
-        // Otherwise, assume MP4-embedded text, since text-based formats tend
-        // not to have a codecs string at all.
-        return 'application/mp4';
-      }
-    }
-
-    if (contentType == ContentType.IMAGE) {
-      if (!codecs || codecs == 'jpeg') {
-        return 'image/jpeg';
-      }
+    // The extension map didn't work, so guess based on codecs.
+    mimeType = this.guessMimeTypeBeforeLoading_(contentType, codecs);
+    if (mimeType) {
+      return mimeType;
     }
 
     // If unable to guess mime type, request a segment and try getting it
@@ -2496,21 +2890,12 @@ shaka.hls.HlsParser = class {
         headRequest, requestType);
 
     const contentMimeType = response.headers['content-type'];
-
-    if (!contentMimeType) {
-      if (contentType == ContentType.TEXT) {
-        // If there was no codecs string and no content-type, assume HLS text
-        // streams are WebVTT.
-        return 'text/vtt';
-      }
-      // If the HLS content is lacking in both MIME type metadata and
-      // segment file extensions, we fall back to assuming it's MP4.
-      const fallbackMimeType = map['mp4'];
-      return fallbackMimeType;
+    if (contentMimeType) {
+      // Split the MIME type in case the server sent additional parameters.
+      return contentMimeType.split(';')[0];
     }
 
-    // Split the MIME type in case the server sent additional parameters.
-    return contentMimeType.split(';')[0];
+    return this.guessMimeTypeFallback_(contentType);
   }
 
   /**
@@ -2700,7 +3085,7 @@ shaka.hls.HlsParser = class {
      */
     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
         'com.apple.fps', [
-          {initDataType: 'sinf', initData: new Uint8Array(0)},
+          {initDataType: 'sinf', initData: new Uint8Array(0), keyId: null},
         ]);
 
     return drmInfo;
@@ -2779,18 +3164,48 @@ shaka.hls.HlsParser = class {
 
     return drmInfo;
   }
+
+  /**
+   * See: https://datatracker.ietf.org/doc/html/draft-pantos-hls-rfc8216bis-11#section-5.1
+   *
+   * @param {!shaka.hls.Tag} drmTag
+   * @return {?shaka.extern.DrmInfo}
+   * @private
+   */
+  static identityDrmParser_(drmTag) {
+    const method = drmTag.getRequiredAttrValue('METHOD');
+    const VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR'];
+    if (!VALID_METHODS.includes(method)) {
+      shaka.log.error('Identity (ClearKey) in HLS is only supported with [',
+          VALID_METHODS.join(', '), '], not', method);
+      return null;
+    }
+
+    // NOTE: The ClearKey CDM requires a key-id to key mapping.  HLS doesn't
+    // provide a key ID anywhere.  So although we could use the 'URI' attribute
+    // to fetch the actual 16-byte key, without a key ID, we can't provide this
+    // automatically to the ClearKey CDM.  Instead, the application will have
+    // to use player.configure('drm.clearKeys', { ... }) to provide the key IDs
+    // and keys or player.configure('drm.servers.org\.w3\.clearkey', ...) to
+    // provide a ClearKey license server URI.
+    return shaka.util.ManifestParserUtils.createDrmInfo(
+        'org.w3.clearkey', /* initDatas= */ null);
+  }
 };
 
 
 /**
  * @typedef {{
  *   stream: !shaka.extern.Stream,
+ *   type: string,
  *   verbatimMediaPlaylistUri: string,
  *   absoluteMediaPlaylistUri: string,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
  *   canSkipSegments: boolean,
- *   hasEndList: boolean
+ *   hasEndList: boolean,
+ *   firstSequenceNumber: number,
+ *   loadedOnce: boolean
  * }}
  *
  * @description
@@ -2798,6 +3213,8 @@ shaka.hls.HlsParser = class {
  *
  * @property {!shaka.extern.Stream} stream
  *   The Stream itself.
+ * @property {string} type
+ *   The type value. Could be 'video', 'audio', 'text', or 'image'.
  * @property {string} verbatimMediaPlaylistUri
  *   The verbatim media playlist URI, as it appeared in the master playlist.
  *   This has not been canonicalized into an absolute URI.  This gives us a
@@ -2810,11 +3227,16 @@ shaka.hls.HlsParser = class {
  *   The maximum timestamp found in the stream.
  * @property {!Map.<number, number>} mediaSequenceToStartTime
  *   A map of media sequence numbers to media start times.
+ *   Only used for VOD content.
  * @property {boolean} canSkipSegments
- *  True if the server supports delta playlist updates, and we can send a
- *  request for a playlist that can skip older media segments.
+ *   True if the server supports delta playlist updates, and we can send a
+ *   request for a playlist that can skip older media segments.
  * @property {boolean} hasEndList
- *  True if the stream has an EXT-X-ENDLIST tag.
+ *   True if the stream has an EXT-X-ENDLIST tag.
+ * @property {number} firstSequenceNumber
+ *   The sequence number of the first reference. Only calculated if needed.
+ * @property {boolean} loadedOnce
+ *   True if the stream has been loaded at least once.
  */
 shaka.hls.HlsParser.StreamInfo;
 
@@ -2936,6 +3358,8 @@ shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
       shaka.hls.HlsParser.widevineDrmParser_,
   'com.microsoft.playready':
       shaka.hls.HlsParser.playreadyDrmParser_,
+  'identity':
+      shaka.hls.HlsParser.identityDrmParser_,
 };