shaka-player 4.10.13 → 4.11.0

package/lib/hls/hls_parser.js

@@ -24,6 +24,7 @@ goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.net.DataUriPlugin');
 goog.require('shaka.net.NetworkingEngine');
+goog.require('shaka.net.NetworkingEngine.PendingRequest');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.DrmUtils');
@@ -42,6 +43,7 @@ goog.require('shaka.util.Timer');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.util.TXml');
 goog.require('shaka.util.Platform');
+goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.Uint8ArrayUtils');
 goog.requireType('shaka.hls.Segment');
 
@@ -267,15 +269,26 @@ shaka.hls.HlsParser = class {
 
     /** @private {HTMLMediaElement} */
     this.mediaElement_ = null;
+
+    /** @private {?number} */
+    this.startTime_ = null;
+
+    /** @private {function():boolean} */
+    this.isPreloadFn_ = () => false;
   }
 
 
   /**
+   * @param {shaka.extern.ManifestConfiguration} config
+   * @param {(function():boolean)=} isPreloadFn
    * @override
    * @exportInterface
    */
-  configure(config) {
+  configure(config, isPreloadFn) {
     this.config_ = config;
+    if (isPreloadFn) {
+      this.isPreloadFn_ = isPreloadFn;
+    }
 
     if (this.contentSteeringManager_) {
       this.contentSteeringManager_.configure(this.config_);
@@ -291,7 +304,7 @@ shaka.hls.HlsParser = class {
     this.playerInterface_ = playerInterface;
     this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
 
-    const response = await this.requestManifest_([uri]);
+    const response = await this.requestManifest_([uri]).promise;
 
     // Record the master playlist URI after redirects.
     this.masterPlaylistUri_ = response.uri;
@@ -456,8 +469,8 @@ shaka.hls.HlsParser = class {
     }
     let response;
     try {
-      response =
-          await this.requestManifest_(manifestUris, /* isPlaylist= */ true);
+      response = await this.requestManifest_(
+          manifestUris, /* isPlaylist= */ true).promise;
     } catch (e) {
       if (this.playerInterface_) {
         this.playerInterface_.disableStream(streamInfo.stream);
@@ -926,9 +939,10 @@ shaka.hls.HlsParser = class {
       this.parseCodecs_(variantTags);
 
       this.parseClosedCaptions_(mediaTags);
+      const iFrameStreams = this.parseIFrames_(iFrameTags);
       variants = await this.createVariantsForTags_(
           variantTags, sessionKeyTags, mediaTags, getUris,
-          this.globalVariables_);
+          this.globalVariables_, iFrameStreams);
       textStreams = this.parseTexts_(mediaTags);
       imageStreams = await this.parseImages_(imageTags, iFrameTags);
     }
@@ -941,6 +955,8 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.OPERATION_ABORTED);
     }
 
+    this.determineStartTime_(playlist);
+
     // 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) {
@@ -975,6 +991,7 @@ shaka.hls.HlsParser = class {
       periodCount: 1,
       gapCount: 0,
       isLowLatency: false,
+      startTime: this.startTime_,
     };
 
     // If there is no 'CODECS' attribute in the manifest and codec guessing is
@@ -1045,7 +1062,7 @@ shaka.hls.HlsParser = class {
       const initType =
           shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
       const initResponse = await this.makeNetworkRequest_(
-          initSegmentRequest, requestType, {type: initType});
+          initSegmentRequest, requestType, {type: initType}).promise;
       initData = initResponse.data;
       if (initSegmentRef.aesKey) {
         initData = await shaka.media.SegmentUtils.aesDecrypt(
@@ -1064,7 +1081,7 @@ shaka.hls.HlsParser = class {
         this.config_.retryParameters);
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const response = await this.makeNetworkRequest_(
-        segmentRequest, requestType, {type});
+        segmentRequest, requestType, {type}).promise;
     let data = response.data;
     if (segment.aesKey) {
       data = await shaka.media.SegmentUtils.aesDecrypt(
@@ -1137,14 +1154,7 @@ shaka.hls.HlsParser = class {
       const PresentationType = shaka.hls.HlsParser.PresentationType_;
 
       if (this.presentationType_ == PresentationType.LIVE) {
-        let segmentAvailabilityDuration = this.getLiveDuration_();
-
-        // This defaults to the presentation delay, which has the effect of
-        // making the live stream unseekable.  This is consistent with Apple's
-        // HLS implementation.
-        if (this.config_.hls.useSafariBehaviorForLive) {
-          segmentAvailabilityDuration = this.presentationTimeline_.getDelay();
-        }
+        let segmentAvailabilityDuration = this.getLiveDuration_() || 0;
 
         // The app can override that with a longer duration, to allow seeking.
         if (!isNaN(this.config_.availabilityWindowOverride)) {
@@ -1167,7 +1177,8 @@ shaka.hls.HlsParser = class {
         if (streamInfo.type != 'audio' && streamInfo.type != 'video') {
           continue;
         }
-        const firstReference = streamInfo.stream.segmentIndex.get(0);
+        const firstReference =
+            streamInfo.stream.segmentIndex.earliestReference();
         if (firstReference && firstReference.syncTime) {
           const syncTime = firstReference.syncTime;
           this.presentationTimeline_.setInitialProgramDateTime(syncTime);
@@ -1449,7 +1460,8 @@ shaka.hls.HlsParser = class {
       }
       try {
         const streamInfo = this.createStreamInfoFromIframeTag_(tag);
-        if (streamInfo.stream.codecs !== 'mjpg') {
+        const ContentType = shaka.util.ManifestParserUtils.ContentType;
+        if (streamInfo.stream.type !== ContentType.IMAGE) {
           return null;
         }
         return streamInfo.stream;
@@ -1494,6 +1506,26 @@ shaka.hls.HlsParser = class {
     }
   }
 
+  /**
+   * @param {!Array.<!shaka.hls.Tag>} iFrameTags from the playlist.
+   * @return {!Array.<!shaka.extern.Stream>}
+   * @private
+   */
+  parseIFrames_(iFrameTags) {
+    // Create iFrame stream for each iFrame tag.
+    const iFrameStreams = iFrameTags.map((tag) => {
+      const streamInfo = this.createStreamInfoFromIframeTag_(tag);
+      const ContentType = shaka.util.ManifestParserUtils.ContentType;
+      if (streamInfo.stream.type !== ContentType.VIDEO) {
+        return null;
+      }
+      return streamInfo.stream;
+    });
+
+    // Filter mjpg iFrames
+    return iFrameStreams.filter((s) => s);
+  }
+
   /**
    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
    * @param {!Array.<!shaka.hls.Tag>} sessionKeyTags EXT-X-SESSION-KEY tags
@@ -1501,12 +1533,13 @@ shaka.hls.HlsParser = class {
    * @param {!Array.<!shaka.hls.Tag>} mediaTags EXT-X-MEDIA tags from the
    * playlist.
    * @param {function():!Array.<string>} getUris
-   * @param {?Map.<string, string>=} variables
+   * @param {?Map.<string, string>} variables
+   * @param {!Array.<!shaka.extern.Stream>} iFrameStreams
    * @return {!Promise.<!Array.<!shaka.extern.Variant>>}
    * @private
    */
   async createVariantsForTags_(tags, sessionKeyTags, mediaTags, getUris,
-      variables) {
+      variables, iFrameStreams) {
     // EXT-X-SESSION-KEY processing
     const drmInfos = [];
     const keyIds = new Set();
@@ -1529,7 +1562,8 @@ shaka.hls.HlsParser = class {
             const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
             const request = shaka.net.NetworkingEngine.makeRequest(
                 keyUris, this.config_.retryParameters);
-            const keyResponse = this.makeNetworkRequest_(request, requestType);
+            const keyResponse = this.makeNetworkRequest_(request, requestType)
+                .promise;
             this.aesKeyMap_.set(keyMapKey, keyResponse);
           }
           continue;
@@ -1615,7 +1649,8 @@ shaka.hls.HlsParser = class {
           videoRange,
           videoLayout,
           drmInfos,
-          keyIds));
+          keyIds,
+          iFrameStreams));
     }
     return allVariants.filter((variant) => variant != null);
   }
@@ -1950,12 +1985,13 @@ shaka.hls.HlsParser = class {
    * @param {?string} videoLayout
    * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
    * @param {!Set.<string>} keyIds
+   * @param {!Array.<!shaka.extern.Stream>} iFrameStreams
    * @return {!Array.<!shaka.extern.Variant>}
    * @private
    */
   createVariants_(
       audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange,
-      videoLayout, drmInfos, keyIds) {
+      videoLayout, drmInfos, keyIds, iFrameStreams) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const DrmUtils = shaka.util.DrmUtils;
 
@@ -1990,6 +2026,8 @@ shaka.hls.HlsParser = class {
         if (videoStream) {
           videoStream.drmInfos = drmInfos;
           videoStream.keyIds = keyIds;
+          shaka.util.StreamUtils.setBetterIFrameStream(
+              videoStream, iFrameStreams);
         }
         if (videoStream && !audioStream) {
           videoStream.bandwidth = bandwidth;
@@ -2226,7 +2264,7 @@ shaka.hls.HlsParser = class {
       // lazy-load in this situation.
       await streamInfo.stream.createSegmentIndex();
 
-      const reference = streamInfo.stream.segmentIndex.get(0);
+      const reference = streamInfo.stream.segmentIndex.earliestReference();
       const layout = reference.getTilesLayout();
       if (layout) {
         streamInfo.stream.width =
@@ -2257,11 +2295,15 @@ shaka.hls.HlsParser = class {
     goog.asserts.assert(tag.name == 'EXT-X-I-FRAME-STREAM-INF',
         'Should only be called on iframe tags!');
     /** @type {string} */
-    const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
+    let type = shaka.util.ManifestParserUtils.ContentType.VIDEO;
 
     const verbatimIFramePlaylistUri = tag.getRequiredAttrValue('URI');
     const codecs = tag.getAttributeValue('CODECS') || '';
 
+    if (codecs == 'mjpg') {
+      type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
+    }
+
     // Check if the stream has already been created as part of another Variant
     // and return it if it has.
     if (this.uriToStreamInfosMap_.has(verbatimIFramePlaylistUri)) {
@@ -2398,205 +2440,213 @@ shaka.hls.HlsParser = class {
       loadedOnce: false,
     };
 
-    /** @param {!AbortSignal} abortSignal */
-    const downloadSegmentIndex = async (abortSignal) => {
+    /** @param {!shaka.net.NetworkingEngine.PendingRequest} pendingRequest */
+    const downloadSegmentIndex = async (pendingRequest) => {
       const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-      const uris = streamInfo.getUris();
-      // Download the actual manifest.
-      let response;
       try {
-        response = await this.requestManifest_(
-            streamInfo.getUris(), /* isPlaylist= */ true);
-      } catch (e) {
-        stream.closeSegmentIndex();
-        const handled = this.playerInterface_.disableStream(stream);
-        if (handled) {
+        const uris = streamInfo.getUris();
+        // Download the actual manifest.
+        const response = await pendingRequest.promise;
+        if (pendingRequest.aborted) {
           return;
-        } else {
-          throw e;
         }
-      }
-      if (abortSignal.aborted) {
-        return;
-      }
 
-      // Record the final URI after redirects.
-      const responseUri = response.uri;
-      if (responseUri != response.originalUri && !uris.includes(responseUri)) {
-        redirectUris.push(responseUri);
-      }
+        // Record the final URI after redirects.
+        const responseUri = response.uri;
+        if (responseUri != response.originalUri &&
+            !uris.includes(responseUri)) {
+          redirectUris.push(responseUri);
+        }
 
-      // Record the redirected, final URI of this media playlist when we parse
-      // it.
-      /** @type {!shaka.hls.Playlist} */
-      const playlist = this.manifestTextParser_.parsePlaylist(response.data);
+        // Record the redirected, final URI of this media playlist when we parse
+        // it.
+        /** @type {!shaka.hls.Playlist} */
+        const playlist = this.manifestTextParser_.parsePlaylist(response.data);
 
-      if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
-        throw new shaka.util.Error(
-            shaka.util.Error.Severity.CRITICAL,
-            shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
-      }
+        if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
+          throw new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.MANIFEST,
+              shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
+        }
 
-      /** @type {!Array.<!shaka.hls.Tag>} */
-      const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
-          'EXT-X-DEFINE');
+        /** @type {!Array.<!shaka.hls.Tag>} */
+        const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
+            'EXT-X-DEFINE');
 
-      const mediaVariables =
-          this.parseMediaVariables_(variablesTags, responseUri);
+        const mediaVariables =
+            this.parseMediaVariables_(variablesTags, responseUri);
 
-      const mimeType = undefined;
+        const mimeType = undefined;
 
-      let requestBasicInfo = false;
+        let requestBasicInfo = false;
 
-      // If no codec info was provided in the manifest and codec guessing is
-      // disabled we try to get necessary info from the media data.
-      if ((!this.codecInfoInManifest_ &&
-          this.config_.hls.disableCodecGuessing) ||
-          (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
-          !this.config_.hls.disableClosedCaptionsDetection)) {
-        if (playlist.segments.length > 0) {
-          this.needsClosedCaptionsDetection_ = false;
-          requestBasicInfo = true;
+        // If no codec info was provided in the manifest and codec guessing is
+        // disabled we try to get necessary info from the media data.
+        if ((!this.codecInfoInManifest_ &&
+            this.config_.hls.disableCodecGuessing) ||
+            (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
+            !this.config_.hls.disableClosedCaptionsDetection)) {
+          if (playlist.segments.length > 0) {
+            this.needsClosedCaptionsDetection_ = false;
+            requestBasicInfo = true;
+          }
         }
-      }
 
-      const allowOverrideMimeType = !this.codecInfoInManifest_ &&
-        this.config_.hls.disableCodecGuessing;
+        const allowOverrideMimeType = !this.codecInfoInManifest_ &&
+          this.config_.hls.disableCodecGuessing;
 
-      const wasLive = this.isLive_();
-      const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
-          streamId, mediaVariables, playlist, getUris, responseUri, codecs,
-          type, languageValue, primary, name, channelsCount, closedCaptions,
-          characteristics, forced, sampleRate, spatialAudio, mimeType,
-          requestBasicInfo, allowOverrideMimeType);
-      if (abortSignal.aborted) {
-        return;
-      }
+        const wasLive = this.isLive_();
+        const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
+            streamId, mediaVariables, playlist, getUris, responseUri, codecs,
+            type, languageValue, primary, name, channelsCount, closedCaptions,
+            characteristics, forced, sampleRate, spatialAudio, mimeType,
+            requestBasicInfo, allowOverrideMimeType);
+        if (pendingRequest.aborted) {
+          return;
+        }
 
-      const realStream = realStreamInfo.stream;
+        const realStream = realStreamInfo.stream;
 
-      if (this.isLive_() && !wasLive) {
-        // Now that we know that the presentation is live, convert the timeline
-        // to live.
-        this.changePresentationTimelineToLive_(playlist);
-      }
+        this.determineStartTime_(playlist);
 
-      // Copy values from the real stream info to our initial one.
-      streamInfo.minTimestamp = realStreamInfo.minTimestamp;
-      streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
-      streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
-      streamInfo.canBlockReload = realStreamInfo.canBlockReload;
-      streamInfo.hasEndList = realStreamInfo.hasEndList;
-      streamInfo.mediaSequenceToStartTime =
-          realStreamInfo.mediaSequenceToStartTime;
-      streamInfo.nextMediaSequence = realStreamInfo.nextMediaSequence;
-      streamInfo.nextPart = realStreamInfo.nextPart;
-      streamInfo.loadedOnce = true;
-      stream.segmentIndex = realStream.segmentIndex;
-      stream.encrypted = realStream.encrypted;
-      stream.drmInfos = realStream.drmInfos;
-      stream.keyIds = realStream.keyIds;
-      stream.mimeType = realStream.mimeType;
-      stream.bandwidth = stream.bandwidth || realStream.bandwidth;
-      stream.codecs = stream.codecs || realStream.codecs;
-      stream.closedCaptions =
-          stream.closedCaptions || realStream.closedCaptions;
-      stream.width = stream.width || realStream.width;
-      stream.height = stream.height || realStream.height;
-      stream.hdr = stream.hdr || realStream.hdr;
-      stream.colorGamut = stream.colorGamut || realStream.colorGamut;
-      if (stream.language == 'und' && realStream.language != 'und') {
-        stream.language = realStream.language;
-      }
-      stream.language = stream.language || realStream.language;
-      stream.channelsCount = stream.channelsCount || realStream.channelsCount;
-      stream.audioSamplingRate =
-          stream.audioSamplingRate || realStream.audioSamplingRate;
-      this.setFullTypeForStream_(stream);
-
-      // 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);
-      }
-
-      let closedCaptionsUpdated = false;
-      if ((!closedCaptions && stream.closedCaptions) ||
-        (closedCaptions && stream.closedCaptions &&
-        closedCaptions.size != stream.closedCaptions.size)) {
-        closedCaptionsUpdated = true;
-      }
-
-      if (this.manifest_ && closedCaptionsUpdated) {
-        this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
-      }
-
-      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;
-            this.setFullTypeForStream_(otherStreamInfo.stream);
-          }
+        if (this.isLive_() && !wasLive) {
+          // Now that we know that the presentation is live, convert the
+          // timeline to live.
+          this.changePresentationTimelineToLive_(playlist);
         }
-      }
 
-      if (type == ContentType.TEXT) {
-        const firstSegment = realStream.segmentIndex.get(0);
-        if (firstSegment && firstSegment.initSegmentReference) {
-          stream.mimeType = 'application/mp4';
-          this.setFullTypeForStream_(stream);
+        // Copy values from the real stream info to our initial one.
+        streamInfo.minTimestamp = realStreamInfo.minTimestamp;
+        streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
+        streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
+        streamInfo.canBlockReload = realStreamInfo.canBlockReload;
+        streamInfo.hasEndList = realStreamInfo.hasEndList;
+        streamInfo.mediaSequenceToStartTime =
+            realStreamInfo.mediaSequenceToStartTime;
+        streamInfo.nextMediaSequence = realStreamInfo.nextMediaSequence;
+        streamInfo.nextPart = realStreamInfo.nextPart;
+        streamInfo.loadedOnce = true;
+        stream.segmentIndex = realStream.segmentIndex;
+        stream.encrypted = realStream.encrypted;
+        stream.drmInfos = realStream.drmInfos;
+        stream.keyIds = realStream.keyIds;
+        stream.mimeType = realStream.mimeType;
+        stream.bandwidth = stream.bandwidth || realStream.bandwidth;
+        stream.codecs = stream.codecs || realStream.codecs;
+        stream.closedCaptions =
+            stream.closedCaptions || realStream.closedCaptions;
+        stream.width = stream.width || realStream.width;
+        stream.height = stream.height || realStream.height;
+        stream.hdr = stream.hdr || realStream.hdr;
+        stream.colorGamut = stream.colorGamut || realStream.colorGamut;
+        stream.frameRate = stream.frameRate || realStream.frameRate;
+        if (stream.language == 'und' && realStream.language != 'und') {
+          stream.language = realStream.language;
+        }
+        stream.language = stream.language || realStream.language;
+        stream.channelsCount = stream.channelsCount || realStream.channelsCount;
+        stream.audioSamplingRate =
+            stream.audioSamplingRate || realStream.audioSamplingRate;
+        this.setFullTypeForStream_(stream);
+
+        // 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 qualityInfo =
-          shaka.media.QualityObserver.createQualityInfo(stream);
-      stream.segmentIndex.forEachTopLevelReference((reference) => {
-        if (reference.initSegmentReference) {
-          reference.initSegmentReference.mediaQuality = qualityInfo;
+        let closedCaptionsUpdated = false;
+        if ((!closedCaptions && stream.closedCaptions) ||
+          (closedCaptions && stream.closedCaptions &&
+          closedCaptions.size != stream.closedCaptions.size)) {
+          closedCaptionsUpdated = true;
+        }
+
+        if (this.manifest_ && closedCaptionsUpdated) {
+          this.playerInterface_.makeTextStreamsForClosedCaptions(
+              this.manifest_);
         }
-      });
 
-      // 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.getUpdatePlaylistDelay_();
-          if (delay > 0) {
-            this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+        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;
+              this.setFullTypeForStream_(otherStreamInfo.stream);
+            }
           }
-        } else {
-          // We don't need to go through the full process; just finalize this
-          // single stream.
-          this.finalizeStreams_([streamInfo]);
         }
-      }
 
-      this.processDateRangeTags_(
-          playlist.tags, stream.type, mediaVariables, getUris);
+        if (type == ContentType.TEXT) {
+          const firstSegment = realStream.segmentIndex.earliestReference();
+          if (firstSegment && firstSegment.initSegmentReference) {
+            stream.mimeType = 'application/mp4';
+            this.setFullTypeForStream_(stream);
+          }
+        }
+
+        const qualityInfo =
+            shaka.media.QualityObserver.createQualityInfo(stream);
+        stream.segmentIndex.forEachTopLevelReference((reference) => {
+          if (reference.initSegmentReference) {
+            reference.initSegmentReference.mediaQuality = qualityInfo;
+          }
+        });
+
+        // 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.getUpdatePlaylistDelay_();
+            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]);
+          }
+        }
+
+        this.processDateRangeTags_(
+            playlist.tags, stream.type, mediaVariables, getUris);
+
+        if (this.manifest_) {
+          this.manifest_.startTime = this.startTime_;
+        }
+      } catch (e) {
+        stream.closeSegmentIndex();
+        if (e.code === shaka.util.Error.Code.OPERATION_ABORTED) {
+          return;
+        }
+        const handled = this.playerInterface_.disableStream(stream);
+        if (!handled) {
+          throw e;
+        }
+      }
     };
 
     /** @type {Promise} */
     let creationPromise = null;
-    /** @type {!AbortController} */
-    let abortController = new AbortController();
+    /** @type {!shaka.net.NetworkingEngine.PendingRequest} */
+    let pendingRequest;
     const safeCreateSegmentIndex = () => {
       // An operation is already in progress.  The second and subsequent
       // callers receive the same Promise as the first caller, and only one
@@ -2605,15 +2655,16 @@ shaka.hls.HlsParser = class {
         return creationPromise;
       }
 
-      // Create a new AbortController to be able to cancel this specific
+      // Create a new PendingRequest to be able to cancel this specific
       // download.
-      abortController = new AbortController();
+      pendingRequest = this.requestManifest_(streamInfo.getUris(),
+          /* isPlaylist= */ true);
 
       // 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));
+        resolve(downloadSegmentIndex(pendingRequest));
       });
       return creationPromise;
     };
@@ -2623,7 +2674,7 @@ shaka.hls.HlsParser = class {
     stream.closeSegmentIndex = () => {
       // If we're mid-creation, cancel it.
       if (creationPromise && !stream.segmentIndex) {
-        abortController.abort();
+        pendingRequest.abort();
       }
       // If we have a segment index, release it.
       if (stream.segmentIndex) {
@@ -2781,8 +2832,20 @@ shaka.hls.HlsParser = class {
       channelsCount, closedCaptions, characteristics, forced, sampleRate,
       spatialAudio, mimeType = undefined, requestBasicInfo = true,
       allowOverrideMimeType = true) {
-    goog.asserts.assert(playlist.segments != null,
-        'Media playlist should have segments!');
+    const playlistSegments = playlist.segments || [];
+    const allAreMissing = playlistSegments.every((seg) => {
+      if (shaka.hls.Utils.getFirstTagWithName(seg.tags, 'EXT-X-GAP')) {
+        return true;
+      }
+      return false;
+    });
+
+    if (!playlistSegments.length || allAreMissing) {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.HLS_EMPTY_MEDIA_PLAYLIST);
+    }
 
     this.determinePresentationType_(playlist);
 
@@ -2800,6 +2863,7 @@ shaka.hls.HlsParser = class {
     let height = null;
     let videoRange = null;
     let colorGamut = null;
+    let frameRate = null;
     if (segments.length > 0 && requestBasicInfo) {
       const basicInfo = await this.getBasicInfoFromSegments_(segments);
 
@@ -2815,6 +2879,7 @@ shaka.hls.HlsParser = class {
       width = basicInfo.width;
       videoRange = basicInfo.videoRange;
       colorGamut = basicInfo.colorGamut;
+      frameRate = basicInfo.frameRate;
 
       if (allowOverrideMimeType) {
         mimeType = basicInfo.mimeType;
@@ -2851,8 +2916,7 @@ shaka.hls.HlsParser = class {
     if (type == shaka.util.ManifestParserUtils.ContentType.VIDEO &&
         (width || height || videoRange || colorGamut)) {
       this.addVideoAttributes_(stream, width, height,
-          /* frameRate= */ null, videoRange, /* videoLayout= */ null,
-          colorGamut);
+          frameRate, videoRange, /* videoLayout= */ null, colorGamut);
     }
 
     // This new calculation is necessary for Low Latency streams.
@@ -3202,7 +3266,8 @@ shaka.hls.HlsParser = class {
           const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
           const request = shaka.net.NetworkingEngine.makeRequest(
               keyUris, this.config_.retryParameters);
-          const keyResponse = this.makeNetworkRequest_(request, requestType);
+          const keyResponse = this.makeNetworkRequest_(request, requestType)
+              .promise;
           this.aesKeyMap_.set(keyMapKey, keyResponse);
         }
         const keyResponse = await this.aesKeyMap_.get(keyMapKey);
@@ -3230,6 +3295,24 @@ shaka.hls.HlsParser = class {
   }
 
 
+  /**
+   * @param {!shaka.hls.Playlist} playlist
+   * @private
+   */
+  determineStartTime_(playlist) {
+    // If we already have a starttime we avoid processing this again.
+    if (this.startTime_ != null) {
+      return;
+    }
+    const startTimeTag =
+        shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-START');
+    if (startTimeTag) {
+      this.startTime_ =
+          Number(startTimeTag.getRequiredAttrValue('TIME-OFFSET'));
+    }
+  }
+
+
   /**
    * @param {!shaka.hls.Playlist} playlist
    * @private
@@ -3359,7 +3442,7 @@ shaka.hls.HlsParser = class {
     // 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;
+    let presentationDelay = 0;
     if (this.config_.defaultPresentationDelay) {
       presentationDelay = this.config_.defaultPresentationDelay;
     } else if (this.lowLatencyPresentationDelay_) {
@@ -3367,12 +3450,27 @@ shaka.hls.HlsParser = class {
     } else if (this.presentationDelay_) {
       presentationDelay = this.presentationDelay_;
     } else {
-      const playlistSegments = playlist.segments.length;
+      const totalSegments = playlist.segments.length;
       let delaySegments = this.config_.hls.liveSegmentsDelay;
-      if (delaySegments > (playlistSegments - 2)) {
-        delaySegments = Math.max(1, playlistSegments - 2);
+      if (delaySegments > (totalSegments - 2)) {
+        delaySegments = Math.max(1, totalSegments - 2);
+      }
+      for (let i = totalSegments - delaySegments; i < totalSegments; i++) {
+        const extinfTag = shaka.hls.Utils.getFirstTagWithName(
+            playlist.segments[i].tags, 'EXTINF');
+        if (extinfTag) {
+          const extinfValues = extinfTag.value.split(',');
+          const duration = Number(extinfValues[0]);
+          presentationDelay += Math.ceil(duration);
+        } else {
+          presentationDelay += this.maxTargetDuration_;
+        }
       }
-      presentationDelay = this.maxTargetDuration_ * delaySegments;
+    }
+
+    if (this.startTime_ && this.startTime_ < 0) {
+      presentationDelay = Math.min(-this.startTime_, presentationDelay);
+      this.startTime_ += presentationDelay;
     }
 
     this.presentationTimeline_.setPresentationStartTime(0);
@@ -3937,7 +4035,6 @@ shaka.hls.HlsParser = class {
       // Exclude these attributes from the metadata since they already go into
       // other fields (eg: startTime or endTime) or are not necessary..
       const excludedAttributes = [
-        'ID',
         'CLASS',
         'START-DATE',
         'END-DATE',
@@ -3967,7 +4064,8 @@ shaka.hls.HlsParser = class {
         values.push(metadataFrame);
       }
 
-      if (values.length) {
+      // ID is always required. So we need more than 1 value.
+      if (values.length > 1) {
         this.playerInterface_.onMetadata(type, startTime, endTime, values);
       }
 
@@ -4021,7 +4119,8 @@ shaka.hls.HlsParser = class {
     if (firstStartTime === 0 &&
         this.presentationType_ == shaka.hls.HlsParser.PresentationType_.LIVE &&
         mediaSequenceToStartTime.size > 0 &&
-        !mediaSequenceToStartTime.has(position)) {
+        !mediaSequenceToStartTime.has(position) &&
+        this.presentationTimeline_.getPresentationStartTime() != null) {
       firstStartTime = this.presentationTimeline_.getSegmentAvailabilityStart();
     }
 
@@ -4351,7 +4450,7 @@ shaka.hls.HlsParser = class {
     try {
       headRequest.method = 'HEAD';
       const response = await this.makeNetworkRequest_(
-          headRequest, requestType, {type});
+          headRequest, requestType, {type}).promise;
 
       contentMimeType = response.headers['content-type'];
     } catch (error) {
@@ -4360,7 +4459,7 @@ shaka.hls.HlsParser = class {
          error.code == shaka.util.Error.Code.BAD_HTTP_STATUS)) {
         headRequest.method = 'GET';
         const response = await this.makeNetworkRequest_(
-            headRequest, requestType, {type});
+            headRequest, requestType, {type}).promise;
 
         contentMimeType = response.headers['content-type'];
       }
@@ -4423,7 +4522,7 @@ shaka.hls.HlsParser = class {
    *
    * @param {!Array.<string>} uris
    * @param {boolean=} isPlaylist
-   * @return {!Promise.<!shaka.extern.Response>}
+   * @return {!shaka.net.NetworkingEngine.PendingRequest}
    * @private
    */
   requestManifest_(uris, isPlaylist) {
@@ -4556,7 +4655,7 @@ shaka.hls.HlsParser = class {
    * @param {shaka.extern.Request} request
    * @param {shaka.net.NetworkingEngine.RequestType} type
    * @param {shaka.extern.RequestContext=} context
-   * @return {!Promise.<shaka.extern.Response>}
+   * @return {!shaka.net.NetworkingEngine.PendingRequest}
    * @private
    */
   makeNetworkRequest_(request, type, context) {
@@ -4567,11 +4666,15 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.OPERATION_ABORTED);
     }
 
+    if (!context) {
+      context = {};
+    }
+    context.isPreload = this.isPreloadFn_();
     const op = this.playerInterface_.networkingEngine.request(
         type, request, context);
     this.operationManager_.manage(op);
 
-    return op.promise;
+    return op;
   }
 
   /**
@@ -4769,7 +4872,8 @@ shaka.hls.HlsParser = class {
         const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
         const request = shaka.net.NetworkingEngine.makeRequest(
             keyUris, this.config_.retryParameters);
-        const keyResponse = this.makeNetworkRequest_(request, requestType);
+        const keyResponse = this.makeNetworkRequest_(request, requestType)
+            .promise;
         this.identityKeyMap_.set(keyMapKey, keyResponse);
       }
       const keyResponse = await this.identityKeyMap_.get(keyMapKey);
@@ -4801,7 +4905,7 @@ shaka.hls.HlsParser = class {
         const initType =
             shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
         const initResponse = await this.makeNetworkRequest_(
-            initSegmentRequest, requestType, {type: initType});
+            initSegmentRequest, requestType, {type: initType}).promise;
 
         defaultKID = shaka.media.SegmentUtils.getDefaultKID(
             initResponse.data);