shaka-player 4.4.3 → 4.6.0

package/lib/hls/hls_parser.js

@@ -9,6 +9,7 @@ goog.provide('shaka.hls.HlsParser');
 
 goog.require('goog.Uri');
 goog.require('goog.asserts');
+goog.require('shaka.abr.Ewma');
 goog.require('shaka.hls.ManifestTextParser');
 goog.require('shaka.hls.Playlist');
 goog.require('shaka.hls.PlaylistType');
@@ -25,18 +26,16 @@ goog.require('shaka.net.DataUriPlugin');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
+goog.require('shaka.util.ContentSteeringManager');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.FakeEvent');
-goog.require('shaka.util.Functional');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
-goog.require('shaka.util.Mp4BoxParsers');
-goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.Pssh');
+goog.require('shaka.media.SegmentUtils');
 goog.require('shaka.util.Timer');
-goog.require('shaka.util.TsParser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.Uint8ArrayUtils');
 goog.require('shaka.util.XmlUtils');
@@ -111,8 +110,8 @@ shaka.hls.HlsParser = class {
      * timestamps, offsets, and to handle TS rollover.
      *
      * During parsing, used to avoid duplicates in the async methods
-     * createStreamInfoFromMediaTag_, createStreamInfoFromImageTag_ and
-     * createStreamInfoFromVariantTag_.
+     * createStreamInfoFromMediaTags_, createStreamInfoFromImageTag_ and
+     * createStreamInfoFromVariantTags_.
      *
      * @private {!Map.<string, shaka.hls.HlsParser.StreamInfo>}
      */
@@ -156,6 +155,13 @@ shaka.hls.HlsParser = class {
      */
     this.streamsFinalized_ = false;
 
+    /**
+     * Whether the manifest informs about the codec to use.
+     *
+     * @private
+     */
+    this.codecInfoInManifest_ = false;
+
     /**
      * This timer is used to trigger the start of a manifest update. A manifest
      * update is async. Once the update is finished, the timer will be restarted
@@ -215,6 +221,16 @@ shaka.hls.HlsParser = class {
 
     /** @private {boolean} */
     this.lowLatencyByterangeOptimization_ = false;
+
+    /**
+     * An ewma that tracks how long updates take.
+     * This is to mitigate issues caused by slow parsing on embedded devices.
+     * @private {!shaka.abr.Ewma}
+     */
+    this.averageUpdateDuration_ = new shaka.abr.Ewma(5);
+
+    /** @private {?shaka.util.ContentSteeringManager} */
+    this.contentSteeringManager_ = null;
   }
 
 
@@ -224,6 +240,10 @@ shaka.hls.HlsParser = class {
    */
   configure(config) {
     this.config_ = config;
+
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.configure(this.config_);
+    }
   }
 
   /**
@@ -235,7 +255,7 @@ shaka.hls.HlsParser = class {
     this.playerInterface_ = playerInterface;
     this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
 
-    const response = await this.requestManifest_(uri);
+    const response = await this.requestManifest_([uri]);
 
     // Record the master playlist URI after redirects.
     this.masterPlaylistUri_ = response.uri;
@@ -276,6 +296,10 @@ shaka.hls.HlsParser = class {
     this.groupIdToCodecsMap_.clear();
     this.globalVariables_.clear();
 
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.destroy();
+    }
+
     return Promise.all(pending);
   }
 
@@ -346,40 +370,42 @@ shaka.hls.HlsParser = class {
    * @private
    */
   async updateStream_(streamInfo) {
-    const manifestUri = streamInfo.absoluteMediaPlaylistUri;
-    const uriObj = new goog.Uri(manifestUri);
-    const queryData = new goog.Uri.QueryData();
-    if (streamInfo.canBlockReload) {
-      if (streamInfo.nextMediaSequence >= 0) {
-        // Indicates that the server must hold the request until a Playlist
-        // contains a Media Segment with Media Sequence
-        queryData.add('_HLS_msn', String(streamInfo.nextMediaSequence));
+    const manifestUris = [];
+    for (const uri of streamInfo.getUris()) {
+      const uriObj = new goog.Uri(uri);
+      const queryData = uriObj.getQueryData();
+      if (streamInfo.canBlockReload) {
+        if (streamInfo.nextMediaSequence >= 0) {
+          // Indicates that the server must hold the request until a Playlist
+          // contains a Media Segment with Media Sequence
+          queryData.add('_HLS_msn', String(streamInfo.nextMediaSequence));
+        }
+        if (streamInfo.nextPart >= 0) {
+          // Indicates, in combination with _HLS_msn, that the server must hold
+          // the request until a Playlist contains Partial Segment N of Media
+          // Sequence Number M or later.
+          queryData.add('_HLS_part', String(streamInfo.nextPart));
+        }
       }
-      if (streamInfo.nextPart >= 0) {
-        // Indicates, in combination with _HLS_msn, that the server must hold
-        // the request until a Playlist contains Partial Segment N of Media
-        // Sequence Number M or later.
-        queryData.add('_HLS_part', String(streamInfo.nextPart));
+      if (streamInfo.canSkipSegments) {
+        // Enable delta updates. This will replace older segments with
+        // 'EXT-X-SKIP' tag in the media playlist.
+        queryData.add('_HLS_skip', 'YES');
       }
-    }
-    if (streamInfo.canSkipSegments) {
-      // Enable delta updates. This will replace older segments with
-      // 'EXT-X-SKIP' tag in the media playlist.
-      queryData.add('_HLS_skip', 'YES');
-    }
-    if (queryData.getCount()) {
-      uriObj.setQueryData(queryData);
+      if (queryData.getCount()) {
+        uriObj.setQueryData(queryData);
+      }
+      manifestUris.push(uriObj.toString());
     }
     const response =
-        await this.requestManifest_(uriObj.toString(), /* isPlaylist= */ true);
+        await this.requestManifest_(manifestUris, /* isPlaylist= */ true);
     if (!streamInfo.stream.segmentIndex) {
       // The stream was closed since the update was first requested.
       return;
     }
 
     /** @type {shaka.hls.Playlist} */
-    const playlist = this.manifestTextParser_.parsePlaylist(
-        response.data, response.uri);
+    const playlist = this.manifestTextParser_.parsePlaylist(response.data);
 
     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
       throw new shaka.util.Error(
@@ -388,11 +414,19 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
     }
 
+    // Record the final URI after redirects.
+    const responseUri = response.uri;
+    if (responseUri != response.originalUri &&
+        !streamInfo.getUris().includes(responseUri)) {
+      streamInfo.redirectUris.push(responseUri);
+    }
+
     /** @type {!Array.<!shaka.hls.Tag>} */
     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
         'EXT-X-DEFINE');
 
-    const mediaVariables = this.parseMediaVariables_(variablesTags);
+    const mediaVariables = this.parseMediaVariables_(
+        variablesTags, responseUri);
 
     const stream = streamInfo.stream;
 
@@ -410,8 +444,8 @@ shaka.hls.HlsParser = class {
     }
 
     const {segments, bandwidth} = this.createSegments_(
-        streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
-        stream.mimeType, mediaSequenceToStartTime, mediaVariables);
+        playlist, stream, mediaSequenceToStartTime, mediaVariables,
+        streamInfo.getUris);
 
     stream.bandwidth = bandwidth;
 
@@ -466,6 +500,24 @@ shaka.hls.HlsParser = class {
     // No-op
   }
 
+  /**
+   * @override
+   * @exportInterface
+   */
+  onInitialVariantChosen(variant) {
+    // No-op
+  }
+
+  /**
+   * @override
+   * @exportInterface
+   */
+  banLocation(uri) {
+    if (this.contentSteeringManager_) {
+      this.contentSteeringManager_.banLocation(uri);
+    }
+  }
+
   /**
    * Align the streams by sequence number by dropping early segments.  Then
    * offset the streams to begin at presentation time 0.
@@ -591,7 +643,7 @@ shaka.hls.HlsParser = class {
         const segment0 = segmentIndex.earliestReference();
         if (segment0.syncTime == null) {
           shaka.log.alwaysError('Missing EXT-X-PROGRAM-DATE-TIME for stream',
-              streamInfo.verbatimMediaPlaylistUri,
+              streamInfo.getUris(),
               'Expect AV sync issues!');
         } else {
           // Stream metadata are offset by a fixed amount based on the
@@ -632,7 +684,7 @@ shaka.hls.HlsParser = class {
     }
 
     shaka.log.debug('Offset', offset, 'applied to',
-        streamInfo.verbatimMediaPlaylistUri);
+        streamInfo.getUris());
   }
 
   /**
@@ -649,14 +701,11 @@ shaka.hls.HlsParser = class {
     goog.asserts.assert(this.masterPlaylistUri_,
         'Master playlist URI must be set before calling parseManifest_!');
 
-    const playlist = this.manifestTextParser_.parsePlaylist(
-        data, this.masterPlaylistUri_);
+    const playlist = this.manifestTextParser_.parsePlaylist(data);
 
     /** @type {!Array.<!shaka.hls.Tag>} */
     const variablesTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-DEFINE');
 
-    this.parseMasterVariables_(variablesTags);
-
     /** @type {!Array.<!shaka.extern.Variant>} */
     let variants = [];
     /** @type {!Array.<!shaka.extern.Stream>} */
@@ -666,9 +715,14 @@ shaka.hls.HlsParser = class {
 
     // Parsing a media playlist results in a single-variant stream.
     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
+      const getUris = () => {
+        return [uri];
+      };
+
       // Get necessary info for this stream. These are things we would normally
       // find from the master playlist (e.g. from values on EXT-X-MEDIA tags).
-      const basicInfo = await this.getMediaPlaylistBasicInfo_(playlist);
+      const basicInfo =
+          await this.getMediaPlaylistBasicInfo_(playlist, getUris);
       const type = basicInfo.type;
       const mimeType = basicInfo.mimeType;
       const codecs = basicInfo.codecs;
@@ -677,6 +731,7 @@ shaka.hls.HlsParser = class {
       const width = basicInfo.width;
       const channelsCount = basicInfo.channelCount;
       const sampleRate = basicInfo.sampleRate;
+      const closedCaptions = basicInfo.closedCaptions;
 
       // Some values we cannot figure out, and aren't important enough to ask
       // the user to provide through config values. A lot of these are only
@@ -684,21 +739,21 @@ shaka.hls.HlsParser = class {
       // So these unknowns should be set to false or null, largely.
       const spatialAudio = false;
       const characteristics = null;
-      const closedCaptions = new Map();
       const forced = false; // Only relevant for text.
       const primary = true; // This is the only stream!
       const name = 'Media Playlist';
 
       // Make the stream info, with those values.
       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
-          playlist, uri, uri, codecs, type, languageValue, primary, name,
-          channelsCount, closedCaptions, characteristics, forced, sampleRate,
-          spatialAudio, mimeType);
+          this.globalId_++, playlist, getUris, uri, codecs, type,
+          languageValue, primary, name, channelsCount, closedCaptions,
+          characteristics, forced, sampleRate, spatialAudio, mimeType);
       this.uriToStreamInfosMap_.set(uri, streamInfo);
 
       if (type == 'video') {
         this.addVideoAttributes_(streamInfo.stream, width, height,
-            /* frameRate= */ null, /* videoRange= */ null);
+            /* frameRate= */ null, /* videoRange= */ null,
+            /* videoLayout= */ null);
       }
 
       // Wrap the stream from that stream info with a variant.
@@ -715,8 +770,11 @@ shaka.hls.HlsParser = class {
         decodingInfos: [],
       });
     } else {
+      this.parseMasterVariables_(variablesTags);
+
       /** @type {!Array.<!shaka.hls.Tag>} */
-      const mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
+      const mediaTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-MEDIA');
       /** @type {!Array.<!shaka.hls.Tag>} */
       const variantTags = Utils.filterTagsByName(
           playlist.tags, 'EXT-X-STREAM-INF');
@@ -724,43 +782,28 @@ shaka.hls.HlsParser = class {
       const imageTags = Utils.filterTagsByName(
           playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
       /** @type {!Array.<!shaka.hls.Tag>} */
+      const iFrameTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-I-FRAME-STREAM-INF');
+      /** @type {!Array.<!shaka.hls.Tag>} */
       const sessionKeyTags = Utils.filterTagsByName(
           playlist.tags, 'EXT-X-SESSION-KEY');
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const sessionDataTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-SESSION-DATA');
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const contentSteeringTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-CONTENT-STEERING');
 
-      this.parseCodecs_(variantTags);
+      this.processSessionData_(sessionDataTags);
+      await this.processContentSteering_(contentSteeringTags);
 
-      /** @type {!Array.<!shaka.hls.Tag>} */
-      const sesionDataTags =
-          Utils.filterTagsByName(playlist.tags, 'EXT-X-SESSION-DATA');
-      for (const tag of sesionDataTags) {
-        const id = tag.getAttributeValue('DATA-ID');
-        const uri = tag.getAttributeValue('URI');
-        const language = tag.getAttributeValue('LANGUAGE');
-        const value = tag.getAttributeValue('VALUE');
-        const data = (new Map()).set('id', id);
-        if (uri) {
-          data.set('uri', shaka.hls.Utils.constructAbsoluteUri(
-              this.masterPlaylistUri_, uri));
-        }
-        if (language) {
-          data.set('language', language);
-        }
-        if (value) {
-          data.set('value', value);
-        }
-        const event = new shaka.util.FakeEvent('sessiondata', data);
-        if (this.playerInterface_) {
-          this.playerInterface_.onEvent(event);
-        }
-      }
+      this.parseCodecs_(variantTags);
 
-      // Parse audio and video media tags first, so that we can extract segment
-      // start time from audio/video streams and reuse for text streams.
-      this.createStreamInfosFromMediaTags_(mediaTags);
       this.parseClosedCaptions_(mediaTags);
-      variants = this.createVariantsForTags_(variantTags, sessionKeyTags);
+      variants =
+          this.createVariantsForTags_(variantTags, sessionKeyTags, mediaTags);
       textStreams = this.parseTexts_(mediaTags);
-      imageStreams = await this.parseImages_(imageTags);
+      imageStreams = await this.parseImages_(imageTags, iFrameTags);
     }
 
     // Make sure that the parser has not been destroyed.
@@ -809,64 +852,72 @@ shaka.hls.HlsParser = class {
       type: shaka.media.ManifestParser.HLS,
       serviceDescription: null,
     };
+
+    // If there is no 'CODECS' attribute in the manifest and codec guessing is
+    // disabled, we need to create the segment indexes now so that missing info
+    // can be parsed from the media data and added to the stream objects.
+    if (!this.codecInfoInManifest_ && this.config_.hls.disableCodecGuessing) {
+      const createIndexes = [];
+      for (const variant of this.manifest_.variants) {
+        if (variant.audio && variant.audio.codecs === '') {
+          createIndexes.push(variant.audio.createSegmentIndex());
+        }
+        if (variant.video && variant.video.codecs === '') {
+          createIndexes.push(variant.video.createSegmentIndex());
+        }
+      }
+
+      await Promise.all(createIndexes);
+    }
+
     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
   }
 
   /**
    * @param {shaka.hls.Playlist} playlist
-   * @return {!Promise.<shaka.hls.HlsParser.BasicInfo>}
+   * @param {function():!Array.<string>} getUris
+   * @return {!Promise.<shaka.media.SegmentUtils.BasicInfo>}
    * @private
    */
-  async getMediaPlaylistBasicInfo_(playlist) {
+  async getMediaPlaylistBasicInfo_(playlist, getUris) {
     const HlsParser = shaka.hls.HlsParser;
-    const defaultFullMimeType = this.config_.hls.mediaPlaylistFullMimeType;
-    const defaultMimeType =
-        shaka.util.MimeUtils.getBasicType(defaultFullMimeType);
-    const defaultType = defaultMimeType.split('/')[0];
-    const defaultCodecs = shaka.util.MimeUtils.getCodecs(defaultFullMimeType);
-    const defaultBasicInfo = {
-      type: defaultType,
-      mimeType: defaultMimeType,
-      codecs: defaultCodecs,
-      language: null,
-      height: null,
-      width: null,
-      channelCount: null,
-      sampleRate: null,
-    };
+    const defaultBasicInfo = shaka.media.SegmentUtils.getBasicInfoFromMimeType(
+        this.config_.hls.mediaPlaylistFullMimeType);
     if (!playlist.segments.length) {
       return defaultBasicInfo;
     }
-    const firstSegment = playlist.segments[0];
-    const parsedUri = new goog.Uri(firstSegment.absoluteUri);
+    const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
+    const middleSegment = playlist.segments[middleSegmentIdx];
+    const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
+        getUris(),
+        playlist.segments[0].verbatimSegmentUri);
+    const middleSegmentUri = middleSegmentUris[0];
+    const parsedUri = new goog.Uri(middleSegmentUri);
     const extension = parsedUri.getPath().split('.').pop();
     const rawMimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
     if (rawMimeType) {
-      return {
-        type: 'audio',
-        mimeType: rawMimeType,
-        codecs: '',
-        language: null,
-        height: null,
-        width: null,
-        channelCount: null,
-        sampleRate: null,
-      };
+      return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
+          rawMimeType);
     }
 
-    let segmentUris = [firstSegment.absoluteUri];
+    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
+
+    let initData = null;
     const initSegmentRef = this.getInitSegmentReference_(
-        playlist, firstSegment.tags, new Map());
+        playlist, middleSegment.tags, getUris);
     if (initSegmentRef) {
-      segmentUris = initSegmentRef.getUris();
+      const initSegmentRequest = shaka.net.NetworkingEngine.makeRequest(
+          initSegmentRef.getUris(), this.config_.retryParameters);
+      const initType =
+          shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
+      const initResponse = await this.makeNetworkRequest_(
+          initSegmentRequest, requestType, {type: initType});
+      initData = initResponse.data;
     }
 
-    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
     const segmentRequest = shaka.net.NetworkingEngine.makeRequest(
-        segmentUris, this.config_.retryParameters);
-    const type = initSegmentRef ?
-        shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT :
-        shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
+        middleSegmentUris, this.config_.retryParameters);
+    const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const response = await this.makeNetworkRequest_(
         segmentRequest, requestType, {type});
 
