shaka-player 4.3.10 → 4.4.0

package/lib/hls/hls_parser.js

@@ -18,7 +18,6 @@ goog.require('shaka.log');
 goog.require('shaka.media.DrmEngine');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.ManifestParser');
-goog.require('shaka.media.MediaSourceEngine');
 goog.require('shaka.media.PresentationTimeline');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
@@ -26,16 +25,18 @@ goog.require('shaka.net.DataUriPlugin');
 goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
-goog.require('shaka.util.CmcdManager');
 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.util.Timer');
+goog.require('shaka.util.TsParser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.Uint8ArrayUtils');
 goog.require('shaka.util.XmlUtils');
@@ -130,15 +131,6 @@ shaka.hls.HlsParser = class {
     /** @private {shaka.hls.ManifestTextParser} */
     this.manifestTextParser_ = new shaka.hls.ManifestTextParser();
 
-    /**
-     * This is the number of seconds we want to wait between finishing a
-     * manifest update and starting the next one. This will be set when we parse
-     * the manifest.
-     *
-     * @private {number}
-     */
-    this.updatePlaylistDelay_ = 0;
-
     /**
      * The minimum sequence number for generated segments, when ignoring
      * EXT-X-PROGRAM-DATE-TIME.
@@ -186,13 +178,16 @@ shaka.hls.HlsParser = class {
     this.maxTargetDuration_ = 0;
 
     /** @private {number} */
-    this.minTargetDuration_ = Infinity;
+    this.lastTargetDuration_ = Infinity;
 
     /** Partial segments target duration.
      * @private {number}
      */
     this.partialTargetDuration_ = 0;
 
+    /** @private {number} */
+    this.presentationDelay_ = 0;
+
     /** @private {number} */
     this.lowLatencyPresentationDelay_ = 0;
 
@@ -217,6 +212,9 @@ shaka.hls.HlsParser = class {
 
     /** @private {boolean} */
     this.lowLatencyMode_ = false;
+
+    /** @private {boolean} */
+    this.lowLatencyByterangeOptimization_ = false;
   }
 
 
@@ -294,6 +292,9 @@ shaka.hls.HlsParser = class {
     const updates = [];
     const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
 
+    // This is necessary to calculate correctly the update time.
+    this.lastTargetDuration_ = Infinity;
+
     // Only update active streams.
     const activeStreamInfos = streamInfos.filter((s) => s.stream.segmentIndex);
     for (const streamInfo of activeStreamInfos) {
@@ -347,12 +348,30 @@ shaka.hls.HlsParser = class {
   async updateStream_(streamInfo) {
     const manifestUri = streamInfo.absoluteMediaPlaylistUri;
     const uriObj = new goog.Uri(manifestUri);
-    if (this.lowLatencyMode_ && streamInfo.canSkipSegments) {
+    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));
+      }
+      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.
-      uriObj.setQueryData(new goog.Uri.QueryData('_HLS_skip=YES'));
+      queryData.add('_HLS_skip', 'YES');
     }
-    const response = await this.requestManifest_(uriObj.toString());
+    if (queryData.getCount()) {
+      uriObj.setQueryData(queryData);
+    }
+    const response =
+        await this.requestManifest_(uriObj.toString(), /* isPlaylist= */ true);
     if (!streamInfo.stream.segmentIndex) {
       // The stream was closed since the update was first requested.
       return;
@@ -390,15 +409,25 @@ shaka.hls.HlsParser = class {
       this.playerInterface_.newDrmInfo(stream);
     }
 
-    const segments = this.createSegments_(
+    const {segments, bandwidth} = this.createSegments_(
         streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
         stream.mimeType, mediaSequenceToStartTime, mediaVariables);
 
+    stream.bandwidth = bandwidth;
+
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
     if (segments.length) {
       const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
           playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
+      const skipTag = shaka.hls.Utils.getFirstTagWithName(
+          playlist.tags, 'EXT-X-SKIP');
+      const skippedSegments =
+          skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
+      const {nextMediaSequence, nextPart} =
+          this.getNextMediaSequenceAndPart_(mediaSequenceNumber, segments);
+      streamInfo.nextMediaSequence = nextMediaSequence + skippedSegments;
+      streamInfo.nextPart = nextPart;
       const playlistStartTime = mediaSequenceToStartTime.get(
           mediaSequenceNumber);
       stream.segmentIndex.evict(playlistStartTime);
@@ -424,6 +453,8 @@ shaka.hls.HlsParser = class {
       // until we've seen the ENDLIST tag for all active playlists.
       streamInfo.hasEndList = true;
     }
+
+    this.determineLastTargetDuration_(playlist);
   }
 
 
@@ -613,7 +644,6 @@ shaka.hls.HlsParser = class {
    * @private
    */
   async parseManifest_(data, uri) {
-    const HlsParser = shaka.hls.HlsParser;
     const Utils = shaka.hls.Utils;
 
     goog.asserts.assert(this.masterPlaylistUri_,
@@ -636,44 +666,22 @@ shaka.hls.HlsParser = class {
 
     // Parsing a media playlist results in a single-variant stream.
     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
-      // Get necessary info for this stream, from the config. These are things
-      // we would normally find from the master playlist (e.g. from values on
-      // EXT-X-MEDIA tags).
-      let fullMimeType = this.config_.hls.mediaPlaylistFullMimeType;
-      // Try to infer the full mimetype better.
-      if (playlist.segments.length) {
-        const parsedUri = new goog.Uri(playlist.segments[0].absoluteUri);
-        const extension = parsedUri.getPath().split('.').pop();
-        let mimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
-        if (mimeType) {
-          fullMimeType = mimeType;
-        } else if (extension === 'ts') {
-          // TODO: Fetch one segment a use the TsParser to analize if there is
-          // video, audio or both.
-        } else if (extension === 'mp4') {
-          // TODO: Fetch one segment a use the Mp4Parser to analize if there is
-          // video, audio or both.
-        } else if (HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_[extension]) {
-          mimeType = HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_[extension];
-          const defaultAudioCodec = this.config_.hls.defaultAudioCodec;
-          fullMimeType = `${mimeType}; codecs="${defaultAudioCodec}"`;
-        } else if (HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_[extension]) {
-          mimeType = HlsParser.VIDEO_EXTENSIONS_TO_MIME_TYPES_[extension];
-          const defaultVideoCodec = this.config_.hls.defaultVideoCodec;
-          fullMimeType = `${mimeType}; codecs="${defaultVideoCodec}"`;
-        }
-      }
-
-      const mimeType = shaka.util.MimeUtils.getBasicType(fullMimeType);
-      const type = mimeType.split('/')[0];
-      const codecs = shaka.util.MimeUtils.getCodecs(fullMimeType);
+      // 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 type = basicInfo.type;
+      const mimeType = basicInfo.mimeType;
+      const codecs = basicInfo.codecs;
+      const languageValue = basicInfo.language;
+      const height = basicInfo.height;
+      const width = basicInfo.width;
+      const channelsCount = basicInfo.channelCount;
+      const sampleRate = basicInfo.sampleRate;
 
       // 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
       // relevant to ABR, which isn't necessary if there's only one variant.
       // So these unknowns should be set to false or null, largely.
-      const language = '';
-      const channelsCount = null;
       const spatialAudio = false;
       const characteristics = null;
       const closedCaptions = new Map();
@@ -683,20 +691,25 @@ shaka.hls.HlsParser = class {
 
       // Make the stream info, with those values.
       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
-          playlist, uri, uri, codecs, type, language, primary, name,
-          channelsCount, closedCaptions, characteristics, forced, spatialAudio,
-          mimeType);
+          playlist, uri, 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);
+      }
+
       // Wrap the stream from that stream info with a variant.
       variants.push({
         id: 0,
-        language: 'und',
+        language: this.getLanguage_(languageValue),
         disabledUntilTime: 0,
         primary: true,
         audio: type == 'audio' ? streamInfo.stream : null,
         video: type == 'video' ? streamInfo.stream : null,
-        bandwidth: 0,
+        bandwidth: streamInfo.stream.bandwidth || 0,
         allowedByApplication: true,
         allowedByKeySystem: true,
         decodingInfos: [],
@@ -775,7 +788,7 @@ shaka.hls.HlsParser = class {
     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
       if (this.isLive_()) {
         this.changePresentationTimelineToLive_();
-        const delay = this.updatePlaylistDelay_;
+        const delay = this.getUpdatePlaylistDelay_();
         this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
       }
       const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
@@ -790,24 +803,322 @@ shaka.hls.HlsParser = class {
       imageStreams,
       offlineSessionIds: [],
       minBufferTime: 0,
-      sequenceMode: true,
+      sequenceMode: this.config_.hls.sequenceMode,
+      ignoreManifestTimestampsInSegmentsMode:
+        this.config_.hls.ignoreManifestTimestampsInSegmentsMode,
+      type: shaka.media.ManifestParser.HLS,
+      serviceDescription: null,
     };
     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
   }
 
+  /**
+   * @param {shaka.hls.Playlist} playlist
+   * @return {!Promise.<shaka.hls.HlsParser.BasicInfo>}
+   * @private
+   */
+  async getMediaPlaylistBasicInfo_(playlist) {
+    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,
+    };
+    if (!playlist.segments.length) {
+      return defaultBasicInfo;
+    }
+    const firstSegment = playlist.segments[0];
+    const parsedUri = new goog.Uri(firstSegment.absoluteUri);
+    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,
+      };
+    }
+
+    let segmentUris = [firstSegment.absoluteUri];
+    const initSegmentRef = this.getInitSegmentReference_(
+        playlist.absoluteUri, firstSegment.tags, new Map());
+    if (initSegmentRef) {
+      segmentUris = initSegmentRef.getUris();
+    }
+
+    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;
+    const response = await this.makeNetworkRequest_(
+        segmentRequest, requestType, {type});
+
+    let contentMimeType = response.headers['content-type'];
+    if (contentMimeType) {
+      // Split the MIME type in case the server sent additional parameters.
+      contentMimeType = contentMimeType.split(';')[0].toLowerCase();
+    }
+
+    if (extension == 'ts' || contentMimeType == 'video/mp2t') {
+      const basicInfo = this.getBasicInfoFromTs_(response);
+      if (basicInfo) {
+        return basicInfo;
+      }
+    } else if (extension == 'mp4' ||
+        contentMimeType == 'video/mp4' || contentMimeType == 'audio/mp4') {
+      const basicInfo = this.getBasicInfoFromMp4_(response);
+      if (basicInfo) {
+        return basicInfo;
+      }
+    }
+    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 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':
+        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;
+    const videoResolution = tsParser.getVideoResolution();
+    return {
+      type: onlyAudio ? 'audio' : 'video',
+      mimeType: 'video/mp2t',
+      codecs: codecs.join(', '),
+      language: null,
+      height: videoResolution.height,
+      width: videoResolution.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_,
         'Presentation timeline not created!');
 
     if (this.isLive_()) {
-      // The HLS spec (RFC 8216) states in 6.3.4:
-      // "the client MUST wait for at least the target duration before
-      // attempting to reload the Playlist file again".
-      // For LL-HLS, the server must add a new partial segment to the Playlist
-      // every part target duration.
-      this.updatePlaylistDelay_ = this.minTargetDuration_;
-
       // The spec says nothing much about seeking in live content, but Safari's
       // built-in HLS implementation does not allow it.  Therefore we will set
       // the availability window equal to the presentation delay.  The player
@@ -1209,6 +1520,16 @@ shaka.hls.HlsParser = class {
     /** @type {!Array.<string>} */
     const codecs = codecsString.split(/\s*,\s*/);
 
+    return this.filterDuplicateCodecs_(codecs);
+  }
+
+
+  /**
+   * @param {!Array.<string>} codecs
+   * @return {!Array.<string>} codecs
+   * @private
+   */
+  filterDuplicateCodecs_(codecs) {
     // Filter out duplicate codecs.
     const seen = new Set();
     const ret = [];
@@ -1250,6 +1571,21 @@ shaka.hls.HlsParser = class {
     return count;
   }
 
+  /**
+   * Get the sample rate information for an HLS audio track.
+   *
+   * @param {!shaka.hls.Tag} tag
+   * @return {?number}
+   * @private
+   */
+  getSampleRate_(tag) {
+    const sampleRate = tag.getAttributeValue('SAMPLE-RATE');
+    if (!sampleRate) {
+      return null;
+    }
+    return parseInt(sampleRate, 10);
+  }
+
   /**
    * Get the spatial audio information for an HLS audio track.
    * In HLS the channels field indicates the number of audio channels that the
@@ -1298,16 +1634,15 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * Get the language value.
+   * Get the normalized language value.
    *
-   * @param {!shaka.hls.Tag} tag
+   * @param {?string} languageValue
    * @return {string}
    * @private
    */
-  getLanguage_(tag) {
+  getLanguage_(languageValue) {
     const LanguageUtils = shaka.util.LanguageUtils;
-    const languageValue = tag.getAttributeValue('LANGUAGE') || 'und';
-    return LanguageUtils.normalize(languageValue);
+    return LanguageUtils.normalize(languageValue || 'und');
   }
 
   /**
@@ -1409,6 +1744,7 @@ shaka.hls.HlsParser = class {
         const variant = {
           id: this.globalId_++,
           language: audioStream ? audioStream.language : 'und',
+          disabledUntilTime: 0,
           primary: (!!audioStream && audioStream.primary) ||
               (!!videoStream && videoStream.primary),
           audio: audioStream,
@@ -1439,7 +1775,8 @@ shaka.hls.HlsParser = class {
     for (const tag of closedCaptionsTags) {
       goog.asserts.assert(tag.name == 'EXT-X-MEDIA',
           'Should only be called on media tags!');
-      const language = this.getLanguage_(tag);
+      const languageValue = tag.getAttributeValue('LANGUAGE');
+      const language = this.getLanguage_(languageValue);
 
       // The GROUP-ID value is a quoted-string that specifies the group to which
       // the Rendition belongs.
@@ -1485,7 +1822,7 @@ shaka.hls.HlsParser = class {
       return this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
     }
 
-    const language = this.getLanguage_(tag);
+    const language = tag.getAttributeValue('LANGUAGE');
     const name = tag.getAttributeValue('NAME');
 
     // NOTE: According to the HLS spec, "DEFAULT=YES" requires "AUTOSELECT=YES".
@@ -1503,12 +1840,13 @@ shaka.hls.HlsParser = class {
 
     const forcedAttrValue = tag.getAttributeValue('FORCED');
     const forced = forcedAttrValue == 'YES';
+    const sampleRate = type == 'audio' ? this.getSampleRate_(tag) : 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,
-        spatialAudio);
+        sampleRate, spatialAudio);
     if (this.groupIdToStreamInfosMap_.has(groupId)) {
       this.groupIdToStreamInfosMap_.get(groupId).push(streamInfo);
     } else {
@@ -1547,7 +1885,7 @@ shaka.hls.HlsParser = class {
       return this.uriToStreamInfosMap_.get(verbatimImagePlaylistUri);
     }
 
-    const language = this.getLanguage_(tag);
+    const language = tag.getAttributeValue('LANGUAGE');
     const name = tag.getAttributeValue('NAME');
 
     const characteristics = tag.getAttributeValue('CHARACTERISTICS');
@@ -1555,7 +1893,8 @@ shaka.hls.HlsParser = class {
     const streamInfo = this.createStreamInfo_(
         verbatimImagePlaylistUri, codecs, type, language, /* primary= */ false,
         name, /* channelsCount= */ null, /* closedCaptions= */ null,
-        characteristics, /* forced= */ false, /* spatialAudio= */ false);
+        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.
@@ -1616,10 +1955,10 @@ shaka.hls.HlsParser = class {
     const closedCaptions = this.getClosedCaptions_(tag, type);
     const codecs = shaka.util.ManifestParserUtils.guessCodecs(type, allCodecs);
     const streamInfo = this.createStreamInfo_(verbatimMediaPlaylistUri,
-        codecs, type, /* language= */ 'und', /* primary= */ false,
+        codecs, type, /* language= */ null, /* primary= */ false,
         /* name= */ null, /* channelcount= */ null, closedCaptions,
         /* characteristics= */ null, /* forced= */ false,
-        /* spatialAudio= */ 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)) {
@@ -1635,20 +1974,21 @@ shaka.hls.HlsParser = class {
    * @param {string} verbatimMediaPlaylistUri
    * @param {string} codecs
    * @param {string} type
-   * @param {string} language
+   * @param {?string} languageValue
    * @param {boolean} primary
    * @param {?string} name
    * @param {?number} channelsCount
    * @param {Map.<string, string>} closedCaptions
    * @param {?string} characteristics
    * @param {boolean} forced
+   * @param {?number} sampleRate
    * @param {boolean} spatialAudio
    * @return {!shaka.hls.HlsParser.StreamInfo}
    * @private
    */
-  createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
+  createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, languageValue,
       primary, name, channelsCount, closedCaptions, characteristics, forced,
-      spatialAudio) {
+      sampleRate, spatialAudio) {
     // TODO: Refactor, too many parameters
     const initialMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
         this.masterPlaylistUri_, verbatimMediaPlaylistUri);
@@ -1656,11 +1996,9 @@ shaka.hls.HlsParser = class {
     // This stream is lazy-loaded inside the createSegmentIndex function.
     // So we start out with a stream object that does not contain the actual
     // segment index, then download when createSegmentIndex is called.
-    const stream = this.makeStreamObject_(codecs, type, language, primary, name,
-        channelsCount, closedCaptions, characteristics, forced, spatialAudio);
-    if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
-      stream.codecs = '';
-    }
+    const stream = this.makeStreamObject_(codecs, type, languageValue, primary,
+        name, channelsCount, closedCaptions, characteristics, forced,
+        sampleRate, spatialAudio);
     const streamInfo = {
       stream,
       type,
@@ -1671,8 +2009,11 @@ shaka.hls.HlsParser = class {
       maxTimestamp: 0,
       mediaSequenceToStartTime: new Map(),
       canSkipSegments: false,
+      canBlockReload: false,
       hasEndList: false,
       firstSequenceNumber: -1,
+      nextMediaSequence: -1,
+      nextPart: -1,
       loadedOnce: false,
     };
 
@@ -1680,7 +2021,7 @@ shaka.hls.HlsParser = class {
     const downloadSegmentIndex = async (abortSignal) => {
       // Download the actual manifest.
       const response = await this.requestManifest_(
-          streamInfo.absoluteMediaPlaylistUri);
+          streamInfo.absoluteMediaPlaylistUri, /* isPlaylist= */ true);
       if (abortSignal.aborted) {
         return;
       }
@@ -1697,8 +2038,8 @@ shaka.hls.HlsParser = class {
       const wasLive = this.isLive_();
       const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
           playlist, verbatimMediaPlaylistUri, absoluteMediaPlaylistUri, codecs,
-          type, language, primary, name, channelsCount, closedCaptions,
-          characteristics, forced, spatialAudio);
+          type, languageValue, primary, name, channelsCount, closedCaptions,
+          characteristics, forced, sampleRate, spatialAudio);
       if (abortSignal.aborted) {
         return;
       }
@@ -1716,18 +2057,19 @@ shaka.hls.HlsParser = class {
       streamInfo.minTimestamp = realStreamInfo.minTimestamp;
       streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
       streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
+      streamInfo.canBlockReload = realStreamInfo.canBlockReload;
       streamInfo.hasEndList = realStreamInfo.hasEndList;
       streamInfo.mediaSequenceToStartTime =
           realStreamInfo.mediaSequenceToStartTime;
+      streamInfo.nextMediaSequence = realStreamInfo.nextMediaSequence;
+      streamInfo.nextPart = realStreamInfo.nextPart;
       streamInfo.loadedOnce = true;
       stream.segmentIndex = realStream.segmentIndex;
       stream.encrypted = realStream.encrypted;
       stream.drmInfos = realStream.drmInfos;
       stream.keyIds = realStream.keyIds;
       stream.mimeType = realStream.mimeType;
-      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
-        stream.codecs = '';
-      }
+      stream.bandwidth = realStream.bandwidth;
 
       // Since we lazy-loaded this content, the player may need to create new
       // sessions for the DRM info in this stream.
@@ -1742,10 +2084,6 @@ shaka.hls.HlsParser = class {
             // To aid manifest filtering, assume before loading that all video
             // renditions have the same MIME type.  (And likewise for audio.)
             otherStreamInfo.stream.mimeType = realStream.mimeType;
-            if (shaka.media.MediaSourceEngine.RAW_FORMATS
-                .includes(otherStreamInfo.stream.mimeType)) {
-              otherStreamInfo.stream.codecs = '';
-            }
           }
         }
       }
@@ -1775,7 +2113,7 @@ shaka.hls.HlsParser = class {
           this.determineDuration_();
           // Finally, start the update timer, if this asset has been determined
           // to be a livestream.
-          const delay = this.updatePlaylistDelay_;
+          const delay = this.getUpdatePlaylistDelay_();
           if (delay > 0) {
             this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
           }
@@ -1892,13 +2230,6 @@ shaka.hls.HlsParser = class {
         streamInfo.stream.segmentIndex.fit(/* periodStart= */ 0, minDuration);
       }
     }
-    // MediaSource expects no codec strings combined with raw formats.
-    for (const streamInfo of streamInfos) {
-      const stream = streamInfo.stream;
-      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(stream.mimeType)) {
-        stream.codecs = '';
-      }
-    }
     this.notifySegmentsForStreams_(streamInfos.map((s) => s.stream));
     if (this.config_.hls.ignoreManifestProgramDateTime) {
       this.syncStreamsWithSequenceNumber_(streamInfos);
@@ -1945,22 +2276,23 @@ shaka.hls.HlsParser = class {
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} codecs
    * @param {string} type
-   * @param {string} language
+   * @param {?string} languageValue
    * @param {boolean} primary
    * @param {?string} name
    * @param {?number} channelsCount
    * @param {Map.<string, string>} closedCaptions
    * @param {?string} characteristics
    * @param {boolean} forced
+   * @param {?number} sampleRate
    * @param {boolean} spatialAudio
    * @param {(string|undefined)} mimeType
    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async convertParsedPlaylistIntoStreamInfo_(playlist, verbatimMediaPlaylistUri,
-      absoluteMediaPlaylistUri, codecs, type, language, primary, name,
-      channelsCount, closedCaptions, characteristics, forced, spatialAudio,
-      mimeType = undefined) {
+      absoluteMediaPlaylistUri, codecs, type, languageValue, primary, name,
+      channelsCount, closedCaptions, characteristics, forced, sampleRate,
+      spatialAudio, mimeType = undefined) {
     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
       // EXT-X-MEDIA and EXT-X-IMAGE-STREAM-INF tags should point to media
       // playlists.
@@ -1981,6 +2313,10 @@ shaka.hls.HlsParser = class {
 
     this.determinePresentationType_(playlist);
 
+    if (this.isLive_()) {
+      this.determineLastTargetDuration_(playlist);
+    }
+
     if (!mimeType) {
       mimeType = await this.guessMimeType_(type, codecs, playlist,
           mediaVariables);
@@ -1998,18 +2334,18 @@ shaka.hls.HlsParser = class {
 
     const mediaSequenceToStartTime = this.isLive_() ?
         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
-    const prevLowLatencyMode = this.lowLatencyMode_;
-    const segments = this.createSegments_(verbatimMediaPlaylistUri, playlist,
-        type, mimeType, mediaSequenceToStartTime, mediaVariables);
+    const {segments, bandwidth} = this.createSegments_(
+        verbatimMediaPlaylistUri, playlist, type, mimeType,
+        mediaSequenceToStartTime, mediaVariables);
 
-    // This happens when autoLowLatencyMode is true, so we need set the
-    // correct lowLatencyPresentationDelay_
-    if (prevLowLatencyMode != this.lowLatencyMode_) {
-      this.determinePresentationType_(playlist);
+    // This new calculation is necessary for Low Latency streams.
+    if (this.isLive_()) {
+      this.determineLastTargetDuration_(playlist);
     }
 
     const firstStartTime = segments[0].startTime;
-    const lastEndTime = segments[segments.length - 1].endTime;
+    const lastSegment = segments[segments.length - 1];
+    const lastEndTime = lastSegment.endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
 
@@ -2017,14 +2353,24 @@ shaka.hls.HlsParser = class {
         playlist.tags, 'EXT-X-SERVER-CONTROL');
     const canSkipSegments = serverControlTag ?
           serverControlTag.getAttribute('CAN-SKIP-UNTIL') != null : false;
+    const canBlockReload = serverControlTag ?
+          serverControlTag.getAttribute('CAN-BLOCK-RELOAD') != null : false;
 
-    const stream = this.makeStreamObject_(codecs, type, language, primary, name,
-        channelsCount, closedCaptions, characteristics, forced, spatialAudio);
+    const mediaSequenceNumber = shaka.hls.Utils.getFirstTagWithNameAsNumber(
+        playlist.tags, 'EXT-X-MEDIA-SEQUENCE', 0);
+
+    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,
@@ -2034,13 +2380,60 @@ shaka.hls.HlsParser = class {
       minTimestamp: firstStartTime,
       maxTimestamp: lastEndTime,
       canSkipSegments,
+      canBlockReload,
       hasEndList: false,
       firstSequenceNumber: -1,
+      nextMediaSequence,
+      nextPart,
       mediaSequenceToStartTime,
       loadedOnce: false,
     };
   }
 
+  /**
+   * Get the next msn and part
+   *
+   * @param {number} mediaSequenceNumber
+   * @param {!Array.<!shaka.media.SegmentReference>} segments
+   * @return {{nextMediaSequence: number, nextPart:number}}}
+   * @private
+   */
+  getNextMediaSequenceAndPart_(mediaSequenceNumber, segments) {
+    const currentMediaSequence = mediaSequenceNumber + segments.length - 1;
+    let nextMediaSequence = currentMediaSequence;
+    let nextPart = -1;
+    if (!segments.length) {
+      nextMediaSequence++;
+      return {
+        nextMediaSequence,
+        nextPart,
+      };
+    }
+    const lastSegment = segments[segments.length - 1];
+    const partialReferences = lastSegment.partialReferences;
+    if (!lastSegment.partialReferences.length) {
+      nextMediaSequence++;
+      if (lastSegment.hasByterangeOptimization()) {
+        nextPart = 0;
+      }
+      return {
+        nextMediaSequence,
+        nextPart,
+      };
+    }
+    nextPart = partialReferences.length - 1;
+    const lastPartialReference =
+        partialReferences[partialReferences.length - 1];
+    if (!lastPartialReference.isPreload()) {
+      nextMediaSequence++;
+      nextPart = 0;
+    }
+    return {
+      nextMediaSequence,
+      nextPart,
+    };
+  }
+
 
   /**
    * Creates a stream object with the given parameters.
@@ -2049,19 +2442,20 @@ shaka.hls.HlsParser = class {
    * manually on the object after creation.
    * @param {string} codecs
    * @param {string} type
-   * @param {string} language
+   * @param {?string} languageValue
    * @param {boolean} primary
    * @param {?string} name
    * @param {?number} channelsCount
    * @param {Map.<string, string>} closedCaptions
    * @param {?string} characteristics
    * @param {boolean} forced
+   * @param {?number} sampleRate
    * @param {boolean} spatialAudio
    * @return {!shaka.extern.Stream}
    * @private
    */
-  makeStreamObject_(codecs, type, language, primary, name, channelsCount,
-      closedCaptions, characteristics, forced, spatialAudio) {
+  makeStreamObject_(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) ||
@@ -2090,11 +2484,13 @@ shaka.hls.HlsParser = class {
       segmentIndex: null,
       mimeType,
       codecs,
-      kind,
+      kind: (type == shaka.util.ManifestParserUtils.ContentType.TEXT) ?
+          shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE : undefined,
       encrypted: false,
       drmInfos: [],
       keyIds: new Set(),
-      language,
+      language: this.getLanguage_(languageValue),
+      originalLanguage: languageValue,
       label: name,  // For historical reasons, since before "originalId".
       type,
       primary,
@@ -2109,11 +2505,12 @@ shaka.hls.HlsParser = class {
       roles,
       forced,
       channelsCount,
-      audioSamplingRate: null,
+      audioSamplingRate: sampleRate,
       spatialAudio,
       closedCaptions,
       hdr: undefined,
       tilesLayout: undefined,
+      accessibilityPurpose: null,
       external: false,
     };
   }
@@ -2284,43 +2681,89 @@ shaka.hls.HlsParser = class {
       } else {
         this.setPresentationType_(PresentationType.EVENT);
       }
+    }
+  }
+
+
+  /**
+   * @param {!shaka.hls.Playlist} playlist
+   * @private
+   */
+  determineLastTargetDuration_(playlist) {
+    let lastTargetDuration = Infinity;
+    const segments = playlist.segments;
+    if (segments.length) {
+      let segmentIndex = segments.length - 1;
+      while (segmentIndex >= 0) {
+        const segment = segments[segmentIndex];
+        const extinfTag =
+            shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXTINF');
+        if (extinfTag) {
+          // The EXTINF tag format is '#EXTINF:<duration>,[<title>]'.
+          // We're interested in the duration part.
+          const extinfValues = extinfTag.value.split(',');
+          lastTargetDuration = Number(extinfValues[0]);
+          break;
+        }
+        segmentIndex--;
+      }
+    }
 
-      const targetDurationTag = this.getRequiredTag_(playlist.tags,
-          'EXT-X-TARGETDURATION');
-      const targetDuration = Number(targetDurationTag.value);
-      const partialTargetDurationTag =
-        shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-PART-INF');
-      // According to the HLS spec, updates should not happen more often than
-      // once in targetDuration.  It also requires us to only update the active
-      // variant.  We might implement that later, but for now every variant
-      // will be updated.  To get the update period, choose the smallest
-      // targetDuration value across all playlists.
-      // 1. Update the shortest one to use as update period and segment
-      // availability time (for LIVE).
-      if (this.lowLatencyMode_ && partialTargetDurationTag) {
-        // For low latency streaming, use the partial segment target duration.
-        this.partialTargetDuration_ = Number(
-            partialTargetDurationTag.getRequiredAttrValue('PART-TARGET'));
-        this.minTargetDuration_ = Math.min(
-            this.partialTargetDuration_, this.minTargetDuration_);
-        // Get the server-recommended min distance from the live edge.
-        const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
-            playlist.tags, 'EXT-X-SERVER-CONTROL');
-        // Use 'PART-HOLD-BACK' as the presentation delay for low latency mode.
-        this.lowLatencyPresentationDelay_ = serverControlTag ? Number(
-            serverControlTag.getRequiredAttrValue('PART-HOLD-BACK')) : 0;
+    const targetDurationTag = this.getRequiredTag_(playlist.tags,
+        'EXT-X-TARGETDURATION');
+    const targetDuration = Number(targetDurationTag.value);
+    const partialTargetDurationTag =
+      shaka.hls.Utils.getFirstTagWithName(playlist.tags, 'EXT-X-PART-INF');
+    if (partialTargetDurationTag) {
+      this.partialTargetDuration_ = Number(
+          partialTargetDurationTag.getRequiredAttrValue('PART-TARGET'));
+    }
+    // Get the server-recommended min distance from the live edge.
+    const serverControlTag = shaka.hls.Utils.getFirstTagWithName(
+        playlist.tags, 'EXT-X-SERVER-CONTROL');
+    // According to the HLS spec, updates should not happen more often than
+    // once in targetDuration.  It also requires us to only update the active
+    // variant.  We might implement that later, but for now every variant
+    // will be updated.  To get the update period, choose the smallest
+    // targetDuration value across all playlists.
+    // 1. Update the shortest one to use as update period and segment
+    // availability time (for LIVE).
+    if (this.lowLatencyMode_ && this.partialTargetDuration_) {
+      // For low latency streaming, use the partial segment target duration.
+      if (this.lowLatencyByterangeOptimization_) {
+        // We always have at least 1 partial segment part, and most servers
+        // allow you to make a request with _HLS_msn=X&_HLS_part=0 with a
+        // distance of 4 partial segments.  With this we ensure that we
+        // obtain the minimum latency in this type of case.
+        if (this.partialTargetDuration_ * 5 <= lastTargetDuration) {
+          this.lastTargetDuration_ = Math.min(
+              this.partialTargetDuration_, this.lastTargetDuration_);
+        } else {
+          this.lastTargetDuration_ = Math.min(
+              lastTargetDuration, this.lastTargetDuration_);
+        }
       } else {
-        // For regular HLS, use the target duration of regular segments.
-        this.minTargetDuration_ = Math.min(
-            targetDuration, this.minTargetDuration_);
+        this.lastTargetDuration_ = Math.min(
+            this.partialTargetDuration_, this.lastTargetDuration_);
       }
-      // 2. Update the longest target duration if need be to use as a
-      // presentation delay later.
-      this.maxTargetDuration_ = Math.max(
-          targetDuration, this.maxTargetDuration_);
+      // Use 'PART-HOLD-BACK' as the presentation delay for low latency mode.
+      this.lowLatencyPresentationDelay_ = serverControlTag ? Number(
+          serverControlTag.getRequiredAttrValue('PART-HOLD-BACK')) : 0;
+    } else {
+      this.lastTargetDuration_ = Math.min(
+          lastTargetDuration, this.lastTargetDuration_);
+      // Use 'HOLD-BACK' as the presentation delay for default if defined.
+      const holdBack = serverControlTag ?
+          serverControlTag.getAttribute('HOLD-BACK') : null;
+      this.presentationDelay_ = holdBack ? Number(holdBack.value) : 0;
     }
+    // 2. Update the longest target duration if need be to use as a
+    // presentation delay later.
+    this.maxTargetDuration_ = Math.max(
+        targetDuration, this.maxTargetDuration_);
   }
 
+
   /**
    * @private
    */
@@ -2344,6 +2787,8 @@ shaka.hls.HlsParser = class {
       presentationDelay = this.config_.defaultPresentationDelay;
     } else if (this.lowLatencyPresentationDelay_) {
       presentationDelay = this.lowLatencyPresentationDelay_;
+    } else if (this.presentationDelay_) {
+      presentationDelay = this.presentationDelay_;
     } else {
       const numberOfSegments = this.config_.hls.liveSegmentsDelay;
       presentationDelay = this.maxTargetDuration_ * numberOfSegments;
@@ -2426,6 +2871,7 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} type
+   * @param {string} mimeType
    * @param {number} timestampOffset
    * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
    * @return {shaka.media.SegmentReference}
@@ -2433,11 +2879,9 @@ shaka.hls.HlsParser = class {
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, absoluteMediaPlaylistUri, type, timestampOffset,
+      variables, absoluteMediaPlaylistUri, type, mimeType, timestampOffset,
       hlsAes128Key) {
     const tags = hlsSegment.tags;
-    const absoluteSegmentUri = this.variableSubstitution_(
-        hlsSegment.absoluteUri, variables);
     const extinfTag =
         shaka.hls.Utils.getFirstTagWithName(tags, 'EXTINF');
 
@@ -2483,8 +2927,20 @@ shaka.hls.HlsParser = class {
     }
 
     // Create SegmentReferences for the partial segments.
-    const partialSegmentRefs = [];
-    if (this.lowLatencyMode_) {
+    let partialSegmentRefs = [];
+
+    // Optimization for LL-HLS with byterange
+    // More info in https://tinyurl.com/hls-open-byte-range
+    let segmentWithByteRangeOptimization = false;
+    let getUrisOptimization = null;
+    let somePartialSegmentWithGap = false;
+    let isPreloadSegment = false;
+
+    if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
+      const byterangeOptimizationSupport = (mimeType == 'video/mp4' ||
+          mimeType == 'audio/mp4') && window.ReadableStream;
+
+      let partialSyncTime = syncTime;
       for (let i = 0; i < hlsSegment.partialSegments.length; i++) {
         const item = hlsSegment.partialSegments[i];
         const pPreviousReference = i == 0 ?
@@ -2512,6 +2968,16 @@ shaka.hls.HlsParser = class {
           // A preload hinted partial segment may have byterange start info.
           const pByterangeStart = item.getAttributeValue('BYTERANGE-START');
           pStartByte = pByterangeStart ? Number(pByterangeStart) : 0;
+          // A preload hinted partial segment may have byterange length info.
+          const pByterangeLength = item.getAttributeValue('BYTERANGE-LENGTH');
+          if (pByterangeLength) {
+            pEndByte = pStartByte + Number(pByterangeLength) - 1;
+          } else if (pStartByte) {
+            // If we have a non-zero start byte, but no end byte, follow the
+            // recommendation of https://tinyurl.com/hls-open-byte-range and
+            // set the end byte explicitly to a large integer.
+            pEndByte = Number.MAX_SAFE_INTEGER;
+          }
         } else {
           const pByterange = item.getAttributeValue('BYTERANGE');
           [pStartByte, pEndByte] =
@@ -2521,20 +2987,33 @@ shaka.hls.HlsParser = class {
         if (!pUri) {
           continue;
         }
-        const pAbsoluteUri = shaka.hls.Utils.constructAbsoluteUri(
-            absoluteMediaPlaylistUri, pUri);
 
         let partialStatus = shaka.media.SegmentReference.Status.AVAILABLE;
         if (item.getAttributeValue('GAP') == 'YES') {
           partialStatus = shaka.media.SegmentReference.Status.MISSING;
+          somePartialSegmentWithGap = true;
+        }
+
+        let pAbsoluteUri = null;
+        const getPartialUris = () => {
+          if (pAbsoluteUri == null) {
+            goog.asserts.assert(pUri, 'Partial uri should be defined!');
+            pAbsoluteUri = shaka.hls.Utils.constructAbsoluteUri(
+                absoluteMediaPlaylistUri, pUri);
+          }
+          return [pAbsoluteUri];
+        };
+
+        if (byterangeOptimizationSupport &&
+            pStartByte >= 0 && pEndByte != null) {
+          getUrisOptimization = getPartialUris;
+          segmentWithByteRangeOptimization = true;
         }
 
-        // We do not set the AES-128 key information for partial segments, as we
-        // do not support AES-128 and low-latency at the same time.
         const partial = new shaka.media.SegmentReference(
             pStartTime,
             pEndTime,
-            () => [pAbsoluteUri],
+            getPartialUris,
             pStartByte,
             pEndByte,
             initSegmentReference,
@@ -2544,12 +3023,25 @@ shaka.hls.HlsParser = class {
             /* partialReferences= */ [],
             /* tilesLayout= */ '',
             /* tileDuration= */ null,
-            /* syncTime= */ null,
-            partialStatus);
+            partialSyncTime,
+            partialStatus,
+            hlsAes128Key);
         if (item.name == 'EXT-X-PRELOAD-HINT') {
           partial.markAsPreload();
+          isPreloadSegment = true;
+        }
+        // The spec doesn't say that we can assume INDEPENDENT=YES for the
+        // first partial segment. It does call the flag "optional", though, and
+        // that cases where there are no such flags on any partial segments, it
+        // is sensible to assume the first one is independent.
+        if (item.getAttributeValue('INDEPENDENT') != 'YES' && i > 0) {
+          partial.markAsNonIndependent();
         }
         partialSegmentRefs.push(partial);
+
+        if (partialSyncTime) {
+          partialSyncTime += pDuration;
+        }
       } // for-loop of hlsSegment.partialSegments
     }
 
@@ -2574,6 +3066,17 @@ shaka.hls.HlsParser = class {
       endTime = partialSegmentRefs[partialSegmentRefs.length - 1].endTime;
     }
 
+    if (segmentWithByteRangeOptimization) {
+      // We cannot optimize segments with gaps, or with a start byte that is
+      // not 0.
+      if (somePartialSegmentWithGap || partialSegmentRefs[0].startByte != 0) {
+        segmentWithByteRangeOptimization = false;
+        getUrisOptimization = null;
+      } else {
+        partialSegmentRefs = [];
+      }
+    }
+
     // If the segment has EXT-X-BYTERANGE tag, set the start byte and end byte
     // base on the byterange information. If segment has no EXT-X-BYTERANGE tag
     // and has partial segments, set the start byte and end byte base on the
@@ -2604,10 +3107,22 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    return new shaka.media.SegmentReference(
+    let absoluteSegmentUri = null;
+    const getUris = () => {
+      if (getUrisOptimization) {
+        return getUrisOptimization();
+      }
+      if (absoluteSegmentUri == null) {
+        absoluteSegmentUri = this.variableSubstitution_(
+            hlsSegment.absoluteUri, variables);
+      }
+      return absoluteSegmentUri.length ? [absoluteSegmentUri] : [];
+    };
+
+    const reference = new shaka.media.SegmentReference(
         startTime,
         endTime,
-        () => absoluteSegmentUri.length ? [absoluteSegmentUri] : [],
+        getUris,
         startByte,
         endByte,
         initSegmentReference,
@@ -2621,6 +3136,17 @@ shaka.hls.HlsParser = class {
         status,
         hlsAes128Key,
     );
+
+    if (segmentWithByteRangeOptimization) {
+      this.lowLatencyByterangeOptimization_ = true;
+      reference.markAsByterangeOptimization();
+
+      if (isPreloadSegment) {
+        reference.markAsPreload();
+      }
+    }
+
+    return reference;
   }
 
 
@@ -2652,7 +3178,9 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences.
+   * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences and
+   * get the bandwidth necessary for this segments If it's defined in the
+   * playlist.
    *
    * @param {string} verbatimMediaPlaylistUri
    * @param {!shaka.hls.Playlist} playlist
@@ -2660,7 +3188,8 @@ shaka.hls.HlsParser = class {
    * @param {string} mimeType
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
-   * @return {!Array.<!shaka.media.SegmentReference>}
+   * @return {{segments: !Array.<!shaka.media.SegmentReference>,
+   *          bandwidth: (number|undefined)}}
    * @private
    */
   createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
@@ -2698,6 +3227,9 @@ shaka.hls.HlsParser = class {
     let previousReference = null;
     let lastDiscontinuityStartTime = firstStartTime;
 
+    /** @type {!Array.<{bitrate: number, duration: number}>} */
+    const bitrates = [];
+
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
       const startTime =
@@ -2747,10 +3279,26 @@ shaka.hls.HlsParser = class {
           variables,
           playlist.absoluteUri,
           type,
+          mimeType,
           lastDiscontinuityStartTime,
           hlsAes128Key);
 
       if (reference) {
+        const bitrate = shaka.hls.Utils.getFirstTagWithNameAsNumber(
+            item.tags, 'EXT-X-BITRATE');
+        if (bitrate) {
+          bitrates.push({
+            bitrate,
+            duration: reference.endTime - reference.startTime,
+          });
+        } else if (bitrates.length) {
+          // It applies to every segment between it and the next EXT-X-BITRATE,
+          // so we use the latest bitrate value
+          const prevBitrate = bitrates.pop();
+          prevBitrate.duration += reference.endTime - reference.startTime;
+          bitrates.push(prevBitrate);
+        }
+
         previousReference = reference;
         reference.discontinuitySequence = discontinuitySequence;
 
@@ -2765,6 +3313,16 @@ shaka.hls.HlsParser = class {
       }
     }
 
+    let bandwidth = undefined;
+    if (bitrates.length) {
+      const duration = bitrates.reduce((sum, value) => {
+        return sum + value.duration;
+      }, 0);
+      bandwidth = Math.round(bitrates.reduce((sum, value) => {
+        return sum + value.bitrate * value.duration;
+      }, 0) / duration * 1000);
+    }
+
     // If some segments have sync times, but not all, extrapolate the sync
     // times of the ones with none.
     const someSyncTime = references.some((ref) => ref.syncTime != null);
@@ -2850,7 +3408,10 @@ shaka.hls.HlsParser = class {
       }
     }
 
-    return references;
+    return {
+      segments: references,
+      bandwidth,
+    };
   }
 
   /**
@@ -2995,9 +3556,9 @@ shaka.hls.HlsParser = class {
     const headRequest = shaka.net.NetworkingEngine.makeRequest(
         [middleSegmentUri], this.config_.retryParameters);
     headRequest.method = 'HEAD';
-
+    const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const response = await this.makeNetworkRequest_(
-        headRequest, requestType);
+        headRequest, requestType, {type});
 
     const contentMimeType = response.headers['content-type'];
     if (contentMimeType) {
@@ -3051,19 +3612,20 @@ shaka.hls.HlsParser = class {
    * with the resulting data.
    *
    * @param {string} absoluteUri
+   * @param {boolean=} isPlaylist
    * @return {!Promise.<!shaka.extern.Response>}
    * @private
    */
-  requestManifest_(absoluteUri) {
+  requestManifest_(absoluteUri, isPlaylist) {
     const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
 
     const request = shaka.net.NetworkingEngine.makeRequest(
         [absoluteUri], this.config_.retryParameters);
 
-    const format = shaka.util.CmcdManager.StreamingFormat.HLS;
-    this.playerInterface_.modifyManifestRequest(request, {format: format});
-
-    return this.makeNetworkRequest_(request, requestType);
+    const type = isPlaylist ?
+        shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_PLAYLIST :
+        shaka.net.NetworkingEngine.AdvancedRequestType.MASTER_PLAYLIST;
+    return this.makeNetworkRequest_(request, requestType, {type});
   }
 
   /**
@@ -3078,7 +3640,7 @@ shaka.hls.HlsParser = class {
     shaka.log.info('Updating manifest...');
 
     goog.asserts.assert(
-        this.updatePlaylistDelay_ > 0,
+        this.getUpdatePlaylistDelay_() > 0,
         'We should only call |onUpdate_| when we are suppose to be updating.');
 
     // Detect a call to stop()
@@ -3091,7 +3653,7 @@ shaka.hls.HlsParser = class {
 
       // This may have converted to VOD, in which case we stop updating.
       if (this.isLive_()) {
-        const delay = this.updatePlaylistDelay_;
+        const delay = this.getUpdatePlaylistDelay_();
         this.updatePlaylistTimer_.tickAfter(/* seconds= */ delay);
       }
     } catch (error) {
@@ -3103,6 +3665,11 @@ shaka.hls.HlsParser = class {
       goog.asserts.assert(error instanceof shaka.util.Error,
           'Should only receive a Shaka error');
 
+      if (this.config_.raiseFatalErrorOnManifestUpdateRequestFailure) {
+        this.playerInterface_.onError(error);
+        return;
+      }
+
       // We will retry updating, so override the severity of the error.
       error.severity = shaka.util.Error.Severity.RECOVERABLE;
       this.playerInterface_.onError(error);
@@ -3123,6 +3690,20 @@ shaka.hls.HlsParser = class {
   }
 
 
+  /**
+   * @return {number}
+   * @private
+   */
+  getUpdatePlaylistDelay_() {
+    // The HLS spec (RFC 8216) states in 6.3.4:
+    // "the client MUST wait for at least the target duration before
+    // attempting to reload the Playlist file again".
+    // For LL-HLS, the server must add a new partial segment to the Playlist
+    // every part target duration.
+    return this.lastTargetDuration_;
+  }
+
+
   /**
    * @param {shaka.hls.HlsParser.PresentationType_} type
    * @private
@@ -3149,10 +3730,11 @@ shaka.hls.HlsParser = class {
    *
    * @param {shaka.extern.Request} request
    * @param {shaka.net.NetworkingEngine.RequestType} type
+   * @param {shaka.extern.RequestContext=} context
    * @return {!Promise.<shaka.extern.Response>}
    * @private
    */
-  makeNetworkRequest_(request, type) {
+  makeNetworkRequest_(request, type, context) {
     if (!this.operationManager_) {
       throw new shaka.util.Error(
           shaka.util.Error.Severity.CRITICAL,
@@ -3160,7 +3742,8 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.OPERATION_ABORTED);
     }
 
-    const op = this.playerInterface_.networkingEngine.request(type, request);
+    const op = this.playerInterface_.networkingEngine.request(
+        type, request, context);
     this.operationManager_.manage(op);
 
     return op.promise;
@@ -3314,8 +3897,11 @@ shaka.hls.HlsParser = class {
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
  *   canSkipSegments: boolean,
+ *   canBlockReload: boolean,
  *   hasEndList: boolean,
  *   firstSequenceNumber: number,
+ *   nextMediaSequence: number,
+ *   nextPart: number,
  *   loadedOnce: boolean
  * }}
  *
@@ -3344,10 +3930,18 @@ shaka.hls.HlsParser = class {
  * @property {boolean} canSkipSegments
  *   True if the server supports delta playlist updates, and we can send a
  *   request for a playlist that can skip older media segments.
+ * @property {boolean} canBlockReload
+ *   True if the server supports blocking playlist reload, and we can send a
+ *   request for a playlist that can block reload until some segments are
+ *   present.
  * @property {boolean} hasEndList
  *   True if the stream has an EXT-X-ENDLIST tag.
  * @property {number} firstSequenceNumber
  *   The sequence number of the first reference. Only calculated if needed.
+ * @property {number} nextMediaSequence
+ *   The next media sequence.
+ * @property {number} nextPart
+ *   The next part.
  * @property {boolean} loadedOnce
  *   True if the stream has been loaded at least once.
  */
@@ -3367,6 +3961,30 @@ 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
@@ -3488,13 +4106,9 @@ shaka.hls.HlsParser.PresentationType_ = {
   LIVE: 'LIVE',
 };
 
-if (!shaka.util.Platform.isTizen3() &&
-    !shaka.util.Platform.isTizen2() &&
-    !shaka.util.Platform.isWebOS3()) {
-  shaka.media.ManifestParser.registerParserByExtension(
-      'm3u8', () => new shaka.hls.HlsParser());
-  shaka.media.ManifestParser.registerParserByMime(
-      'application/x-mpegurl', () => new shaka.hls.HlsParser());
-  shaka.media.ManifestParser.registerParserByMime(
-      'application/vnd.apple.mpegurl', () => new shaka.hls.HlsParser());
-}
+shaka.media.ManifestParser.registerParserByExtension(
+    'm3u8', () => new shaka.hls.HlsParser());
+shaka.media.ManifestParser.registerParserByMime(
+    'application/x-mpegurl', () => new shaka.hls.HlsParser());
+shaka.media.ManifestParser.registerParserByMime(
+    'application/vnd.apple.mpegurl', () => new shaka.hls.HlsParser());