shaka-player 4.9.13 → 4.10.1

package/lib/hls/hls_parser.js

@@ -19,6 +19,7 @@ goog.require('shaka.log');
 goog.require('shaka.media.InitSegmentReference');
 goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.PresentationTimeline');
+goog.require('shaka.media.QualityObserver');
 goog.require('shaka.media.SegmentIndex');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.net.DataUriPlugin');
@@ -28,6 +29,7 @@ goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.DrmUtils');
 goog.require('shaka.util.ContentSteeringManager');
 goog.require('shaka.util.Error');
+goog.require('shaka.util.EventManager');
 goog.require('shaka.util.FakeEvent');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
@@ -37,6 +39,7 @@ 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.TXml');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.Uint8ArrayUtils');
@@ -172,6 +175,14 @@ shaka.hls.HlsParser = class {
      * @private {shaka.util.Timer}
      */
     this.updatePlaylistTimer_ = new shaka.util.Timer(() => {
+      if (this.mediaElement_ && !this.config_.continueLoadingWhenPaused) {
+        this.eventManager_.unlisten(this.mediaElement_, 'timeupdate');
+        if (this.mediaElement_.paused) {
+          this.eventManager_.listenOnce(
+              this.mediaElement_, 'timeupdate', () => this.onUpdate_());
+          return;
+        }
+      }
       this.onUpdate_();
     });
 
@@ -247,6 +258,15 @@ shaka.hls.HlsParser = class {
 
     /** @private {boolean} */
     this.needsClosedCaptionsDetection_ = true;
+
+    /** @private {Set.<string>} */
+    this.dateRangeIdsEmitted_ = new Set();
+
+    /** @private {shaka.util.EventManager} */
+    this.eventManager_ = new shaka.util.EventManager();
+
+    /** @private {HTMLMediaElement} */
+    this.mediaElement_ = null;
   }
 
 
@@ -316,11 +336,17 @@ shaka.hls.HlsParser = class {
     this.aesKeyMap_.clear();
     this.identityKeyMap_.clear();
     this.identityKidMap_.clear();
+    this.dateRangeIdsEmitted_.clear();
 
     if (this.contentSteeringManager_) {
       this.contentSteeringManager_.destroy();
     }
 
+    if (this.eventManager_) {
+      this.eventManager_.release();
+      this.eventManager_ = null;
+    }
+
     return Promise.all(pending);
   }
 
@@ -339,6 +365,7 @@ shaka.hls.HlsParser = class {
 
     // This is necessary to calculate correctly the update time.
     this.lastTargetDuration_ = Infinity;
+    this.manifest_.gapCount = 0;
 
     // Only update active streams.
     const activeStreamInfos = streamInfos.filter((s) => s.stream.segmentIndex);
@@ -368,6 +395,15 @@ shaka.hls.HlsParser = class {
     if (stillLive) {
       this.determineDuration_();
     }
+    // Check if any playlist does not have the first reference (due to a
+    // problem in the live encoder for example), and disable the stream if
+    // necessary.
+    for (const streamInfo of activeStreamInfos) {
+      if (streamInfo.stream.segmentIndex &&
+          !streamInfo.stream.segmentIndex.earliestReference()) {
+        this.playerInterface_.disableStream(streamInfo.stream);
+      }
+    }
   }
 
   /**
@@ -418,8 +454,16 @@ shaka.hls.HlsParser = class {
       }
       manifestUris.push(uriObj.toString());
     }
-    const response =
-        await this.requestManifest_(manifestUris, /* isPlaylist= */ true);
+    let response;
+    try {
+      response =
+          await this.requestManifest_(manifestUris, /* isPlaylist= */ true);
+    } catch (e) {
+      if (this.playerInterface_) {
+        this.playerInterface_.disableStream(streamInfo.stream);
+      }
+      throw e;
+    }
     if (!streamInfo.stream.segmentIndex) {
       // The stream was closed since the update was first requested.
       return;
@@ -472,6 +516,14 @@ shaka.hls.HlsParser = class {
       stream.bandwidth = bandwidth;
     }
 
+    const qualityInfo =
+        shaka.media.QualityObserver.createQualityInfo(stream);
+    for (const segment of segments) {
+      if (segment.initSegmentReference) {
+        segment.initSegmentReference.mediaQuality = qualityInfo;
+      }
+    }
+
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
     if (segments.length) {
@@ -490,14 +542,14 @@ shaka.hls.HlsParser = class {
       stream.segmentIndex.evict(playlistStartTime);
     }
     const oldSegment = stream.segmentIndex.earliestReference();
-    goog.asserts.assert(oldSegment, 'Should have segments!');
-
-    streamInfo.minTimestamp = oldSegment.startTime;
+    if (oldSegment) {
+      streamInfo.minTimestamp = oldSegment.startTime;
 
-    const newestSegment = segments[segments.length - 1];
-    goog.asserts.assert(newestSegment, 'Should have segments!');
+      const newestSegment = segments[segments.length - 1];
+      goog.asserts.assert(newestSegment, 'Should have segments!');
 
-    streamInfo.maxTimestamp = newestSegment.endTime;
+      streamInfo.maxTimestamp = newestSegment.endTime;
+    }
 
     // Once the last segment has been added to the playlist,
     // #EXT-X-ENDLIST tag will be appended.
@@ -512,6 +564,9 @@ shaka.hls.HlsParser = class {
     }
 
     this.determineLastTargetDuration_(playlist);
+
+    this.processDateRangeTags_(
+        playlist.tags, stream.type, mediaVariables, streamInfo.getUris);
   }
 
 
@@ -541,6 +596,14 @@ shaka.hls.HlsParser = class {
     }
   }
 
+  /**
+   * @override
+   * @exportInterface
+   */
+  setMediaElement(mediaElement) {
+    this.mediaElement_ = mediaElement;
+  }
+
   /**
    * Align the streams by sequence number by dropping early segments.  Then
    * offset the streams to begin at presentation time 0.
@@ -728,6 +791,7 @@ shaka.hls.HlsParser = class {
    */
   async parseManifest_(data, uri) {
     const Utils = shaka.hls.Utils;
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(this.masterPlaylistUri_,
         'Master playlist URI must be set before calling parseManifest_!');
@@ -760,6 +824,12 @@ shaka.hls.HlsParser = class {
       return [uri];
     };
 
+    /** @type {?string} */
+    let mediaPlaylistType = null;
+
+    /** @type {!Map.<string, string>} */
+    let mediaVariables = new Map();
+
     // Parsing a media playlist results in a single-variant stream.
     if (playlist.type == shaka.hls.PlaylistType.MEDIA) {
       this.needsClosedCaptionsDetection_ = false;
@@ -768,29 +838,19 @@ shaka.hls.HlsParser = class {
       const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
           'EXT-X-DEFINE');
 
-      const mediaVariables =
-          this.parseMediaVariables_(variablesTags, this.masterPlaylistUri_);
-
-      // 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, getUris, mediaVariables);
-      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;
-      const closedCaptions = basicInfo.closedCaptions;
-      const videoRange = basicInfo.videoRange;
-      const colorGamut = basicInfo.colorGamut;
-
-      // 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.
+      mediaVariables = this.parseMediaVariables_(
+          variablesTags, this.masterPlaylistUri_);
+
+      // By default we assume it is video, but in a later step the correct type
+      // is obtained.
+      mediaPlaylistType = ContentType.VIDEO;
+
+      // These values can be obtained later so these default values are good.
+      const codecs = '';
+      const languageValue = '';
+      const channelsCount = null;
+      const sampleRate = null;
+      const closedCaptions = new Map();
       const spatialAudio = false;
       const characteristics = null;
       const forced = false; // Only relevant for text.
@@ -800,24 +860,32 @@ shaka.hls.HlsParser = class {
       // Make the stream info, with those values.
       const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
           this.globalId_++, mediaVariables, playlist, getUris, uri, codecs,
-          type, languageValue, primary, name, channelsCount, closedCaptions,
-          characteristics, forced, sampleRate, spatialAudio, mimeType);
+          mediaPlaylistType, languageValue, primary, name, channelsCount,
+          closedCaptions, characteristics, forced, sampleRate, spatialAudio);
       this.uriToStreamInfosMap_.set(uri, streamInfo);
 
-      if (type == 'video') {
-        this.addVideoAttributes_(streamInfo.stream, width, height,
-            /* frameRate= */ null, videoRange, /* videoLayout= */ null,
-            colorGamut);
+
+      if (streamInfo.stream) {
+        const qualityInfo =
+            shaka.media.QualityObserver.createQualityInfo(streamInfo.stream);
+        streamInfo.stream.segmentIndex.forEachTopLevelReference(
+            (reference) => {
+              if (reference.initSegmentReference) {
+                reference.initSegmentReference.mediaQuality = qualityInfo;
+              }
+            });
       }
 
+      mediaPlaylistType = streamInfo.stream.type;
+
       // Wrap the stream from that stream info with a variant.
       variants.push({
         id: 0,
         language: this.getLanguage_(languageValue),
         disabledUntilTime: 0,
         primary: true,
-        audio: type == 'audio' ? streamInfo.stream : null,
-        video: type == 'video' ? streamInfo.stream : null,
+        audio: mediaPlaylistType == 'audio' ? streamInfo.stream : null,
+        video: mediaPlaylistType == 'video' ? streamInfo.stream : null,
         bandwidth: streamInfo.stream.bandwidth || 0,
         allowedByApplication: true,
         allowedByKeySystem: true,
@@ -880,6 +948,11 @@ shaka.hls.HlsParser = class {
       const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
       this.finalizeStreams_(streamInfos);
       this.determineDuration_();
+
+      goog.asserts.assert(mediaPlaylistType,
+          'mediaPlaylistType should be non-null');
+      this.processDateRangeTags_(
+          playlist.tags, mediaPlaylistType, mediaVariables, getUris);
     }
 
     this.manifest_ = {
@@ -895,6 +968,9 @@ shaka.hls.HlsParser = class {
       type: shaka.media.ManifestParser.HLS,
       serviceDescription: null,
       nextUrl: null,
+      periodCount: 1,
+      gapCount: 0,
+      isLowLatency: false,
     };
 
     // If there is no 'CODECS' attribute in the manifest and codec guessing is
@@ -931,26 +1007,21 @@ shaka.hls.HlsParser = class {
   }
 
   /**
-   * @param {shaka.hls.Playlist} playlist
-   * @param {function():!Array.<string>} getUris
-   * @param {?Map.<string, string>=} variables
+   * @param {!Array.<!shaka.media.SegmentReference>} segments
    * @return {!Promise.<shaka.media.SegmentUtils.BasicInfo>}
    * @private
    */
-  async getMediaPlaylistBasicInfo_(playlist, getUris, variables) {
+  async getBasicInfoFromSegments_(segments) {
     const HlsParser = shaka.hls.HlsParser;
     const defaultBasicInfo = shaka.media.SegmentUtils.getBasicInfoFromMimeType(
         this.config_.hls.mediaPlaylistFullMimeType);
-    if (!playlist.segments.length) {
+    if (!segments.length) {
       return defaultBasicInfo;
     }
-    const firstSegment = playlist.segments[0];
-    const firstSegmentUris = shaka.hls.Utils.constructSegmentUris(
-        getUris(),
-        firstSegment.verbatimSegmentUri,
-        variables);
-    const firstSegmentUri = firstSegmentUris[0];
-    const parsedUri = new goog.Uri(firstSegmentUri);
+    const segment = this.getAvailableSegment_(segments);
+    const segmentUris = segment.getUris();
+    const segmentUri = segmentUris[0];
+    const parsedUri = new goog.Uri(segmentUri);
     const extension = parsedUri.getPath().split('.').pop();
     const rawMimeType = HlsParser.RAW_FORMATS_TO_MIME_TYPES_[extension];
     if (rawMimeType) {
@@ -961,33 +1032,28 @@ shaka.hls.HlsParser = class {
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
     let initData = null;
-    const initSegmentRef = this.getInitSegmentReference_(
-        playlist, firstSegment.tags, getUris, variables);
-    this.mapTagToInitSegmentRefMap_.clear();
+    let initMimeType = null;
+    const initSegmentRef = segment.initSegmentReference;
     if (initSegmentRef) {
       const initSegmentRequest = shaka.util.Networking.createSegmentRequest(
-          initSegmentRef.getUris(),
-          initSegmentRef.getStartByte(),
-          initSegmentRef.getEndByte(),
-          this.config_.retryParameters);
+          initSegmentRef.getUris(), initSegmentRef.getStartByte(),
+          initSegmentRef.getEndByte(), this.config_.retryParameters);
       const initType =
           shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT;
       const initResponse = await this.makeNetworkRequest_(
           initSegmentRequest, requestType, {type: initType});
       initData = initResponse.data;
-    }
 
-    let startByte = 0;
-    let endByte = null;
-    const byterangeTag = shaka.hls.Utils.getFirstTagWithName(
-        firstSegment.tags, 'EXT-X-BYTERANGE');
-    if (byterangeTag) {
-      [startByte, endByte] = this.parseByteRange_(
-          /* previousReference= */ null, byterangeTag.value);
+      initMimeType = initResponse.headers['content-type'];
+      if (initMimeType) {
+        // Split the MIME type in case the server sent additional parameters.
+        initMimeType = initMimeType.split(';')[0].toLowerCase();
+      }
     }
 
     const segmentRequest = shaka.util.Networking.createSegmentRequest(
-        firstSegmentUris, startByte, endByte, this.config_.retryParameters);
+        segment.getUris(), segment.getStartByte(), segment.getEndByte(),
+        this.config_.retryParameters);
     const type = shaka.net.NetworkingEngine.AdvancedRequestType.MEDIA_SEGMENT;
     const response = await this.makeNetworkRequest_(
         segmentRequest, requestType, {type});
@@ -998,23 +1064,49 @@ shaka.hls.HlsParser = class {
       contentMimeType = contentMimeType.split(';')[0].toLowerCase();
     }
 
-    if (extension == 'ts' || contentMimeType == 'video/mp2t') {
+    const validMp4Extensions = [
+      'mp4',
+      'mp4a',
+      'm4s',
+      'm4i',
+      'm4a',
+      'm4f',
+      'cmfa',
+      'mp4v',
+      'm4v',
+      'cmfv',
+      'fmp4',
+    ];
+    const validMp4MimeType = [
+      'audio/mp4',
+      'video/mp4',
+      'video/iso.segment',
+    ];
+
+    if (shaka.util.TsParser.probe(
+        shaka.util.BufferUtils.toUint8(response.data))) {
       const basicInfo =
           shaka.media.SegmentUtils.getBasicInfoFromTs(response.data);
       if (basicInfo) {
         return basicInfo;
       }
-    } else if (extension == 'mp4' || extension == 'cmfv' ||
-        extension == 'm4s' || extension == 'fmp4' ||
-        contentMimeType == 'video/mp4' ||
-        contentMimeType == 'audio/mp4' ||
-        contentMimeType == 'video/iso.segment') {
+    } else if (validMp4Extensions.includes(extension) ||
+        validMp4MimeType.includes(contentMimeType) ||
+        (initMimeType && validMp4MimeType.includes(initMimeType))) {
       const basicInfo = shaka.media.SegmentUtils.getBasicInfoFromMp4(
           initData, response.data);
       if (basicInfo) {
         return basicInfo;
       }
     }
+    if (contentMimeType) {
+      return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
+          contentMimeType);
+    }
+    if (initMimeType) {
+      return shaka.media.SegmentUtils.getBasicInfoFromMimeType(
+          initMimeType);
+    }
     return defaultBasicInfo;
   }
 
@@ -2285,8 +2377,19 @@ shaka.hls.HlsParser = class {
 
       const uris = streamInfo.getUris();
       // Download the actual manifest.
-      const response = await this.requestManifest_(
-          streamInfo.getUris(), /* isPlaylist= */ true);
+      let response;
+      try {
+        response = await this.requestManifest_(
+            streamInfo.getUris(), /* isPlaylist= */ true);
+      } catch (e) {
+        stream.closeSegmentIndex();
+        const handled = this.playerInterface_.disableStream(stream);
+        if (handled) {
+          return;
+        } else {
+          throw e;
+        }
+      }
       if (abortSignal.aborted) {
         return;
       }
@@ -2316,9 +2419,9 @@ shaka.hls.HlsParser = class {
       const mediaVariables =
           this.parseMediaVariables_(variablesTags, responseUri);
 
-      let mimeType = undefined;
+      const mimeType = undefined;
 
-      let closedCaptionsUpdated = false;
+      let requestBasicInfo = false;
 
       // If no codec info was provided in the manifest and codec guessing is
       // disabled we try to get necessary info from the media data.
@@ -2326,40 +2429,21 @@ shaka.hls.HlsParser = class {
           this.config_.hls.disableCodecGuessing) ||
           (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
           !this.config_.hls.disableClosedCaptionsDetection)) {
-        let canRequestBasicInfo = playlist.segments.length > 0;
-        if (canRequestBasicInfo) {
-          const segment = playlist.segments[0];
-          if (shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXT-X-GAP')) {
-            canRequestBasicInfo = false;
-          }
-        }
-        if (canRequestBasicInfo) {
+        if (playlist.segments.length > 0) {
           this.needsClosedCaptionsDetection_ = false;
-          const basicInfo = await this.getMediaPlaylistBasicInfo_(
-              playlist, getUris, mediaVariables);
-
-          goog.asserts.assert(
-              type === basicInfo.type, 'Media types should match!');
-
-          if (basicInfo.closedCaptions.size && (!closedCaptions ||
-              closedCaptions.size != basicInfo.closedCaptions.size)) {
-            closedCaptions = basicInfo.closedCaptions;
-            closedCaptionsUpdated = true;
-          }
-
-          if (!this.codecInfoInManifest_ &&
-              this.config_.hls.disableCodecGuessing) {
-            mimeType = basicInfo.mimeType;
-            codecs = basicInfo.codecs;
-          }
+          requestBasicInfo = true;
         }
       }
 
+      const allowOverrideMimeType = !this.codecInfoInManifest_ &&
+        this.config_.hls.disableCodecGuessing;
+
       const wasLive = this.isLive_();
       const realStreamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
           streamId, mediaVariables, playlist, getUris, responseUri, codecs,
           type, languageValue, primary, name, channelsCount, closedCaptions,
-          characteristics, forced, sampleRate, spatialAudio, mimeType);
+          characteristics, forced, sampleRate, spatialAudio, mimeType,
+          requestBasicInfo, allowOverrideMimeType);
       if (abortSignal.aborted) {
         return;
       }
@@ -2392,6 +2476,17 @@ shaka.hls.HlsParser = class {
       stream.codecs = stream.codecs || realStream.codecs;
       stream.closedCaptions =
           stream.closedCaptions || realStream.closedCaptions;
+      stream.width = stream.width || realStream.width;
+      stream.height = stream.height || realStream.height;
+      stream.hdr = stream.hdr || realStream.hdr;
+      stream.colorGamut = stream.colorGamut || realStream.colorGamut;
+      if (stream.language == 'und' && realStream.language != 'und') {
+        stream.language = realStream.language;
+      }
+      stream.language = stream.language || realStream.language;
+      stream.channelsCount = stream.channelsCount || realStream.channelsCount;
+      stream.audioSamplingRate =
+          stream.audioSamplingRate || realStream.audioSamplingRate;
       this.setFullTypeForStream_(stream);
 
       // Since we lazy-loaded this content, the player may need to create new
@@ -2400,6 +2495,13 @@ shaka.hls.HlsParser = class {
         this.playerInterface_.newDrmInfo(stream);
       }
 
+      let closedCaptionsUpdated = false;
+      if ((!closedCaptions && stream.closedCaptions) ||
+        (closedCaptions && stream.closedCaptions &&
+        closedCaptions.size != stream.closedCaptions.size)) {
+        closedCaptionsUpdated = true;
+      }
+
       if (this.manifest_ && closedCaptionsUpdated) {
         this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
       }
@@ -2423,6 +2525,14 @@ shaka.hls.HlsParser = class {
         }
       }
 
+      const qualityInfo =
+          shaka.media.QualityObserver.createQualityInfo(stream);
+      stream.segmentIndex.forEachTopLevelReference((reference) => {
+        if (reference.initSegmentReference) {
+          reference.initSegmentReference.mediaQuality = qualityInfo;
+        }
+      });
+
       // Add finishing touches to the stream that can only be done once we have
       // more full context on the media as a whole.
       if (this.hasEnoughInfoToFinalizeStreams_()) {
@@ -2451,6 +2561,9 @@ shaka.hls.HlsParser = class {
           this.finalizeStreams_([streamInfo]);
         }
       }
+
+      this.processDateRangeTags_(
+          playlist.tags, stream.type, mediaVariables, getUris);
     };
 
     /** @type {Promise} */
@@ -2631,13 +2744,16 @@ shaka.hls.HlsParser = class {
    * @param {?number} sampleRate
    * @param {boolean} spatialAudio
    * @param {(string|undefined)} mimeType
+   * @param {boolean=} requestBasicInfo
+   * @param {boolean=} allowOverrideMimeType
    * @return {!Promise.<!shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async convertParsedPlaylistIntoStreamInfo_(streamId, variables, playlist,
       getUris, responseUri, codecs, type, languageValue, primary, name,
       channelsCount, closedCaptions, characteristics, forced, sampleRate,
-      spatialAudio, mimeType = undefined) {
+      spatialAudio, mimeType = undefined, requestBasicInfo = true,
+      allowOverrideMimeType = true) {
     goog.asserts.assert(playlist.segments != null,
         'Media playlist should have segments!');
 
@@ -2653,6 +2769,30 @@ shaka.hls.HlsParser = class {
     const {segments, bandwidth} = this.createSegments_(
         playlist, mediaSequenceToStartTime, variables, getUris, type);
 
+    let width = null;
+    let height = null;
+    let videoRange = null;
+    let colorGamut = null;
+    if (segments.length > 0 && requestBasicInfo) {
+      const basicInfo = await this.getBasicInfoFromSegments_(segments);
+
+      type = basicInfo.type;
+      languageValue = basicInfo.language;
+      channelsCount = basicInfo.channelCount;
+      sampleRate = basicInfo.sampleRate;
+      closedCaptions = basicInfo.closedCaptions;
+
+      height = basicInfo.height;
+      width = basicInfo.width;
+      videoRange = basicInfo.videoRange;
+      colorGamut = basicInfo.colorGamut;
+
+      if (allowOverrideMimeType) {
+        mimeType = basicInfo.mimeType;
+        codecs = basicInfo.codecs;
+      }
+    }
+
     if (!mimeType) {
       mimeType = await this.guessMimeType_(type, codecs, segments);
     }
@@ -2679,6 +2819,13 @@ shaka.hls.HlsParser = class {
     }
     this.setFullTypeForStream_(stream);
 
+    if (type == shaka.util.ManifestParserUtils.ContentType.VIDEO &&
+        (width || height || videoRange || colorGamut)) {
+      this.addVideoAttributes_(stream, width, height,
+          /* frameRate= */ null, videoRange, /* videoLayout= */ null,
+          colorGamut);
+    }
+
     // This new calculation is necessary for Low Latency streams.
     if (this.isLive_()) {
       this.determineLastTargetDuration_(playlist);
@@ -3325,11 +3472,8 @@ shaka.hls.HlsParser = class {
     let startByte = 0;
     let endByte = null;
 
-    if (hlsSegment.partialSegments.length && !this.lowLatencyMode_) {
-      shaka.log.alwaysWarn('Low-latency HLS live stream detected, but ' +
-                'low-latency streaming mode is not enabled in Shaka ' +
-                'Player. Set streaming.lowLatencyMode configuration to ' +
-                'true, and see https://bit.ly/3clctcj for details.');
+    if (hlsSegment.partialSegments.length) {
+      this.manifest_.isLowLatency = true;
     }
 
     let syncTime = null;
@@ -3345,6 +3489,7 @@ shaka.hls.HlsParser = class {
 
     let status = shaka.media.SegmentReference.Status.AVAILABLE;
     if (shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-GAP')) {
+      this.manifest_.gapCount++;
       status = shaka.media.SegmentReference.Status.MISSING;
     }
 
@@ -3427,6 +3572,7 @@ shaka.hls.HlsParser = class {
 
         let partialStatus = shaka.media.SegmentReference.Status.AVAILABLE;
         if (item.getAttributeValue('GAP') == 'YES') {
+          this.manifest_.gapCount++;
           partialStatus = shaka.media.SegmentReference.Status.MISSING;
           somePartialSegmentWithGap = true;
         }
@@ -3621,6 +3767,156 @@ shaka.hls.HlsParser = class {
     return [startByte, endByte];
   }
 
+  /**
+   * @param {!Array.<!shaka.hls.Tag>} tags
+   * @param {string} contentType
+   * @param {!Map.<string, string>} variables
+   * @param {function():!Array.<string>} getUris
+   * @private
+   */
+  processDateRangeTags_(tags, contentType, variables, getUris) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (contentType != ContentType.VIDEO && contentType != ContentType.AUDIO) {
+      // DATE-RANGE should only appear in AUDIO or VIDEO playlists.
+      // We ignore those that appear in other playlists.
+      return;
+    }
+    const Utils = shaka.hls.Utils;
+    const initialProgramDateTime =
+        this.presentationTimeline_.getInitialProgramDateTime();
+    if (!initialProgramDateTime ||
+        this.ignoreManifestProgramDateTimeFor_(contentType)) {
+      return;
+    }
+    let dateRangeTags =
+        shaka.hls.Utils.filterTagsByName(tags, 'EXT-X-DATERANGE');
+    dateRangeTags = dateRangeTags.sort((a, b) => {
+      const aStartDateValue = a.getRequiredAttrValue('START-DATE');
+      const bStartDateValue = b.getRequiredAttrValue('START-DATE');
+      if (aStartDateValue < bStartDateValue) {
+        return -1;
+      }
+      if (aStartDateValue > bStartDateValue) {
+        return 1;
+      }
+      return 0;
+    });
+    for (let i = 0; i < dateRangeTags.length; i++) {
+      const tag = dateRangeTags[i];
+      const id = tag.getRequiredAttrValue('ID');
+      if (this.dateRangeIdsEmitted_.has(id)) {
+        continue;
+      }
+      const startDateValue = tag.getRequiredAttrValue('START-DATE');
+      const startDate = shaka.util.TXml.parseDate(startDateValue);
+      if (isNaN(startDate)) {
+        // Invalid START-DATE
+        continue;
+      }
+      goog.asserts.assert(startDate != null, 'Start date should not be null!');
+      const startTime = Math.max(0, startDate - initialProgramDateTime);
+
+      let endTime = null;
+      const endDateValue = tag.getAttributeValue('END-DATE');
+      if (endDateValue) {
+        const endDate = shaka.util.TXml.parseDate(endDateValue);
+        if (!isNaN(endDate)) {
+          goog.asserts.assert(endDate != null, 'End date should not be null!');
+          endTime = endDate - initialProgramDateTime;
+          if (endTime < 0) {
+            // Date range in the past
+            continue;
+          }
+        }
+      }
+      if (endTime == null) {
+        const durationValue = tag.getAttributeValue('DURATION') ||
+            tag.getAttributeValue('PLANNED-DURATION');
+        if (durationValue) {
+          const duration = parseFloat(durationValue);
+          if (!isNaN(duration)) {
+            endTime = startTime + duration;
+          }
+          const realEndTime = startDate - initialProgramDateTime + duration;
+          if (realEndTime < 0) {
+            // Date range in the past
+            continue;
+          }
+        }
+      }
+      const type = tag.getAttributeValue('CLASS') || 'com.apple.quicktime.HLS';
+
+      const endOnNext = tag.getAttributeValue('END-ON-NEXT') == 'YES';
+      if (endTime == null && endOnNext) {
+        for (let j = i + 1; j < dateRangeTags.length; j++) {
+          const otherDateRangeType =
+              dateRangeTags[j].getAttributeValue('CLASS') ||
+              'com.apple.quicktime.HLS';
+          if (type != otherDateRangeType) {
+            continue;
+          }
+          const otherDateRangeStartDateValue =
+              dateRangeTags[j].getRequiredAttrValue('START-DATE');
+          const otherDateRangeStartDate =
+              shaka.util.TXml.parseDate(otherDateRangeStartDateValue);
+          if (isNaN(otherDateRangeStartDate)) {
+            // Invalid START-DATE
+            continue;
+          }
+          if (otherDateRangeStartDate && otherDateRangeStartDate > startDate) {
+            endTime = Math.max(0,
+                otherDateRangeStartDate - initialProgramDateTime);
+            break;
+          }
+        }
+        if (endTime == null) {
+          // Since we cannot know when it ends, we omit it for now and in the
+          // future with an update we will be able to have more information.
+          continue;
+        }
+      }
+
+      // Exclude these attributes from the metadata since they already go into
+      // other fields (eg: startTime or endTime) or are not necessary..
+      const excludedAttributes = [
+        'ID',
+        'CLASS',
+        'START-DATE',
+        'END-DATE',
+        'DURATION',
+        'END-ON-NEXT',
+      ];
+
+      /* @type {!Array.<shaka.extern.MetadataFrame>} */
+      const values = [];
+      for (const attribute of tag.attributes) {
+        if (excludedAttributes.includes(attribute.name)) {
+          continue;
+        }
+        let data = Utils.variableSubstitution(attribute.value, variables);
+        if (attribute.name == 'X-ASSET-URI' ||
+            attribute.name == 'X-ASSET-LIST') {
+          data = Utils.constructSegmentUris(
+              getUris(), attribute.value, variables)[0];
+        }
+        const metadataFrame = {
+          key: attribute.name,
+          description: '',
+          data,
+          mimeType: null,
+          pictureType: null,
+        };
+        values.push(metadataFrame);
+      }
+
+      if (values.length) {
+        this.playerInterface_.onMetadata(type, startTime, endTime, values);
+      }
+
+      this.dateRangeIdsEmitted_.add(id);
+    }
+  }
+
   /**
    * Parses shaka.hls.Segment objects into shaka.media.SegmentReferences and
    * get the bandwidth necessary for this segments If it's defined in the
@@ -3925,6 +4221,28 @@ shaka.hls.HlsParser = class {
     return map['mp4'];
   }
 
+  /**
+   * @param {!Array.<!shaka.media.SegmentReference>} segments
+   * @return {!shaka.media.SegmentReference}
+   * @private
+   */
+  getAvailableSegment_(segments) {
+    goog.asserts.assert(segments.length, 'Should have segments!');
+
+    // If you wait long enough, requesting the first segment can fail
+    // because it has fallen off the left edge of DVR, so to be safer,
+    // let's request the middle segment.
+    let segmentIndex = this.isLive_() ?
+        Math.trunc((segments.length - 1) / 2) : 0;
+    let segment = segments[segmentIndex];
+    while (segment.getStatus() == shaka.media.SegmentReference.Status.MISSING &&
+        (segmentIndex + 1) < segments.length) {
+      segmentIndex ++;
+      segment = segments[segmentIndex];
+    }
+    return segment;
+  }
+
   /**
    * Attempts to guess stream's mime type.
    *
@@ -3938,17 +4256,7 @@ shaka.hls.HlsParser = class {
     const HlsParser = shaka.hls.HlsParser;
     const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
 
-    // If you wait long enough, requesting the first segment can fail
-    // because it has fallen off the left edge of DVR, so to be safer,
-    // let's request the middle segment.
-    goog.asserts.assert(segments.length, 'Should have segments!');
-    let segmentIndex = Math.trunc((segments.length - 1) / 2);
-    let segment = segments[segmentIndex];
-    while (segment.status == shaka.media.SegmentReference.Status.MISSING &&
-        segmentIndex < segments.length) {
-      segmentIndex ++;
-      segment = segments[segmentIndex];
-    }
+    const segment = this.getAvailableSegment_(segments);
 
     if (segment.status == shaka.media.SegmentReference.Status.MISSING) {
       return this.guessMimeTypeFallback_(contentType);
@@ -4264,7 +4572,7 @@ shaka.hls.HlsParser = class {
     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
         'com.apple.fps', encryptionScheme, [
           {initDataType: 'sinf', initData: new Uint8Array(0), keyId: null},
-        ]);
+        ], drmTag.getRequiredAttrValue('URI'));
 
     return drmInfo;
   }