@@ -877,13 +928,16 @@ shaka.hls.HlsParser = class {
     }
 
     if (extension == 'ts' || contentMimeType == 'video/mp2t') {
-      const basicInfo = this.getBasicInfoFromTs_(response);
+      const basicInfo =
+          shaka.media.SegmentUtils.getBasicInfoFromTs(response.data);
       if (basicInfo) {
         return basicInfo;
       }
-    } else if (extension == 'mp4' ||
-        contentMimeType == 'video/mp4' || contentMimeType == 'audio/mp4') {
-      const basicInfo = this.getBasicInfoFromMp4_(response);
+    } else if (extension == 'mp4' || extension == 'cmfv' ||
+        contentMimeType == 'video/mp4' || contentMimeType == 'audio/mp4' ||
+        contentMimeType == 'video/iso.segment') {
+      const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromMp4(
+          initData, response.data);
       if (basicInfo) {
         return basicInfo;
       }
@@ -891,232 +945,6 @@ shaka.hls.HlsParser = class {
     return defaultBasicInfo;
   }
 
-  /**
-   * @param {shaka.extern.Response} response
-   * @return {?shaka.hls.HlsParser.BasicInfo}
-   * @private
-   */
-  getBasicInfoFromTs_(response) {
-    const uint8ArrayData = shaka.util.BufferUtils.toUint8(response.data);
-    const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
-    const tsCodecs = tsParser.getCodecs();
-    const videoInfo = tsParser.getVideoInfo();
-    const codecs = [];
-    let hasAudio = false;
-    let hasVideo = false;
-    switch (tsCodecs.audio) {
-      case 'aac':
-        codecs.push('mp4a.40.2');
-        hasAudio = true;
-        break;
-      case 'mp3':
-        codecs.push('mp4a.40.34');
-        hasAudio = true;
-        break;
-      case 'ac3':
-        codecs.push('ac-3');
-        hasAudio = true;
-        break;
-      case 'ec3':
-        codecs.push('ec-3');
-        hasAudio = true;
-        break;
-    }
-    switch (tsCodecs.video) {
-      case 'avc':
-        if (videoInfo.codec) {
-          codecs.push(videoInfo.codec);
-        } else {
-          codecs.push('avc1.42E01E');
-        }
-        hasVideo = true;
-        break;
-      case 'hvc':
-        codecs.push('hvc1.1.6.L93.90');
-        hasVideo = true;
-        break;
-    }
-    if (!codecs.length) {
-      return null;
-    }
-    const onlyAudio = hasAudio && !hasVideo;
-    return {
-      type: onlyAudio ? 'audio' : 'video',
-      mimeType: 'video/mp2t',
-      codecs: codecs.join(', '),
-      language: null,
-      height: videoInfo.height,
-      width: videoInfo.width,
-      channelCount: null,
-      sampleRate: null,
-    };
-  }
-
-  /**
-   * @param {shaka.extern.Response} response
-   * @return {?shaka.hls.HlsParser.BasicInfo}
-   * @private
-   */
-  getBasicInfoFromMp4_(response) {
-    const Mp4Parser = shaka.util.Mp4Parser;
-
-    const codecs = [];
-
-    let hasAudio = false;
-    let hasVideo = false;
-
-    const addCodec = (codec) => {
-      const codecLC = codec.toLowerCase();
-      switch (codecLC) {
-        case 'avc1':
-        case 'avc3':
-          codecs.push(codecLC + '.42E01E');
-          hasVideo = true;
-          break;
-        case 'hev1':
-        case 'hvc1':
-          codecs.push(codecLC + '.1.6.L93.90');
-          hasVideo = true;
-          break;
-        case 'dvh1':
-        case 'dvhe':
-          codecs.push(codecLC + '.05.04');
-          hasVideo = true;
-          break;
-        case 'vp09':
-          codecs.push(codecLC + '.00.10.08');
-          hasVideo = true;
-          break;
-        case 'av01':
-          codecs.push(codecLC + '.0.01M.08');
-          hasVideo = true;
-          break;
-        case 'mp4a':
-          // We assume AAC, but this can be wrong since mp4a supports
-          // others codecs
-          codecs.push('mp4a.40.2');
-          hasAudio = true;
-          break;
-        case 'ac-3':
-        case 'ec-3':
-        case 'opus':
-        case 'flac':
-          codecs.push(codecLC);
-          hasAudio = true;
-          break;
-      }
-    };
-
-    const codecBoxParser = (box) => addCodec(box.name);
-
-    /** @type {?string} */
-    let language = null;
-    /** @type {?string} */
-    let height = null;
-    /** @type {?string} */
-    let width = null;
-    /** @type {?number} */
-    let channelCount = null;
-    /** @type {?number} */
-    let sampleRate = null;
-
-    new Mp4Parser()
-        .box('moov', Mp4Parser.children)
-        .box('trak', Mp4Parser.children)
-        .fullBox('tkhd', (box) => {
-          goog.asserts.assert(
-              box.version != null,
-              'TKHD is a full box and should have a valid version.');
-          const parsedTKHDBox = shaka.util.Mp4BoxParsers.parseTKHD(
-              box.reader, box.version);
-          height = String(parsedTKHDBox.height);
-          width = String(parsedTKHDBox.width);
-        })
-        .box('mdia', Mp4Parser.children)
-        .fullBox('mdhd', (box) => {
-          goog.asserts.assert(
-              box.version != null,
-              'MDHD is a full box and should have a valid version.');
-          const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
-              box.reader, box.version);
-          language = parsedMDHDBox.language;
-        })
-        .box('minf', Mp4Parser.children)
-        .box('stbl', Mp4Parser.children)
-        .fullBox('stsd', Mp4Parser.sampleDescription)
-
-        // AUDIO
-        // These are the various boxes that signal a codec.
-        .box('mp4a', (box) => {
-          const parsedMP4ABox = shaka.util.Mp4BoxParsers.parseMP4A(box.reader);
-          channelCount = parsedMP4ABox.channelCount;
-          sampleRate = parsedMP4ABox.sampleRate;
-          if (box.reader.hasMoreData()) {
-            Mp4Parser.children(box);
-          } else {
-            codecBoxParser(box);
-          }
-        })
-        .box('esds', (box) => {
-          const parsedESDSBox = shaka.util.Mp4BoxParsers.parseESDS(box.reader);
-          codecs.push(parsedESDSBox.codec);
-          hasAudio = true;
-        })
-        .box('ac-3', codecBoxParser)
-        .box('ec-3', codecBoxParser)
-        .box('opus', codecBoxParser)
-        .box('Opus', codecBoxParser)
-        .box('fLaC', codecBoxParser)
-
-        // VIDEO
-        // These are the various boxes that signal a codec.
-        .box('avc1', (box) => {
-          const parsedAVCBox =
-              shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
-          codecs.push(parsedAVCBox.codec);
-          hasVideo = true;
-        })
-        .box('avc3', (box) => {
-          const parsedAVCBox =
-              shaka.util.Mp4BoxParsers.parseAVC(box.reader, box.name);
-          codecs.push(parsedAVCBox.codec);
-          hasVideo = true;
-        })
-        .box('hev1', codecBoxParser)
-        .box('hvc1', codecBoxParser)
-        .box('dvh1', codecBoxParser)
-        .box('dvhe', codecBoxParser)
-        .box('vp09', codecBoxParser)
-        .box('av01', codecBoxParser)
-
-        // This signals an encrypted sample, which we can go inside of to
-        // find the codec used.
-        // Note: If encrypted, you can only have audio or video, not both.
-        .box('enca', Mp4Parser.visualSampleEntry)
-        .box('encv', Mp4Parser.visualSampleEntry)
-        .box('sinf', Mp4Parser.children)
-        .box('frma', (box) => {
-          const {codec} = shaka.util.Mp4BoxParsers.parseFRMA(box.reader);
-          addCodec(codec);
-        })
-
-        .parse(response.data, /* partialOkay= */ true);
-    if (!codecs.length) {
-      return null;
-    }
-    const onlyAudio = hasAudio && !hasVideo;
-    return {
-      type: onlyAudio ? 'audio' : 'video',
-      mimeType: onlyAudio ? 'audio/mp4' : 'video/mp4',
-      codecs: this.filterDuplicateCodecs_(codecs).join(', '),
-      language: language,
-      height: height,
-      width: width,
-      channelCount: channelCount,
-      sampleRate: sampleRate,
-    };
-  }
-
   /** @private */
   determineDuration_() {
     goog.asserts.assert(this.presentationTimeline_,
@@ -1171,31 +999,50 @@ shaka.hls.HlsParser = class {
    * @private
    */
   parseMasterVariables_(tags) {
+    const queryParams = new goog.Uri(this.masterPlaylistUri_).getQueryData();
     for (const variableTag of tags) {
       const name = variableTag.getAttributeValue('NAME');
       const value = variableTag.getAttributeValue('VALUE');
+      const queryParam = variableTag.getAttributeValue('QUERYPARAM');
       if (name && value) {
         if (!this.globalVariables_.has(name)) {
           this.globalVariables_.set(name, value);
         }
       }
+      if (queryParam) {
+        const queryParamValue = queryParams.get(queryParam)[0];
+        if (queryParamValue && !this.globalVariables_.has(queryParamValue)) {
+          this.globalVariables_.set(queryParam, queryParamValue);
+        }
+      }
     }
   }
 
   /**
    * Get the variables of each variant tag, and store in a map.
    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
+   * @param {string} uri Media playlist URI.
    * @return {!Map.<string, string>}
    * @private
    */
-  parseMediaVariables_(tags) {
+  parseMediaVariables_(tags, uri) {
+    const queryParams = new goog.Uri(uri).getQueryData();
     const mediaVariables = new Map();
     for (const variableTag of tags) {
       const name = variableTag.getAttributeValue('NAME');
       const value = variableTag.getAttributeValue('VALUE');
+      const queryParam = variableTag.getAttributeValue('QUERYPARAM');
       const mediaImport = variableTag.getAttributeValue('IMPORT');
       if (name && value) {
-        mediaVariables.set(name, value);
+        if (!mediaVariables.has(name)) {
+          mediaVariables.set(name, value);
+        }
+      }
+      if (queryParam) {
+        const queryParamValue = queryParams.get(queryParam)[0];
+        if (queryParamValue && !mediaVariables.has(queryParamValue)) {
+          mediaVariables.set(queryParam, queryParamValue);
+        }
       }
       if (mediaImport) {
         const globalValue = this.globalVariables_.get(mediaImport);
@@ -1248,6 +1095,68 @@ shaka.hls.HlsParser = class {
     }
   }
 
+  /**
+   * Process EXT-X-SESSION-DATA tags.
+   *
+   * @param {!Array.<!shaka.hls.Tag>} tags
+   * @private
+   */
+  processSessionData_(tags) {
+    for (const tag of tags) {
+      const id = tag.getAttributeValue('DATA-ID');
+      const uri = tag.getAttributeValue('URI');
+      const language = tag.getAttributeValue('LANGUAGE');
+      const value = tag.getAttributeValue('VALUE');
+      const data = (new Map()).set('id', id);
+      if (uri) {
+        data.set('uri', shaka.hls.Utils.constructSegmentUris(
+            [this.masterPlaylistUri_], uri, this.globalVariables_)[0]);
+      }
+      if (language) {
+        data.set('language', language);
+      }
+      if (value) {
+        data.set('value', value);
+      }
+      const event = new shaka.util.FakeEvent('sessiondata', data);
+      if (this.playerInterface_) {
+        this.playerInterface_.onEvent(event);
+      }
+    }
+  }
+
+  /**
+   * Process EXT-X-CONTENT-STEERING tags.
+   *
+   * @param {!Array.<!shaka.hls.Tag>} tags
+   * @return {!Promise}
+   * @private
+   */
+  async processContentSteering_(tags) {
+    if (!this.playerInterface_ || !this.config_) {
+      return;
+    }
+    let contentSteeringPromise;
+    for (const tag of tags) {
+      const defaultPathwayId = tag.getAttributeValue('PATHWAY-ID');
+      const uri = tag.getAttributeValue('SERVER-URI');
+      if (!defaultPathwayId || !uri) {
+        continue;
+      }
+      this.contentSteeringManager_ =
+            new shaka.util.ContentSteeringManager(this.playerInterface_);
+      this.contentSteeringManager_.configure(this.config_);
+      this.contentSteeringManager_.setBaseUris([this.masterPlaylistUri_]);
+      this.contentSteeringManager_.setManifestType(
+          shaka.media.ManifestParser.HLS);
+      this.contentSteeringManager_.setDefaultPathwayId(defaultPathwayId);
+      contentSteeringPromise =
+          this.contentSteeringManager_.requestInfo(uri);
+      break;
+    }
+    await contentSteeringPromise;
+  }
+
   /**
    * Parse Subtitles and Closed Captions from 'EXT-X-MEDIA' tags.
    * Create text streams for Subtitles, but not Closed Captions.
@@ -1266,7 +1175,7 @@ shaka.hls.HlsParser = class {
         return null;
       }
       try {
-        return this.createStreamInfoFromMediaTag_(tag).stream;
+        return this.createStreamInfoFromMediaTags_([tag], new Map()).stream;
       } catch (e) {
         if (this.config_.hls.ignoreTextStreamFailures) {
           return null;
@@ -1300,10 +1209,11 @@ shaka.hls.HlsParser = class {
 
   /**
    * @param {!Array.<!shaka.hls.Tag>} imageTags from the playlist.
+   * @param {!Array.<!shaka.hls.Tag>} iFrameTags from the playlist.
    * @return {!Promise.<!Array.<!shaka.extern.Stream>>}
    * @private
    */
-  async parseImages_(imageTags) {
+  async parseImages_(imageTags, iFrameTags) {
     // Create image stream for each image tag.
     const imageStreamPromises = imageTags.map(async (tag) => {
       const disableThumbnails = this.config_.disableThumbnails;
@@ -1319,16 +1229,34 @@ shaka.hls.HlsParser = class {
         }
         throw e;
       }
-    });
+    }).concat(iFrameTags.map((tag) => {
+      const disableThumbnails = this.config_.disableThumbnails;
+      if (disableThumbnails) {
+        return null;
+      }
+      try {
+        const streamInfo = this.createStreamInfoFromIframeTag_(tag);
+        if (streamInfo.stream.codecs !== 'mjpg') {
+          return null;
+        }
+        return streamInfo.stream;
+      } catch (e) {
+        if (this.config_.hls.ignoreImageStreamFailures) {
+          return null;
+        }
+        throw e;
+      }
+    }));
     const imageStreams = await Promise.all(imageStreamPromises);
     return imageStreams.filter((s) => s);
   }
 
   /**
    * @param {!Array.<!shaka.hls.Tag>} mediaTags Media tags from the playlist.
+   * @param {!Map.<string, string>} groupIdPathwayIdMapping
    * @private
    */
-  createStreamInfosFromMediaTags_(mediaTags) {
+  createStreamInfosFromMediaTags_(mediaTags, groupIdPathwayIdMapping) {
     // Filter out subtitles and  media tags without uri.
     mediaTags = mediaTags.filter((tag) => {
       const uri = tag.getAttributeValue('URI') || '';
@@ -1336,9 +1264,20 @@ shaka.hls.HlsParser = class {
       return type != 'SUBTITLES' && uri != '';
     });
 
-    // Create stream info for each audio / video media tag.
+    const groupedTags = {};
     for (const tag of mediaTags) {
-      this.createStreamInfoFromMediaTag_(tag);
+      const key = tag.getTagKey();
+      if (!groupedTags[key]) {
+        groupedTags[key] = [tag];
+      } else {
+        groupedTags[key].push(tag);
+      }
+    }
+
+    for (const key in groupedTags) {
+      // Create stream info for each audio / video media grouped tag.
+      this.createStreamInfoFromMediaTags_(
+          groupedTags[key], groupIdPathwayIdMapping);
     }
   }
 
@@ -1346,10 +1285,12 @@ shaka.hls.HlsParser = class {
    * @param {!Array.<!shaka.hls.Tag>} tags Variant tags from the playlist.
    * @param {!Array.<!shaka.hls.Tag>} sessionKeyTags EXT-X-SESSION-KEY tags
    * from the playlist.
+   * @param {!Array.<!shaka.hls.Tag>} mediaTags EXT-X-MEDIA tags from the
+   * playlist.
    * @return {!Array.<!shaka.extern.Variant>}
    * @private
    */
-  createVariantsForTags_(tags, sessionKeyTags) {
+  createVariantsForTags_(tags, sessionKeyTags, mediaTags) {
     // EXT-X-SESSION-KEY processing
     const drmInfos = [];
     const keyIds = new Set();
@@ -1381,24 +1322,54 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    // Create variants for each variant tag.
-    const allVariants = tags.map((tag) => {
-      const frameRate = tag.getAttributeValue('FRAME-RATE');
-      const bandwidth = Number(tag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
-        Number(tag.getRequiredAttrValue('BANDWIDTH'));
+    const groupedTags = {};
+    for (const tag of tags) {
+      const key = tag.getTagKey();
+      if (!groupedTags[key]) {
+        groupedTags[key] = [tag];
+      } else {
+        groupedTags[key].push(tag);
+      }
+    }
 
-      const resolution = tag.getAttributeValue('RESOLUTION');
+    const allVariants = [];
+    // Create variants for each group of variant tag.
+    for (const key in groupedTags) {
+      const tags = groupedTags[key];
+      const firstTag = tags[0];
+
+      const frameRate = firstTag.getAttributeValue('FRAME-RATE');
+      const bandwidth =
+          Number(firstTag.getAttributeValue('AVERAGE-BANDWIDTH')) ||
+          Number(firstTag.getRequiredAttrValue('BANDWIDTH'));
+
+      const resolution = firstTag.getAttributeValue('RESOLUTION');
       const [width, height] = resolution ? resolution.split('x') : [null, null];
 
-      const videoRange = tag.getAttributeValue('VIDEO-RANGE');
+      const videoRange = firstTag.getAttributeValue('VIDEO-RANGE');
 
-      const streamInfos = this.createStreamInfosForVariantTag_(tag,
-          resolution, frameRate);
+      let videoLayout = firstTag.getAttributeValue('REQ-VIDEO-LAYOUT');
+      if (videoLayout && videoLayout.includes(',')) {
+        // If multiple video layout strings are present, pick the first valid
+        // one.
+        const layoutStrings = videoLayout.split(',').filter((layoutString) => {
+          return layoutString == 'CH-STEREO' || layoutString == 'CH-MONO';
+        });
+        videoLayout = layoutStrings[0];
+      }
+      // According to the HLS spec:
+      // By default a video variant is monoscopic, so an attribute
+      // consisting entirely of REQ-VIDEO-LAYOUT="CH-MONO" is unnecessary
+      // and SHOULD NOT be present.
+      videoLayout = videoLayout || 'CH-MONO';
+
+      const streamInfos = this.createStreamInfosForVariantTags_(tags,
+          mediaTags, resolution, frameRate);
 
       goog.asserts.assert(streamInfos.audio.length ||
           streamInfos.video.length, 'We should have created a stream!');
 
-      return this.createVariants_(
+      allVariants.push(...this.createVariants_(
           streamInfos.audio,
           streamInfos.video,
           bandwidth,
@@ -1406,47 +1377,78 @@ shaka.hls.HlsParser = class {
           height,
           frameRate,
           videoRange,
+          videoLayout,
           drmInfos,
-          keyIds);
-    });
-    let variants = allVariants.reduce(shaka.util.Functional.collapseArrays, []);
-    // Filter out null variants.
-    variants = variants.filter((variant) => variant != null);
-    return variants;
+          keyIds));
+    }
+    return allVariants.filter((variant) => variant != null);
   }
 
   /**
    * Create audio and video streamInfos from an 'EXT-X-STREAM-INF' tag and its
    * related media tags.
    *
-   * @param {!shaka.hls.Tag} tag
+   * @param {!Array.<!shaka.hls.Tag>} tags
+   * @param {!Array.<!shaka.hls.Tag>} mediaTags
    * @param {?string} resolution
    * @param {?string} frameRate
    * @return {!shaka.hls.HlsParser.StreamInfos}
    * @private
    */
-  createStreamInfosForVariantTag_(tag, resolution, frameRate) {
+  createStreamInfosForVariantTags_(tags, mediaTags, resolution, frameRate) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
-    /** @type {!Array.<string>} */
-    let allCodecs = this.getCodecsForVariantTag_(tag);
-    const audioGroupId = tag.getAttributeValue('AUDIO');
-    const videoGroupId = tag.getAttributeValue('VIDEO');
-    goog.asserts.assert(audioGroupId == null || videoGroupId == null,
-        'Unexpected: both video and audio described by media tags!');
-
-    const groupId = audioGroupId || videoGroupId;
-    const streamInfos =
-        (groupId && this.groupIdToStreamInfosMap_.has(groupId)) ?
-        this.groupIdToStreamInfosMap_.get(groupId) : [];
 
     /** @type {shaka.hls.HlsParser.StreamInfos} */
     const res = {
-      audio: audioGroupId ? streamInfos : [],
-      video: videoGroupId ? streamInfos : [],
+      audio: [],
+      video: [],
     };
+    const groupIdPathwayIdMapping = new Map();
+    const globalGroupIds = [];
+    let isAudioGroup = false;
+    let isVideoGroup = false;
+    for (const tag of tags) {
+      const audioGroupId = tag.getAttributeValue('AUDIO');
+      const videoGroupId = tag.getAttributeValue('VIDEO');
+      goog.asserts.assert(audioGroupId == null || videoGroupId == null,
+          'Unexpected: both video and audio described by media tags!');
+
+      const groupId = audioGroupId || videoGroupId;
+      if (!groupId) {
+        continue;
+      }
+      if (!globalGroupIds.includes(groupId)) {
+        globalGroupIds.push(groupId);
+      }
+      const pathwayId = tag.getAttributeValue('PATHWAY-ID');
+      if (pathwayId) {
+        groupIdPathwayIdMapping.set(groupId, pathwayId);
+      }
+      if (audioGroupId) {
+        isAudioGroup = true;
+      } else if (videoGroupId) {
+        isVideoGroup = true;
+      }
+      // Make an educated guess about the stream type.
+      shaka.log.debug('Guessing stream type for', tag.toString());
+    }
+    if (globalGroupIds.length && mediaTags.length) {
+      const mediaTagsForVariant = mediaTags.filter((tag) => {
+        return globalGroupIds.includes(tag.getRequiredAttrValue('GROUP-ID'));
+      });
+      this.createStreamInfosFromMediaTags_(
+          mediaTagsForVariant, groupIdPathwayIdMapping);
+    }
+    const globalGroupId = globalGroupIds.sort().join(',');
+    const streamInfos =
+        (globalGroupId && this.groupIdToStreamInfosMap_.has(globalGroupId)) ?
+        this.groupIdToStreamInfosMap_.get(globalGroupId) : [];
+    if (isAudioGroup) {
+      res.audio.push(...streamInfos);
+    } else if (isVideoGroup) {
+      res.video.push(...streamInfos);
+    }
 
-    // Make an educated guess about the stream type.
-    shaka.log.debug('Guessing stream type for', tag.toString());
     let type;
     let ignoreStream = false;
 
@@ -1455,11 +1457,15 @@ shaka.hls.HlsParser = class {
     // In that case, ignore the local URI and use the version in the
     // AUDIO tag, so you inherit its language.
     // As an example, see the manifest linked in issue #860.
-    const streamURI = tag.getRequiredAttrValue('URI');
+    const allStreamUris = tags.map((tag) => tag.getRequiredAttrValue('URI'));
     const hasSameUri = res.audio.find((audio) => {
-      return audio && audio.verbatimMediaPlaylistUri == streamURI;
+      return audio && audio.getUris().find((uri) => {
+        return allStreamUris.includes(uri);
+      });
     });
 
+    /** @type {!Array.<string>} */
+    let allCodecs = this.getCodecsForVariantTag_(tags[0]);
     const videoCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
         ContentType.VIDEO, allCodecs);
     const audioCodecs = shaka.util.ManifestParserUtils.guessCodecsSafe(
@@ -1471,7 +1477,8 @@ shaka.hls.HlsParser = class {
       type = ContentType.AUDIO;
       shaka.log.debug('Guessing audio-only.');
       ignoreStream = res.audio.length > 0;
-    } else if (!streamInfos.length && audioCodecs && videoCodecs) {
+    } else if (!res.audio.length && !res.video.length &&
+        audioCodecs && videoCodecs) {
       // There are both audio and video codecs, so assume multiplexed content.
       // Note that the default used when CODECS is missing assumes multiple
       // (and therefore multiplexed).
@@ -1494,8 +1501,35 @@ shaka.hls.HlsParser = class {
     }
 
     if (!ignoreStream) {
-      const streamInfo =
-          this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
+      let language = null;
+      let name = null;
+      let channelsCount = null;
+      let spatialAudio = false;
+      let characteristics = null;
+      let sampleRate = null;
+      if (!streamInfos.length) {
+        const mediaTag = mediaTags.find((tag) => {
+          const uri = tag.getAttributeValue('URI') || '';
+          const type = tag.getAttributeValue('TYPE');
+          const groupId = tag.getRequiredAttrValue('GROUP-ID');
+          return type != 'SUBTITLES' && uri == '' &&
+              globalGroupIds.includes(groupId);
+        });
+        if (mediaTag) {
+          language = mediaTag.getAttributeValue('LANGUAGE');
+          name = mediaTag.getAttributeValue('NAME');
+          channelsCount = this.getChannelsCount_(mediaTag);
+          spatialAudio = this.isSpatialAudio_(mediaTag);
+          characteristics = mediaTag.getAttributeValue('CHARACTERISTICS');
+          sampleRate = this.getSampleRate_(mediaTag);
+        }
+      }
+      const streamInfo = this.createStreamInfoFromVariantTags_(
+          tags, allCodecs, type, language, name, channelsCount,
+          characteristics, sampleRate, spatialAudio);
+      if (globalGroupId) {
+        streamInfo.stream.groupId = globalGroupId;
+      }
       res[streamInfo.stream.type] = [streamInfo];
     }
     return res;
@@ -1510,17 +1544,24 @@ shaka.hls.HlsParser = class {
    * @private
    */
   getCodecsForVariantTag_(tag) {
-    // These are the default codecs to assume if none are specified.
-    const defaultCodecsArray = [];
-    if (!this.config_.disableVideo) {
-      defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
-    }
-    if (!this.config_.disableAudio) {
-      defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
+    let codecsString = tag.getAttributeValue('CODECS') || '';
+
+    this.codecInfoInManifest_ = codecsString.length > 0;
+
+    if (!this.codecInfoInManifest_ && !this.config_.hls.disableCodecGuessing) {
+      // These are the default codecs to assume if none are specified.
+      const defaultCodecsArray = [];
+
+      if (!this.config_.disableVideo) {
+        defaultCodecsArray.push(this.config_.hls.defaultVideoCodec);
+      }
+      if (!this.config_.disableAudio) {
+        defaultCodecsArray.push(this.config_.hls.defaultAudioCodec);
+      }
+
+      codecsString = defaultCodecsArray.join(',');
     }
-    const defaultCodecs = defaultCodecsArray.join(',');
 
-    const codecsString = tag.getAttributeValue('CODECS', defaultCodecs);
     // Strip out internal whitespace while splitting on commas:
     /** @type {!Array.<string>} */
     const codecs = codecsString.split(/\s*,\s*/);
@@ -1674,6 +1715,7 @@ shaka.hls.HlsParser = class {
    * @param {?string} height
    * @param {?string} frameRate
    * @param {?string} videoRange
+   * @param {?string} videoLayout
    * @param {!Array.<shaka.extern.DrmInfo>} drmInfos
    * @param {!Set.<string>} keyIds
    * @return {!Array.<!shaka.extern.Variant>}
@@ -1681,13 +1723,13 @@ shaka.hls.HlsParser = class {
    */
   createVariants_(
       audioInfos, videoInfos, bandwidth, width, height, frameRate, videoRange,
-      drmInfos, keyIds) {
+      videoLayout, drmInfos, keyIds) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const DrmEngine = shaka.media.DrmEngine;
 
     for (const info of videoInfos) {
       this.addVideoAttributes_(
-          info.stream, width, height, frameRate, videoRange);
+          info.stream, width, height, frameRate, videoRange, videoLayout);
     }
 
     // In case of audio-only or video-only content or the audio/video is
@@ -1719,9 +1761,9 @@ shaka.hls.HlsParser = class {
         const audioDrmInfos = audioInfo ? audioInfo.stream.drmInfos : null;
         const videoDrmInfos = videoInfo ? videoInfo.stream.drmInfos : null;
         const videoStreamUri =
-            videoInfo ? videoInfo.verbatimMediaPlaylistUri : '';
+            videoInfo ? videoInfo.getUris().sort().join(',') : '';
         const audioStreamUri =
-            audioInfo ? audioInfo.verbatimMediaPlaylistUri : '';
+            audioInfo ? audioInfo.getUris().sort().join(',') : '';
         const variantUriKey = videoStreamUri + ' - ' + audioStreamUri;
 
         if (audioStream && videoStream) {
@@ -1809,34 +1851,59 @@ shaka.hls.HlsParser = class {
   /**
    * Parse EXT-X-MEDIA media tag into a Stream object.
    *
-   * @param {shaka.hls.Tag} tag
+   * @param {!Array.<!shaka.hls.Tag>} tags
+   * @param {!Map.<string, string>} groupIdPathwayIdMapping
    * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  createStreamInfoFromMediaTag_(tag) {
-    goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
-        'Should only be called on media tags!');
-    const groupId = tag.getRequiredAttrValue('GROUP-ID');
+  createStreamInfoFromMediaTags_(tags, groupIdPathwayIdMapping) {
+    const verbatimMediaPlaylistUris = [];
+    const globalGroupIds = [];
+    const groupIdUriMappping = new Map();
+    for (const tag of tags) {
+      goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
+          'Should only be called on media tags!');
+      const uri = tag.getRequiredAttrValue('URI');
+      const groupId = tag.getRequiredAttrValue('GROUP-ID');
+      verbatimMediaPlaylistUris.push(uri);
+      globalGroupIds.push(groupId);
+      groupIdUriMappping.set(groupId, uri);
+    }
+
+    const globalGroupId = globalGroupIds.sort().join(',');
+    const firstTag = tags[0];
     let codecs = '';
     /** @type {string} */
-    const type = this.getType_(tag);
+    const type = this.getType_(firstTag);
     if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
-      codecs = tag.getAttributeValue('CODECS') || '';
-    } else if (groupId && this.groupIdToCodecsMap_.has(groupId)) {
-      codecs = this.groupIdToCodecsMap_.get(groupId);
+      codecs = firstTag.getAttributeValue('CODECS') || '';
+    } else {
+      for (const groupId of globalGroupIds) {
+        if (this.groupIdToCodecsMap_.has(groupId)) {
+          codecs = this.groupIdToCodecsMap_.get(groupId);
+          break;
+        }
+      }
     }
 
-    const verbatimMediaPlaylistUri = this.variableSubstitution_(
-        tag.getRequiredAttrValue('URI'), this.globalVariables_);
-
     // Check if the stream has already been created as part of another Variant
     // and return it if it has.
-    if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
-      return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
+    const key = verbatimMediaPlaylistUris.sort().join(',');
+    if (this.uriToStreamInfosMap_.has(key)) {
+      return this.uriToStreamInfosMap_.get(key);
+    }
+    const streamId = this.globalId_++;
+    if (this.contentSteeringManager_) {
+      for (const [groupId, uri] of groupIdUriMappping) {
+        const pathwayId = groupIdPathwayIdMapping.get(groupId);
+        if (pathwayId) {
+          this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
+        }
+      }
     }
 
-    const language = tag.getAttributeValue('LANGUAGE');
-    const name = tag.getAttributeValue('NAME');
+    const language = firstTag.getAttributeValue('LANGUAGE');
+    const name = firstTag.getAttributeValue('NAME');
 
     // NOTE: According to the HLS spec, "DEFAULT=YES" requires "AUTOSELECT=YES".
     // However, we don't bother to validate "AUTOSELECT", since we don't
@@ -1844,39 +1911,39 @@ shaka.hls.HlsParser = class {
     // "AUTOSELECT=YES".  A value of "AUTOSELECT=NO" would imply that it may
     // only be selected explicitly by the user, and we don't have a way to
     // represent that in our model.
-    const defaultAttrValue = tag.getAttributeValue('DEFAULT');
+    const defaultAttrValue = firstTag.getAttributeValue('DEFAULT');
     const primary = defaultAttrValue == 'YES';
 
-    const channelsCount = type == 'audio' ? this.getChannelsCount_(tag) : null;
-    const spatialAudio = type == 'audio' ? this.isSpatialAudio_(tag) : false;
-    const characteristics = tag.getAttributeValue('CHARACTERISTICS');
+    const channelsCount =
+        type == 'audio' ? this.getChannelsCount_(firstTag) : null;
+    const spatialAudio =
+        type == 'audio' ? this.isSpatialAudio_(firstTag) : false;
+    const characteristics = firstTag.getAttributeValue('CHARACTERISTICS');
 
-    const forcedAttrValue = tag.getAttributeValue('FORCED');
+    const forcedAttrValue = firstTag.getAttributeValue('FORCED');
     const forced = forcedAttrValue == 'YES';
-    const sampleRate = type == 'audio' ? this.getSampleRate_(tag) : null;
+    const sampleRate = type == 'audio' ? this.getSampleRate_(firstTag) : null;
     // TODO: Should we take into account some of the currently ignored
     // attributes: INSTREAM-ID, Attribute descriptions: https://bit.ly/2lpjOhj
     const streamInfo = this.createStreamInfo_(
-        verbatimMediaPlaylistUri, codecs, type, language, primary, name,
-        channelsCount, /* closedCaptions= */ null, characteristics, forced,
-        sampleRate, spatialAudio);
-    if (this.groupIdToStreamInfosMap_.has(groupId)) {
-      this.groupIdToStreamInfosMap_.get(groupId).push(streamInfo);
+        streamId, verbatimMediaPlaylistUris, codecs, type, language,
+        primary, name, channelsCount, /* closedCaptions= */ null,
+        characteristics, forced, sampleRate, spatialAudio);
+    if (streamInfo.stream) {
+      streamInfo.stream.groupId = globalGroupId;
+    }
+    if (this.groupIdToStreamInfosMap_.has(globalGroupId)) {
+      this.groupIdToStreamInfosMap_.get(globalGroupId).push(streamInfo);
     } else {
-      this.groupIdToStreamInfosMap_.set(groupId, [streamInfo]);
+      this.groupIdToStreamInfosMap_.set(globalGroupId, [streamInfo]);
     }
 
-    // TODO: This check is necessary because of the possibility of multiple
-    // calls to createStreamInfoFromMediaTag_ before either has resolved.
-    if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
-      return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
-    }
-    this.uriToStreamInfosMap_.set(verbatimMediaPlaylistUri, streamInfo);
+    this.uriToStreamInfosMap_.set(key, streamInfo);
     return streamInfo;
   }
 
   /**
-   * Parse EXT-X-MEDIA media tag into a Stream object.
+   * Parse EXT-X-IMAGE-STREAM-INF media tag into a Stream object.
    *
    * @param {shaka.hls.Tag} tag
    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
@@ -1888,8 +1955,7 @@ shaka.hls.HlsParser = class {
     /** @type {string} */
     const type = shaka.util.ManifestParserUtils.ContentType.IMAGE;
 
-    const verbatimImagePlaylistUri = this.variableSubstitution_(
-        tag.getRequiredAttrValue('URI'), this.globalVariables_);
+    const verbatimImagePlaylistUri = tag.getRequiredAttrValue('URI');
     const codecs = tag.getAttributeValue('CODECS', 'jpeg') || '';
 
     // Check if the stream has already been created as part of another Variant
@@ -1904,16 +1970,10 @@ shaka.hls.HlsParser = class {
     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
 
     const streamInfo = this.createStreamInfo_(
-        verbatimImagePlaylistUri, codecs, type, language, /* primary= */ false,
-        name, /* channelsCount= */ null, /* closedCaptions= */ null,
-        characteristics, /* forced= */ false, /* sampleRate= */ null,
-        /* spatialAudio= */ false);
-
-    // TODO: This check is necessary because of the possibility of multiple
-    // calls to createStreamInfoFromImageTag_ before either has resolved.
-    if (this.uriToStreamInfosMap_.has(verbatimImagePlaylistUri)) {
-      return this.uriToStreamInfosMap_.get(verbatimImagePlaylistUri);
-    }
+        this.globalId_++, [verbatimImagePlaylistUri], codecs, type, language,
+        /* primary= */ false, name, /* channelsCount= */ null,
+        /* closedCaptions= */ null, characteristics, /* forced= */ false,
+        /* sampleRate= */ null, /* spatialAudio= */ false);
 
     // Parse misc attributes.
     const resolution = tag.getAttributeValue('RESOLUTION');
@@ -1946,45 +2006,104 @@ shaka.hls.HlsParser = class {
     return streamInfo;
   }
 
+  /**
+   * Parse EXT-X-I-FRAME-STREAM-INF media tag into a Stream object.
+   *
+   * @param {shaka.hls.Tag} tag
+   * @return {!shaka.hls.HlsParser.StreamInfo}
+   * @private
+   */
+  createStreamInfoFromIframeTag_(tag) {
+    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;
+
+    const verbatimIFramePlaylistUri = tag.getRequiredAttrValue('URI');
+    const codecs = tag.getAttributeValue('CODECS') || '';
+
+    // Check if the stream has already been created as part of another Variant
+    // and return it if it has.
+    if (this.uriToStreamInfosMap_.has(verbatimIFramePlaylistUri)) {
+      return this.uriToStreamInfosMap_.get(verbatimIFramePlaylistUri);
+    }
+
+    const language = tag.getAttributeValue('LANGUAGE');
+    const name = tag.getAttributeValue('NAME');
+
+    const characteristics = tag.getAttributeValue('CHARACTERISTICS');
+
+    const streamInfo = this.createStreamInfo_(
+        this.globalId_++, [verbatimIFramePlaylistUri], codecs, type, language,
+        /* primary= */ false, name, /* channelsCount= */ null,
+        /* closedCaptions= */ null, characteristics, /* forced= */ false,
+        /* sampleRate= */ null, /* spatialAudio= */ false);
+
+    // Parse misc attributes.
+    const resolution = tag.getAttributeValue('RESOLUTION');
+    const [width, height] = resolution ? resolution.split('x') : [null, null];
+    streamInfo.stream.width = Number(width) || undefined;
+    streamInfo.stream.height = Number(height) || undefined;
+    const bandwidth = tag.getAttributeValue('BANDWIDTH');
+    if (bandwidth) {
+      streamInfo.stream.bandwidth = Number(bandwidth);
+    }
+
+    this.uriToStreamInfosMap_.set(verbatimIFramePlaylistUri, streamInfo);
+    return streamInfo;
+  }
+
   /**
    * Parse an EXT-X-STREAM-INF media tag into a Stream object.
    *
-   * @param {!shaka.hls.Tag} tag
+   * @param {!Array.<!shaka.hls.Tag>} tags
    * @param {!Array.<string>} allCodecs
    * @param {string} type
+   * @param {?string} language
+   * @param {?string} name
+   * @param {?number} channelsCount
+   * @param {?string} characteristics
+   * @param {?number} sampleRate
+   * @param {boolean} spatialAudio
    * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  createStreamInfoFromVariantTag_(tag, allCodecs, type) {
-    goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
-        'Should only be called on variant tags!');
-    const verbatimMediaPlaylistUri = this.variableSubstitution_(
-        tag.getRequiredAttrValue('URI'), this.globalVariables_);
+  createStreamInfoFromVariantTags_(tags, allCodecs, type, language, name,
+      channelsCount, characteristics, sampleRate, spatialAudio) {
+    const streamId = this.globalId_++;
+    const verbatimMediaPlaylistUris = [];
+    for (const tag of tags) {
+      goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
+          'Should only be called on variant tags!');
+      const uri = tag.getRequiredAttrValue('URI');
+      const pathwayId = tag.getAttributeValue('PATHWAY-ID');
+      if (this.contentSteeringManager_ && pathwayId) {
+        this.contentSteeringManager_.addLocation(streamId, pathwayId, uri);
+      }
+      verbatimMediaPlaylistUris.push(uri);
+    }
 
-    if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
-      return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
+    const key = verbatimMediaPlaylistUris.sort().join(',');
+    if (this.uriToStreamInfosMap_.has(key)) {
+      return this.uriToStreamInfosMap_.get(key);
     }
 
-    const closedCaptions = this.getClosedCaptions_(tag, type);
+    const closedCaptions = this.getClosedCaptions_(tags[0], type);
     const codecs = shaka.util.ManifestParserUtils.guessCodecs(type, allCodecs);
-    const streamInfo = this.createStreamInfo_(verbatimMediaPlaylistUri,
-        codecs, type, /* language= */ null, /* primary= */ false,
-        /* name= */ null, /* channelcount= */ null, closedCaptions,
-        /* characteristics= */ null, /* forced= */ false,
-        /* sampleRate= */ null, /* spatialAudio= */ false);
-    // TODO: This check is necessary because of the possibility of multiple
-    // calls to createStreamInfoFromVariantTag_ before either has resolved.
-    if (this.uriToStreamInfosMap_.has(verbatimMediaPlaylistUri)) {
-      return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
-    }
+    const streamInfo = this.createStreamInfo_(
+        streamId, verbatimMediaPlaylistUris, codecs, type, language,
+        /* primary= */ false, name, channelsCount, closedCaptions,
+        characteristics, /* forced= */ false, sampleRate,
+        /* spatialAudio= */ false);
 
-    this.uriToStreamInfosMap_.set(verbatimMediaPlaylistUri, streamInfo);
+    this.uriToStreamInfosMap_.set(key, streamInfo);
     return streamInfo;
   }
 
 
   /**
-   * @param {string} verbatimMediaPlaylistUri
+   * @param {number} streamId
+   * @param {!Array.<string>} verbatimMediaPlaylistUris
    * @param {string} codecs
    * @param {string} type
    * @param {?string} languageValue
@@ -1999,25 +2118,34 @@ shaka.hls.HlsParser = class {
    * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, languageValue,
-      primary, name, channelsCount, closedCaptions, characteristics, forced,
-      sampleRate, spatialAudio) {
+  createStreamInfo_(streamId, verbatimMediaPlaylistUris, codecs, type,
+      languageValue, primary, name, channelsCount, closedCaptions,
+      characteristics, forced, sampleRate, spatialAudio) {
     // TODO: Refactor, too many parameters
-    const initialMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
-        this.masterPlaylistUri_, verbatimMediaPlaylistUri);
 
     // 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, languageValue, primary,
-        name, channelsCount, closedCaptions, characteristics, forced,
-        sampleRate, spatialAudio);
+    const stream = this.makeStreamObject_(streamId, codecs, type,
+        languageValue, primary, name, channelsCount, closedCaptions,
+        characteristics, forced, sampleRate, spatialAudio);
+
+    const redirectUris = [];
+    const getUris = () => {
+      if (this.contentSteeringManager_ &&
+          verbatimMediaPlaylistUris.length > 1) {
+        return this.contentSteeringManager_.getLocations(streamId);
+      }
+      return redirectUris.concat(shaka.hls.Utils.constructUris(
+          [this.masterPlaylistUri_], verbatimMediaPlaylistUris,
+          this.globalVariables_));
+    };
     const streamInfo = {
       stream,
       type,
-      verbatimMediaPlaylistUri,
+      redirectUris,
+      getUris,
       // These values are filled out or updated after lazy-loading:
-      absoluteMediaPlaylistUri: initialMediaPlaylistUri,
       minTimestamp: 0,
       maxTimestamp: 0,
       mediaSequenceToStartTime: new Map(),
@@ -2032,27 +2160,45 @@ shaka.hls.HlsParser = class {
 
     /** @param {!AbortSignal} abortSignal */
     const downloadSegmentIndex = async (abortSignal) => {
+      const uris = streamInfo.getUris();
       // Download the actual manifest.
       const response = await this.requestManifest_(
-          streamInfo.absoluteMediaPlaylistUri, /* isPlaylist= */ true);
+          streamInfo.getUris(), /* isPlaylist= */ true);
       if (abortSignal.aborted) {
         return;
       }
 
       // Record the final URI after redirects.
-      const absoluteMediaPlaylistUri = response.uri;
+      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, absoluteMediaPlaylistUri);
+      const playlist = this.manifestTextParser_.parsePlaylist(response.data);
+
+      let mimeType = undefined;
+
+      // 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) {
+        const basicInfo =
+            await this.getMediaPlaylistBasicInfo_(playlist, getUris);
+
+        goog.asserts.assert(
+            type === basicInfo.type, 'Media types should match!');
+
+        mimeType = basicInfo.mimeType;
+        codecs = basicInfo.codecs;
+      }
 
       const wasLive = this.isLive_();
       const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
-          playlist, verbatimMediaPlaylistUri, absoluteMediaPlaylistUri, codecs,
+          streamId, playlist, getUris, responseUri, codecs,
           type, languageValue, primary, name, channelsCount, closedCaptions,
-          characteristics, forced, sampleRate, spatialAudio);
+          characteristics, forced, sampleRate, spatialAudio, mimeType);
       if (abortSignal.aborted) {
         return;
       }
@@ -2066,7 +2212,6 @@ shaka.hls.HlsParser = class {
       }
 
       // Copy values from the real stream info to our initial one.
-      streamInfo.absoluteMediaPlaylistUri = absoluteMediaPlaylistUri;
       streamInfo.minTimestamp = realStreamInfo.minTimestamp;
       streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
       streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
@@ -2083,6 +2228,7 @@ shaka.hls.HlsParser = class {
       stream.keyIds = realStream.keyIds;
       stream.mimeType = realStream.mimeType;
       stream.bandwidth = realStream.bandwidth;
+      stream.codecs = realStream.codecs || stream.codecs;
 
       // Since we lazy-loaded this content, the player may need to create new
       // sessions for the DRM info in this stream.
@@ -2284,9 +2430,10 @@ shaka.hls.HlsParser = class {
   }
 
   /**
+   * @param {number} streamId
    * @param {!shaka.hls.Playlist} playlist
-   * @param {string} verbatimMediaPlaylistUri
-   * @param {string} absoluteMediaPlaylistUri
+   * @param {function():!Array.<string>} getUris
+   * @param {string} responseUri
    * @param {string} codecs
    * @param {string} type
    * @param {?string} languageValue
@@ -2302,8 +2449,8 @@ shaka.hls.HlsParser = class {
    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
-  async convertParsedPlaylistIntoStreamInfo_(playlist, verbatimMediaPlaylistUri,
-      absoluteMediaPlaylistUri, codecs, type, languageValue, primary, name,
+  async convertParsedPlaylistIntoStreamInfo_(streamId, playlist,
+      getUris, responseUri, codecs, type, languageValue, primary, name,
       channelsCount, closedCaptions, characteristics, forced, sampleRate,
       spatialAudio, mimeType = undefined) {
     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
@@ -2319,7 +2466,8 @@ shaka.hls.HlsParser = class {
     const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
         'EXT-X-DEFINE');
 
-    const mediaVariables = this.parseMediaVariables_(variablesTags);
+    const mediaVariables =
+        this.parseMediaVariables_(variablesTags, responseUri);
 
     goog.asserts.assert(playlist.segments != null,
         'Media playlist should have segments!');
@@ -2332,7 +2480,7 @@ shaka.hls.HlsParser = class {
 
     if (!mimeType) {
       mimeType = await this.guessMimeType_(type, codecs, playlist,
-          mediaVariables);
+          mediaVariables, getUris);
     }
 
     const {drmInfos, keyIds, encrypted, aesEncrypted} =
@@ -2345,11 +2493,20 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
     }
 
+    const stream = this.makeStreamObject_(streamId, codecs, type,
+        languageValue, primary, name, channelsCount, closedCaptions,
+        characteristics, forced, sampleRate, spatialAudio);
+    stream.encrypted = encrypted;
+    stream.drmInfos = drmInfos;
+    stream.keyIds = keyIds;
+    stream.mimeType = mimeType;
+
     const mediaSequenceToStartTime = this.isLive_() ?
         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
+
     const {segments, bandwidth} = this.createSegments_(
-        verbatimMediaPlaylistUri, playlist, type, mimeType,
-        mediaSequenceToStartTime, mediaVariables);
+        playlist, stream, mediaSequenceToStartTime, mediaVariables, getUris);
+    stream.bandwidth = bandwidth;
 
     // This new calculation is necessary for Low Latency streams.
     if (this.isLive_()) {
@@ -2361,6 +2518,7 @@ shaka.hls.HlsParser = class {
     const lastEndTime = lastSegment.endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
+    stream.segmentIndex = segmentIndex;
 
     const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
         playlist.tags, 'EXT-X-SERVER-CONTROL');
@@ -2375,21 +2533,11 @@ shaka.hls.HlsParser = class {
     const {nextMediaSequence, nextPart} =
         this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
 
-    const stream = this.makeStreamObject_(codecs, type, languageValue, primary,
-        name, channelsCount, closedCaptions, characteristics, forced,
-        sampleRate, spatialAudio);
-    stream.segmentIndex = segmentIndex;
-    stream.encrypted = encrypted;
-    stream.drmInfos = drmInfos;
-    stream.keyIds = keyIds;
-    stream.mimeType = mimeType;
-    stream.bandwidth = bandwidth;
-
     return {
       stream,
       type,
-      verbatimMediaPlaylistUri,
-      absoluteMediaPlaylistUri,
+      redirectUris: [],
+      getUris,
       minTimestamp: firstStartTime,
       maxTimestamp: lastEndTime,
       canSkipSegments,
@@ -2453,6 +2601,7 @@ shaka.hls.HlsParser = class {
    * 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 {number} id
    * @param {string} codecs
    * @param {string} type
    * @param {?string} languageValue
@@ -2467,8 +2616,9 @@ shaka.hls.HlsParser = class {
    * @return {!shaka.extern.Stream}
    * @private
    */
-  makeStreamObject_(codecs, type, languageValue, primary, name, channelsCount,
-      closedCaptions, characteristics, forced, sampleRate, spatialAudio) {
+  makeStreamObject_(id, codecs, type, languageValue, primary, name,
+      channelsCount, closedCaptions, characteristics, forced, sampleRate,
+      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) ||
@@ -2480,8 +2630,21 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    const kind = (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
-        shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined;
+    let kind = undefined;
+    let accessibilityPurpose = null;
+    if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      if (roles.includes('public.accessibility.transcribes-spoken-dialog') &&
+          roles.includes('public.accessibility.describes-music-and-sound')) {
+        kind = shaka.util.ManifestParserUtils.TextStreamKind.CLOSED_CAPTION;
+      } else {
+        kind = shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE;
+      }
+    } else {
+      if (roles.includes('public.accessibility.describes-video')) {
+        accessibilityPurpose =
+              shaka.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED;
+      }
+    }
 
     // If there are no roles, and we have defaulted to the subtitle "kind" for
     // this track, add the implied subtitle role.
@@ -2493,6 +2656,7 @@ shaka.hls.HlsParser = class {
     return {
       id: this.globalId_++,
       originalId: name,
+      groupId: null,
       createSegmentIndex: () => Promise.resolve(),
       segmentIndex: null,
       mimeType,
@@ -2522,9 +2686,11 @@ shaka.hls.HlsParser = class {
       spatialAudio,
       closedCaptions,
       hdr: undefined,
+      videoLayout: undefined,
       tilesLayout: undefined,
-      accessibilityPurpose: null,
+      accessibilityPurpose: accessibilityPurpose,
       external: false,
+      fastSwitching: false,
     };
   }
 
@@ -2595,10 +2761,12 @@ shaka.hls.HlsParser = class {
   /**
    * @param {!shaka.hls.Tag} drmTag
    * @param {!shaka.hls.Playlist} playlist
-   * @return {!shaka.extern.HlsAes128Key}
+   * @param {function():!Array.<string>} getUris
+   * @param {?Map.<string, string>=} variables
+   * @return {!shaka.extern.aes128Key}
    * @private
    */
-  parseAES128DrmTag_(drmTag, playlist) {
+  parseAES128DrmTag_(drmTag, playlist, getUris, variables) {
     // Check if the Web Crypto API is available.
     if (!window.crypto || !window.crypto.subtle) {
       shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
@@ -2629,22 +2797,21 @@ shaka.hls.HlsParser = class {
         throw new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_AES_128_INVALID_IV_LENGTH);
+            shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
       }
     }
 
-    const keyUri = shaka.hls.Utils.constructAbsoluteUri(
-        playlist.absoluteUri, drmTag.getRequiredAttrValue('URI'));
-
-    const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
-    const request = shaka.net.NetworkingEngine.makeRequest(
-        [keyUri], this.config_.retryParameters);
-
     const keyInfo = {method: 'AES-128', iv, firstMediaSequenceNumber};
 
     // Don't download the key object until the segment is parsed, to avoid a
     // startup delay for long manifests with lots of keys.
     keyInfo.fetchKey = async () => {
+      const keyUri = shaka.hls.Utils.constructSegmentUris(
+          getUris(), drmTag.getRequiredAttrValue('URI'), variables);
+
+      const requestType = shaka.net.NetworkingEngine.RequestType.KEY;
+      const request = shaka.net.NetworkingEngine.makeRequest(
+          [keyUri], this.config_.retryParameters);
       const keyResponse = await this.makeNetworkRequest_(request, requestType);
 
       // keyResponse.status is undefined when URI is "data:text/plain;base64,"
@@ -2652,7 +2819,7 @@ shaka.hls.HlsParser = class {
         throw new shaka.util.Error(
             shaka.util.Error.Severity.CRITICAL,
             shaka.util.Error.Category.MANIFEST,
-            shaka.util.Error.Code.HLS_AES_128_INVALID_KEY_LENGTH);
+            shaka.util.Error.Code.AES_128_INVALID_KEY_LENGTH);
       }
 
       const algorithm = {
@@ -2821,11 +2988,12 @@ shaka.hls.HlsParser = class {
    * Get the InitSegmentReference for a segment if it has a EXT-X-MAP tag.
    * @param {!shaka.hls.Playlist} playlist
    * @param {!Array.<!shaka.hls.Tag>} tags Segment tags
-   * @param {!Map.<string, string>} variables
+   * @param {function():!Array.<string>} getUris
+   * @param {?Map.<string, string>=} variables
    * @return {shaka.media.InitSegmentReference}
    * @private
    */
-  getInitSegmentReference_(playlist, tags, variables) {
+  getInitSegmentReference_(playlist, tags, getUris, variables) {
     /** @type {?shaka.hls.Tag} */
     const mapTag = shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-MAP');
 
@@ -2834,28 +3002,30 @@ shaka.hls.HlsParser = class {
     }
     // Map tag example: #EXT-X-MAP:URI="main.mp4",BYTERANGE="720@0"
     const verbatimInitSegmentUri = mapTag.getRequiredAttrValue('URI');
-    const absoluteInitSegmentUri = this.variableSubstitution_(
-        shaka.hls.Utils.constructAbsoluteUri(
-            playlist.absoluteUri, verbatimInitSegmentUri),
-        variables);
+    const absoluteInitSegmentUris = shaka.hls.Utils.constructSegmentUris(
+        getUris(), verbatimInitSegmentUri, variables);
 
     const mapTagKey = [
-      absoluteInitSegmentUri,
+      absoluteInitSegmentUris.toString(),
       mapTag.getAttributeValue('BYTERANGE', ''),
     ].join('-');
     if (!this.mapTagToInitSegmentRefMap_.has(mapTagKey)) {
-      /** @type {shaka.extern.HlsAes128Key|undefined} */
+      /** @type {shaka.extern.aes128Key|undefined} */
       let aes128Key = undefined;
+      let byteRangeTag = null;
       for (const tag of tags) {
         if (tag.name == 'EXT-X-KEY') {
           if (tag.getRequiredAttrValue('METHOD') == 'AES-128' &&
               tag.id < mapTag.id) {
-            aes128Key = this.parseAES128DrmTag_(tag, playlist);
+            aes128Key =
+                this.parseAES128DrmTag_(tag, playlist, getUris, variables);
           }
+        } else if (tag.name == 'EXT-X-BYTERANGE' && tag.id < mapTag.id) {
+          byteRangeTag = tag;
         }
       }
       const initSegmentRef = this.createInitSegmentReference_(
-          absoluteInitSegmentUri, mapTag, aes128Key);
+          absoluteInitSegmentUris, mapTag, byteRangeTag, aes128Key);
       this.mapTagToInitSegmentRefMap_.set(mapTagKey, initSegmentRef);
     }
     return this.mapTagToInitSegmentRefMap_.get(mapTagKey);
@@ -2864,16 +3034,21 @@ shaka.hls.HlsParser = class {
   /**
    * Create an InitSegmentReference object for the EXT-X-MAP tag in the media
    * playlist.
-   * @param {string} absoluteInitSegmentUri
+   * @param {!Array.<string>} absoluteInitSegmentUris
    * @param {!shaka.hls.Tag} mapTag EXT-X-MAP
-   * @param {shaka.extern.HlsAes128Key=} aes128Key
+   * @param {shaka.hls.Tag=} byteRangeTag EXT-X-BYTERANGE
+   * @param {shaka.extern.aes128Key=} aes128Key
    * @return {!shaka.media.InitSegmentReference}
    * @private
    */
-  createInitSegmentReference_(absoluteInitSegmentUri, mapTag, aes128Key) {
+  createInitSegmentReference_(absoluteInitSegmentUris, mapTag, byteRangeTag,
+      aes128Key) {
     let startByte = 0;
     let endByte = null;
-    const byterange = mapTag.getAttributeValue('BYTERANGE');
+    let byterange = mapTag.getAttributeValue('BYTERANGE');
+    if (!byterange && byteRangeTag) {
+      byterange = byteRangeTag.value;
+    }
     // If a BYTERANGE attribute is not specified, the segment consists
     // of the entire resource.
     if (byterange) {
@@ -2894,7 +3069,7 @@ shaka.hls.HlsParser = class {
     }
 
     const initSegmentRef = new shaka.media.InitSegmentReference(
-        () => [absoluteInitSegmentUri],
+        () => absoluteInitSegmentUris,
         startByte,
         endByte,
         /* mediaQuality= */ null,
@@ -2912,16 +3087,16 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Segment} hlsSegment
    * @param {number} startTime
    * @param {!Map.<string, string>} variables
-   * @param {string} absoluteMediaPlaylistUri
-   * @param {string} type
-   * @param {string} mimeType
-   * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
+   * @param {!shaka.hls.Playlist} playlist
+   * @param {shaka.extern.Stream} stream
+   * @param {function():!Array.<string>} getUris
+   * @param {shaka.extern.aes128Key=} aes128Key
    * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, absoluteMediaPlaylistUri, type, mimeType, hlsAes128Key) {
+      variables, playlist, stream, getUris, aes128Key) {
     const tags = hlsSegment.tags;
     const extinfTag =
         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
@@ -2978,8 +3153,9 @@ shaka.hls.HlsParser = class {
     let isPreloadSegment = false;
 
     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
-      const byterangeOptimizationSupport = (mimeType == 'video/mp4' ||
-          mimeType == 'audio/mp4') && window.ReadableStream;
+      const byterangeOptimizationSupport = (stream.mimeType == 'video/mp4' ||
+          stream.mimeType == 'audio/mp4') && window.ReadableStream &&
+          this.config_.hls.allowLowLatencyByteRangeOptimization;
 
       let partialSyncTime = syncTime;
       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
@@ -3035,14 +3211,14 @@ shaka.hls.HlsParser = class {
           somePartialSegmentWithGap = true;
         }
 
-        let pAbsoluteUri = null;
+        let uris = null;
         const getPartialUris = () => {
-          if (pAbsoluteUri == null) {
+          if (uris == null) {
             goog.asserts.assert(pUri, 'Partial uri should be defined!');
-            pAbsoluteUri = shaka.hls.Utils.constructAbsoluteUri(
-                absoluteMediaPlaylistUri, pUri);
+            uris = shaka.hls.Utils.constructSegmentUris(
+                getUris(), pUri, variables);
           }
-          return [pAbsoluteUri];
+          return uris;
         };
 
         if (byterangeOptimizationSupport &&
@@ -3066,7 +3242,7 @@ shaka.hls.HlsParser = class {
             /* tileDuration= */ null,
             partialSyncTime,
             partialStatus,
-            hlsAes128Key);
+            aes128Key);
         if (item.name == 'EXT-X-PRELOAD-HINT') {
           partial.markAsPreload();
           isPreloadSegment = true;
@@ -3137,7 +3313,7 @@ shaka.hls.HlsParser = class {
 
     let tilesLayout = '';
     let tileDuration = null;
-    if (type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
+    if (stream.type == shaka.util.ManifestParserUtils.ContentType.IMAGE) {
       // By default in HLS the tilesLayout is 1x1
       tilesLayout = '1x1';
       const tilesTag =
@@ -3151,22 +3327,25 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    let absoluteSegmentUri = null;
-    const getUris = () => {
+    let uris = null;
+    const getSegmentUris = () => {
       if (getUrisOptimization) {
         return getUrisOptimization();
       }
-      if (absoluteSegmentUri == null) {
-        absoluteSegmentUri = this.variableSubstitution_(
-            hlsSegment.absoluteUri, variables);
+      if (uris == null) {
+        uris = shaka.hls.Utils.constructSegmentUris(getUris(),
+            hlsSegment.verbatimSegmentUri, variables);
       }
-      return absoluteSegmentUri.length ? [absoluteSegmentUri] : [];
+      return uris || [];
     };
 
+    const allPartialSegments = partialSegmentRefs.length > 0 &&
+        !!hlsSegment.verbatimSegmentUri;
+
     const reference = new shaka.media.SegmentReference(
         startTime,
         endTime,
-        getUris,
+        getSegmentUris,
         startByte,
         endByte,
         initSegmentReference,
@@ -3178,7 +3357,8 @@ shaka.hls.HlsParser = class {
         tileDuration,
         syncTime,
         status,
-        hlsAes128Key,
+        aes128Key,
+        allPartialSegments,
     );
 
     if (segmentWithByteRangeOptimization) {
@@ -3226,18 +3406,17 @@ shaka.hls.HlsParser = class {
    * get the bandwidth necessary for this segments If it's defined in the
    * playlist.
    *
-   * @param {string} verbatimMediaPlaylistUri
    * @param {!shaka.hls.Playlist} playlist
-   * @param {string} type
-   * @param {string} mimeType
+   * @param {shaka.extern.Stream} stream
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
+   * @param {function():!Array.<string>} getUris
    * @return {{segments: !Array.<!shaka.media.SegmentReference>,
    *          bandwidth: (number|undefined)}}
    * @private
    */
-  createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
-      mediaSequenceToStartTime, variables) {
+  createSegments_(playlist, stream, mediaSequenceToStartTime, variables,
+      getUris) {
     /** @type {Array.<!shaka.hls.Segment>} */
     const hlsSegments = playlist.segments;
     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
@@ -3245,8 +3424,8 @@ shaka.hls.HlsParser = class {
     /** @type {shaka.media.InitSegmentReference} */
     let initSegmentRef;
 
-    /** @type {shaka.extern.HlsAes128Key|undefined} */
-    let hlsAes128Key = undefined;
+    /** @type {shaka.extern.aes128Key|undefined} */
+    let aes128Key = undefined;
 
     let discontinuitySequence = shaka.hls.Utils.getFirstTagWithNameAsNumber(
         playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE', 0);
@@ -3289,9 +3468,10 @@ shaka.hls.HlsParser = class {
       for (const drmTag of item.tags) {
         if (drmTag.name == 'EXT-X-KEY') {
           if (drmTag.getRequiredAttrValue('METHOD') == 'AES-128') {
-            hlsAes128Key = this.parseAES128DrmTag_(drmTag, playlist);
+            aes128Key =
+                this.parseAES128DrmTag_(drmTag, playlist, getUris, variables);
           } else {
-            hlsAes128Key = undefined;
+            aes128Key = undefined;
           }
         }
       }
@@ -3299,7 +3479,7 @@ shaka.hls.HlsParser = class {
       mediaSequenceToStartTime.set(position, startTime);
 
       initSegmentRef = this.getInitSegmentReference_(playlist,
-          item.tags, variables);
+          item.tags, getUris, variables);
 
       // If the stream is low latency and the user has not configured the
       // lowLatencyMode, but if it has been configured to activate the
@@ -3319,10 +3499,10 @@ shaka.hls.HlsParser = class {
           item,
           startTime,
           variables,
-          playlist.absoluteUri,
-          type,
-          mimeType,
-          hlsAes128Key);
+          playlist,
+          stream,
+          getUris,
+          aes128Key);
 
       if (reference) {
         const bitrate = shaka.hls.Utils.getFirstTagWithNameAsNumber(
@@ -3455,42 +3635,6 @@ shaka.hls.HlsParser = class {
     };
   }
 
-  /**
-   * Replaces the variables of a given URI.
-   *
-   * @param {string} uri
-   * @param {!Map.<string, string>} variables
-   * @return {string}
-   * @private
-   */
-  variableSubstitution_(uri, variables) {
-    if (!variables.size) {
-      return uri;
-    }
-    let newUri = String(uri).replace(/%7B/g, '{').replace(/%7D/g, '}');
-
-    const uriVariables = newUri.match(/{\$\w*}/g);
-    if (uriVariables) {
-      for (const variable of uriVariables) {
-        // Note: All variables have the structure {$...}
-        const variableName = variable.slice(2, variable.length - 1);
-        const replaceValue = variables.get(variableName);
-        if (replaceValue) {
-          newUri = newUri.replace(variable, replaceValue);
-        } else {
-          shaka.log.error('A variable has been found that is not declared',
-              variableName);
-          throw new shaka.util.Error(
-              shaka.util.Error.Severity.CRITICAL,
-              shaka.util.Error.Category.MANIFEST,
-              shaka.util.Error.Code.HLS_VARIABLE_NOT_FOUND,
-              variableName);
-        }
-      }
-    }
-    return newUri;
-  }
-
   /**
    * Attempts to guess stream's mime type based on content type and URI.
    *
@@ -3524,6 +3668,10 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    if (codecs == 'mjpg') {
+      return 'application/mp4';
+    }
+
     // Not enough information to guess from the content type and codecs.
     return null;
   }
@@ -3556,10 +3704,11 @@ shaka.hls.HlsParser = class {
    * @param {string} codecs
    * @param {!shaka.hls.Playlist} playlist
    * @param {!Map.<string, string>} variables
+   * @param {function():!Array.<string>} getUris
    * @return {!Promise.<string>}
    * @private
    */
-  async guessMimeType_(contentType, codecs, playlist, variables) {
+  async guessMimeType_(contentType, codecs, playlist, variables, getUris) {
     const HlsParser = shaka.hls.HlsParser;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
@@ -3569,10 +3718,13 @@ shaka.hls.HlsParser = class {
     goog.asserts.assert(playlist.segments.length,
         'Playlist should have segments!');
     const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
-    const middleSegmentUri = this.variableSubstitution_(
-        playlist.segments[middleSegmentIdx].absoluteUri, variables);
 
-    const parsedUri = new goog.Uri(middleSegmentUri);
+    const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
+        getUris(),
+        playlist.segments[middleSegmentIdx].verbatimSegmentUri,
+        variables);
+
+    const parsedUri = new goog.Uri(middleSegmentUris[0]);
     const extension = parsedUri.getPath().split('.').pop();
     const map = HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_[contentType];
 
@@ -3595,7 +3747,7 @@ shaka.hls.HlsParser = class {
     // If unable to guess mime type, request a segment and try getting it
     // from the response.
     const headRequest = shaka.net.NetworkingEngine.makeRequest(
-        [middleSegmentUri], this.config_.retryParameters);
+        middleSegmentUris, this.config_.retryParameters);
     headRequest.method = 'HEAD';
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const response = await this.makeNetworkRequest_(
@@ -3637,14 +3789,17 @@ shaka.hls.HlsParser = class {
    * @param {?string} height
    * @param {?string} frameRate
    * @param {?string} videoRange
+   * @param {?string} videoLayout
    * @private
    */
-  addVideoAttributes_(stream, width, height, frameRate, videoRange) {
+  addVideoAttributes_(stream, width, height, frameRate, videoRange,
+      videoLayout) {
     if (stream) {
       stream.width = Number(width) || undefined;
       stream.height = Number(height) || undefined;
       stream.frameRate = Number(frameRate) || undefined;
       stream.hdr = videoRange || undefined;
+      stream.videoLayout = videoLayout || undefined;
     }
   }
 
@@ -3652,16 +3807,16 @@ shaka.hls.HlsParser = class {
    * Makes a network request for the manifest and returns a Promise
    * with the resulting data.
    *
-   * @param {string} absoluteUri
+   * @param {!Array.<string>} uris
    * @param {boolean=} isPlaylist
    * @return {!Promise.<!shaka.extern.Response>}
    * @private
    */
-  requestManifest_(absoluteUri, isPlaylist) {
+  requestManifest_(uris, isPlaylist) {
     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
 
     const request = shaka.net.NetworkingEngine.makeRequest(
-        [absoluteUri], this.config_.retryParameters);
+        uris, this.config_.retryParameters);
 
     const type = isPlaylist ?
         shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_PLAYLIST :
@@ -3690,12 +3845,20 @@ shaka.hls.HlsParser = class {
     }
 
     try {
+      const startTime = Date.now();
       await this.update();
 
+      // Keep track of how long the longest manifest update took.
+      const endTime = Date.now();
+
       // This may have converted to VOD, in which case we stop updating.
       if (this.isLive_()) {
+        const updateDuration = (endTime - startTime) / 1000.0;
+        this.averageUpdateDuration_.sample(1, updateDuration);
         const delay = this.getUpdatePlaylistDelay_();
-        this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
+        const finalDelay = Math.max(0,
+            delay - this.averageUpdateDuration_.getEstimate());
+        this.updatePlaylistTimer_.tickAfter(/* seconds= */ finalDelay);
       }
     } catch (error) {
       // Detect a call to stop() during this.update()
@@ -3718,6 +3881,13 @@ shaka.hls.HlsParser = class {
       // Try again very soon.
       this.updatePlaylistTimer_.tickAfter(/* seconds= */ 0.1);
     }
+
+    // Detect a call to stop()
+    if (!this.playerInterface_) {
+      return;
+    }
+
+    this.playerInterface_.onManifestUpdated();
   }
 
 
@@ -3932,8 +4102,8 @@ shaka.hls.HlsParser = class {
  * @typedef {{
  *   stream: !shaka.extern.Stream,
  *   type: string,
- *   verbatimMediaPlaylistUri: string,
- *   absoluteMediaPlaylistUri: string,
+ *   redirectUris: !Array.<string>,
+ *   getUris: function():!Array.<string>,
  *   minTimestamp: number,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
@@ -3953,14 +4123,10 @@ shaka.hls.HlsParser = class {
  *   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
- *   consistent key for this playlist, even if redirects cause us to update
- *   from different origins each time.
- * @property {string} absoluteMediaPlaylistUri
- *   The absolute media playlist URI, resolved relative to the master playlist
- *   and updated to reflect any redirects.
+ * @property {!Array.<string>} redirectUris
+ *   The redirect URIs.
+ * @property {function():!Array.<string>} getUris
+ *   The verbatim media playlist URIs, as it appeared in the master playlist.
  * @property {number} minTimestamp
  *   The minimum timestamp found in the stream.
  * @property {number} maxTimestamp
@@ -4002,30 +4168,6 @@ shaka.hls.HlsParser.StreamInfo;
 shaka.hls.HlsParser.StreamInfos;
 
 
-/**
- * @typedef {{
- *   type: string,
- *   mimeType: string,
- *   codecs: string,
- *   language: ?string,
- *   height: ?string,
- *   width: ?string,
- *   channelCount: ?number,
- *   sampleRate: ?number
- * }}
- *
- * @property {string} type
- * @property {string} mimeType
- * @property {string} codecs
- * @property {?string} language
- * @property {?string} height
- * @property {?string} width
- * @property {?number} channelCount
- * @property {?number} sampleRate
- */
-shaka.hls.HlsParser.BasicInfo;
-
-
 /**
  * @const {!Object.<string, string>}
  * @private
@@ -4147,8 +4289,6 @@ shaka.hls.HlsParser.PresentationType_ = {
   LIVE: 'LIVE',
 };
 
-shaka.media.ManifestParser.registerParserByExtension(
-    'm3u8', () => new shaka.hls.HlsParser());
 shaka.media.ManifestParser.registerParserByMime(
     'application/x-mpegurl', () => new shaka.hls.HlsParser());
 shaka.media.ManifestParser.registerParserByMime(