shaka-player 3.3.4 → 4.0.0

package/lib/hls/hls_parser.js

@@ -18,6 +18,7 @@ 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,19 +27,17 @@ goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.ArrayUtils');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.CmcdManager');
-goog.require('shaka.util.DataViewReader');
 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.Mp4Parser');
-goog.require('shaka.util.Mp4BoxParsers');
-goog.require('shaka.util.Networking');
 goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.Pssh');
 goog.require('shaka.util.Timer');
+goog.require('shaka.util.Platform');
+goog.require('shaka.util.XmlUtils');
 goog.requireType('shaka.hls.Segment');
 
 
@@ -95,9 +94,6 @@ shaka.hls.HlsParser = class {
      * createStreamInfoFromMediaTag_, createStreamInfoFromImageTag_ and
      * createStreamInfoFromVariantTag_.
      *
-     * During parsing of updates, used by getStartTime_ to determine the start
-     * time of the first segment from existing segment references.
-     *
      * @private {!Map.<string, shaka.hls.HlsParser.StreamInfo>}
      */
     this.uriToStreamInfosMap_ = new Map();
@@ -124,6 +120,15 @@ shaka.hls.HlsParser = class {
      */
     this.updatePlaylistDelay_ = 0;
 
+    /**
+     * A time offset to apply to EXT-X-PROGRAM-DATE-TIME values to normalize
+     * them so that they start at 0. This is necessary because these times will
+     * be used to set presentation times for segments.
+     * null means we don't have enough data yet.
+     * @private {?number}
+     */
+    this.syncTimeOffset_ = null;
+
     /**
      * This timer is used to trigger the start of a manifest update. A manifest
      * update is async. Once the update is finished, the timer will be restarted
@@ -175,9 +180,6 @@ shaka.hls.HlsParser = class {
     /** @private {Map.<string, string>} */
     this.groupIdToCodecsMap_ = new Map();
 
-    /** @private {?number} */
-    this.playlistStartTime_ = null;
-
     /** A cache mapping EXT-X-MAP tag info to the InitSegmentReference created
      * from the tag.
      * The key is a string combining the EXT-X-MAP tag's absolute uri, and
@@ -185,15 +187,6 @@ shaka.hls.HlsParser = class {
      * {!Map.<string, !shaka.media.InitSegmentReference>} */
     this.mapTagToInitSegmentRefMap_ = new Map();
 
-    /**
-     * A cache mapping a discontinuity sequence number of a segment with
-     * EXT-X-DISCONTINUITY tag into its timestamp offset.
-     * Key: the discontinuity sequence number of a segment
-     * Value: the segment reference's timestamp offset.
-     * {!Map.<number, number>}
-     */
-    this.discontinuityToTso_ = new Map();
-
     /** @private {boolean} */
     this.lowLatencyMode_ = false;
   }
@@ -222,7 +215,7 @@ shaka.hls.HlsParser = class {
     this.masterPlaylistUri_ = response.uri;
 
     goog.asserts.assert(response.data, 'Response data should be non-null!');
-    await this.parseManifest_(response.data);
+    await this.parseManifest_(response.data, uri);
 
     // Start the update timer if we want updates.
     const delay = this.updatePlaylistDelay_;
@@ -277,8 +270,6 @@ shaka.hls.HlsParser = class {
 
     /** @type {!Array.<!Promise>} */
     const updates = [];
-    // Reset the start time for the new media playlist.
-    this.playlistStartTime_ = null;
     const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
     // Wait for the first stream info created, so that the start time is fetched
     // and can be reused.
@@ -329,11 +320,10 @@ shaka.hls.HlsParser = class {
 
     const stream = streamInfo.stream;
 
-    const segments = await this.createSegments_(
+    const segments = this.createSegments_(
         streamInfo.verbatimMediaPlaylistUri, playlist, stream.type,
         stream.mimeType, streamInfo.mediaSequenceToStartTime, mediaVariables,
-        streamInfo.discontinuityToMediaSequence, stream.codecs,
-        stream.bandwidth);
+        stream.codecs);
 
     stream.segmentIndex.mergeAndEvict(
         segments, this.presentationTimeline_.getSegmentAvailabilityStart());
@@ -370,14 +360,51 @@ shaka.hls.HlsParser = class {
     // No-op
   }
 
+  /**
+   * If necessary, makes sure that sync times will be normalized to 0, so that
+   * a stream does not start buffering at 50 years in because sync times are
+   * measured in time since 1970.
+   * @private
+   */
+  calculateSyncTimeOffset_() {
+    if (this.syncTimeOffset_ != null) {
+      // The offset was already calculated.
+      return;
+    }
+
+    const segments = new Set();
+    let lowestSyncTime = Infinity;
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      const segmentIndex = streamInfo.stream.segmentIndex;
+      if (segmentIndex) {
+        segmentIndex.forEachTopLevelReference((segment) => {
+          if (segment.syncTime != null) {
+            lowestSyncTime = Math.min(lowestSyncTime, segment.syncTime);
+            segments.add(segment);
+          }
+        });
+      }
+    }
+    if (segments.size > 0) {
+      this.syncTimeOffset_ = -lowestSyncTime;
+      for (const segment of segments) {
+        segment.syncTime += this.syncTimeOffset_;
+        for (const partial of segment.partialReferences) {
+          partial.syncTime += this.syncTimeOffset_;
+        }
+      }
+    }
+  }
+
   /**
    * Parses the manifest.
    *
    * @param {BufferSource} data
+   * @param {string} uri
    * @return {!Promise}
    * @private
    */
-  async parseManifest_(data) {
+  async parseManifest_(data, uri) {
     const Utils = shaka.hls.Utils;
 
     goog.asserts.assert(this.masterPlaylistUri_,
@@ -386,63 +413,106 @@ shaka.hls.HlsParser = class {
     const playlist = this.manifestTextParser_.parsePlaylist(
         data, this.masterPlaylistUri_);
 
-    // We don't support directly providing a Media Playlist.
-    // See the error code for details.
-    if (playlist.type != shaka.hls.PlaylistType.MASTER) {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_MASTER_PLAYLIST_NOT_PROVIDED);
-    }
-
     /** @type {!Array.<!shaka.hls.Tag>} */
     const variablesTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-DEFINE');
 
     this.parseMasterVariables_(variablesTags);
 
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const variantTags = Utils.filterTagsByName(
-        playlist.tags, 'EXT-X-STREAM-INF');
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const imageTags = Utils.filterTagsByName(
-        playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
-
-    this.parseCodecs_(variantTags);
-
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const sesionDataTags =
-        Utils.filterTagsByName(playlist.tags, 'EXT-X-SESSION-DATA');
-    for (const tag of sesionDataTags) {
-      const id = tag.getAttributeValue('DATA-ID');
-      const uri = tag.getAttributeValue('URI');
-      const language = tag.getAttributeValue('LANGUAGE');
-      const value = tag.getAttributeValue('VALUE');
-      const data = (new Map()).set('id', id);
-      if (uri) {
-        data.set('uri',
-            shaka.hls.Utils.constructAbsoluteUri(this.masterPlaylistUri_, uri));
-      }
-      if (language) {
-        data.set('language', language);
-      }
-      if (value) {
-        data.set('value', value);
-      }
-      const event = new shaka.util.FakeEvent('sessiondata', data);
-      if (this.playerInterface_) {
-        this.playerInterface_.onEvent(event);
+    /** @type {!Array.<!shaka.extern.Variant>} */
+    let variants = [];
+    /** @type {!Array.<!shaka.extern.Stream>} */
+    let textStreams = [];
+    /** @type {!Array.<!shaka.extern.Stream>} */
+    let imageStreams = [];
+
+    // 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).
+      const fullMimeType = this.config_.hls.mediaPlaylistFullMimeType;
+      const mimeType = shaka.util.MimeUtils.getBasicType(fullMimeType);
+      const type = mimeType.split('/')[0];
+      const codecs = shaka.util.MimeUtils.getCodecs(fullMimeType);
+
+      // 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();
+      const forced = false; // Only relevant for text.
+      const primary = true; // This is the only stream!
+      const name = 'Media Playlist';
+
+      // Make the stream info, with those values.
+      const streamInfo = await this.convertParsedPlaylistIntoStreamInfo_(
+          playlist, uri, uri, codecs, type, language, primary, name,
+          channelsCount, closedCaptions, characteristics, forced, spatialAudio,
+          mimeType);
+      goog.asserts.assert(streamInfo != null, 'StreamInfo is null!');
+      this.uriToStreamInfosMap_.set(uri, streamInfo);
+
+      // Wrap the stream from that stream info with a variant.
+      variants.push({
+        id: 0,
+        language: 'und',
+        primary: true,
+        audio: type == 'audio' ? streamInfo.stream : null,
+        video: type == 'video' ? streamInfo.stream : null,
+        bandwidth: 0,
+        allowedByApplication: true,
+        allowedByKeySystem: true,
+        decodingInfos: [],
+      });
+    } else {
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const mediaTags = Utils.filterTagsByName(playlist.tags, 'EXT-X-MEDIA');
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const variantTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-STREAM-INF');
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const imageTags = Utils.filterTagsByName(
+          playlist.tags, 'EXT-X-IMAGE-STREAM-INF');
+
+      this.parseCodecs_(variantTags);
+
+      /** @type {!Array.<!shaka.hls.Tag>} */
+      const sesionDataTags =
+          Utils.filterTagsByName(playlist.tags, 'EXT-X-SESSION-DATA');
+      for (const tag of sesionDataTags) {
+        const id = tag.getAttributeValue('DATA-ID');
+        const uri = tag.getAttributeValue('URI');
+        const language = tag.getAttributeValue('LANGUAGE');
+        const value = tag.getAttributeValue('VALUE');
+        const data = (new Map()).set('id', id);
+        if (uri) {
+          data.set('uri', shaka.hls.Utils.constructAbsoluteUri(
+              this.masterPlaylistUri_, uri));
+        }
+        if (language) {
+          data.set('language', language);
+        }
+        if (value) {
+          data.set('value', value);
+        }
+        const event = new shaka.util.FakeEvent('sessiondata', data);
+        if (this.playerInterface_) {
+          this.playerInterface_.onEvent(event);
+        }
       }
-    }
 
-    // Parse audio and video media tags first, so that we can extract segment
-    // start time from audio/video streams and reuse for text streams.
-    await this.createStreamInfosFromMediaTags_(mediaTags);
-    this.parseClosedCaptions_(mediaTags);
-    const variants = await this.createVariantsForTags_(variantTags);
-    const textStreams = await this.parseTexts_(mediaTags);
-    const imageStreams = await this.parseImages_(imageTags);
+      // Parse audio and video media tags first, so that we can extract segment
+      // start time from audio/video streams and reuse for text streams.
+      await this.createStreamInfosFromMediaTags_(mediaTags);
+      this.parseClosedCaptions_(mediaTags);
+      variants = await this.createVariantsForTags_(variantTags);
+      textStreams = await this.parseTexts_(mediaTags);
+      imageStreams = await this.parseImages_(imageTags);
+    }
 
     // Make sure that the parser has not been destroyed.
     if (!this.playerInterface_) {
@@ -452,6 +522,10 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.OPERATION_ABORTED);
     }
 
+    // Now that we have generated all streams, we can determine the offset to
+    // apply to sync times.
+    this.calculateSyncTimeOffset_();
+
     if (this.aesEncrypted_ && variants.length == 0) {
       // We do not support AES-128 encryption with HLS yet. Variants is null
       // when the playlist is encrypted with AES-128.
@@ -564,6 +638,7 @@ shaka.hls.HlsParser = class {
       imageStreams,
       offlineSessionIds: [],
       minBufferTime: 0,
+      sequenceMode: true,
     };
     this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
   }
@@ -764,7 +839,7 @@ shaka.hls.HlsParser = class {
       const videoRange = tag.getAttributeValue('VIDEO-RANGE');
 
       const streamInfos = await this.createStreamInfosForVariantTag_(tag,
-          resolution, frameRate, bandwidth);
+          resolution, frameRate);
 
       if (streamInfos) {
         goog.asserts.assert(streamInfos.audio.length ||
@@ -798,11 +873,10 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {?string} resolution
    * @param {?string} frameRate
-   * @param {number} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfos>}
    * @private
    */
-  async createStreamInfosForVariantTag_(tag, resolution, frameRate, bandwidth) {
+  async createStreamInfosForVariantTag_(tag, resolution, frameRate) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     /** @type {!Array.<string>} */
     let allCodecs = this.getCodecsForVariantTag_(tag);
@@ -872,8 +946,7 @@ shaka.hls.HlsParser = class {
     let streamInfo;
     if (!ignoreStream) {
       streamInfo =
-          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type,
-              bandwidth);
+          await this.createStreamInfoFromVariantTag_(tag, allCodecs, type);
     }
     if (streamInfo) {
       res[streamInfo.stream.type] = [streamInfo];
@@ -1314,11 +1387,10 @@ shaka.hls.HlsParser = class {
    * @param {!shaka.hls.Tag} tag
    * @param {!Array.<string>} allCodecs
    * @param {string} type
-   * @param {number} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
-  async createStreamInfoFromVariantTag_(tag, allCodecs, type, bandwidth) {
+  async createStreamInfoFromVariantTag_(tag, allCodecs, type) {
     goog.asserts.assert(tag.name == 'EXT-X-STREAM-INF',
         'Should only be called on variant tags!');
     const verbatimMediaPlaylistUri = this.variableSubstitution_(
@@ -1334,7 +1406,7 @@ shaka.hls.HlsParser = class {
         codecs, type, /* language= */ 'und', /* primary= */ false,
         /* name= */ null, /* channelcount= */ null, closedCaptions,
         /* characteristics= */ null, /* forced= */ false,
-        /* spatialAudio= */ false, bandwidth);
+        /* spatialAudio= */ false);
     if (streamInfo == null) {
       return null;
     }
@@ -1361,13 +1433,12 @@ shaka.hls.HlsParser = class {
    * @param {?string} characteristics
    * @param {boolean} forced
    * @param {boolean} spatialAudio
-   * @param {(number|undefined)} bandwidth
    * @return {!Promise.<?shaka.hls.HlsParser.StreamInfo>}
    * @private
    */
   async createStreamInfo_(verbatimMediaPlaylistUri, codecs, type, language,
       primary, name, channelsCount, closedCaptions, characteristics, forced,
-      spatialAudio, bandwidth = undefined) {
+      spatialAudio) {
     // TODO: Refactor, too many parameters
     let absoluteMediaPlaylistUri = shaka.hls.Utils.constructAbsoluteUri(
         this.masterPlaylistUri_, verbatimMediaPlaylistUri);
@@ -1381,6 +1452,34 @@ shaka.hls.HlsParser = class {
     const playlist = this.manifestTextParser_.parsePlaylist(
         response.data, absoluteMediaPlaylistUri);
 
+    return this.convertParsedPlaylistIntoStreamInfo_(playlist,
+        verbatimMediaPlaylistUri, absoluteMediaPlaylistUri, codecs, type,
+        language, primary, name, channelsCount, closedCaptions, characteristics,
+        forced, spatialAudio);
+  }
+
+  /**
+   * @param {!shaka.hls.Playlist} playlist
+   * @param {string} verbatimMediaPlaylistUri
+   * @param {string} absoluteMediaPlaylistUri
+   * @param {string} codecs
+   * @param {string} type
+   * @param {string} language
+   * @param {boolean} primary
+   * @param {?string} name
+   * @param {?number} channelsCount
+   * @param {Map.<string, string>} closedCaptions
+   * @param {?string} characteristics
+   * @param {boolean} forced
+   * @param {boolean} spatialAudio
+   * @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) {
     if (playlist.type != shaka.hls.PlaylistType.MEDIA) {
       // EXT-X-MEDIA and EXT-X-IMAGE-STREAM-INF tags should point to media
       // playlists.
@@ -1390,6 +1489,22 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_INVALID_PLAYLIST_HIERARCHY);
     }
 
+    /** @type {!Array.<!shaka.hls.Tag>} */
+    const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
+        'EXT-X-DEFINE');
+
+    const mediaVariables = this.parseMediaVariables_(variablesTags);
+
+    goog.asserts.assert(playlist.segments != null,
+        'Media playlist should have segments!');
+
+    this.determinePresentationType_(playlist);
+
+    if (!mimeType) {
+      mimeType = await this.guessMimeType_(type, codecs, playlist,
+          mediaVariables);
+    }
+
     /** @type {!Array.<!shaka.hls.Tag>} */
     const drmTags = [];
     if (playlist.segments) {
@@ -1424,7 +1539,7 @@ shaka.hls.HlsParser = class {
         const drmParser =
             shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_[keyFormat];
 
-        const drmInfo = drmParser ? drmParser(drmTag) : null;
+        const drmInfo = drmParser ? drmParser(drmTag, mimeType) : null;
         if (drmInfo) {
           if (drmInfo.keyIds) {
             for (const keyId of drmInfo.keyIds) {
@@ -1445,47 +1560,19 @@ shaka.hls.HlsParser = class {
           shaka.util.Error.Code.HLS_KEYFORMATS_NOT_SUPPORTED);
     }
 
-    /** @type {!Array.<!shaka.hls.Tag>} */
-    const variablesTags = shaka.hls.Utils.filterTagsByName(playlist.tags,
-        'EXT-X-DEFINE');
-
-    const mediaVariables = this.parseMediaVariables_(variablesTags);
-
-    goog.asserts.assert(playlist.segments != null,
-        'Media playlist should have segments!');
-
-    this.determinePresentationType_(playlist);
-
-    /** @type {string} */
-    const mimeType = await this.guessMimeType_(type, codecs, playlist,
-        mediaVariables);
-
     // MediaSource expects no codec strings combined with raw formats.
-    // TODO(#2337): Instead, create a Stream flag indicating a raw format.
-    if (shaka.hls.HlsParser.RAW_FORMATS_.includes(mimeType)) {
+    if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(mimeType)) {
       codecs = '';
     }
 
     /** @type {!Map.<number, number>} */
     const mediaSequenceToStartTime = new Map();
 
-    /**
-     * A map of a discontinuity sequence number, to the first segment's media
-     * sequence number with the discontinuity sequence number.
-     * Key: the discontinuity sequence number of a few segments
-     * Value: the first segment's media sequence number of the segments with
-     * this discontinuity sequence number.
-     * Used to get the discontinuity sequence number with playlist delta
-     * updates with lowLatencyMode enabled.
-     * {!Map.<number, number>}
-     */
-    const discontinuityToMediaSequence = new Map();
-
     let segments;
     try {
-      segments = await this.createSegments_(verbatimMediaPlaylistUri,
+      segments = this.createSegments_(verbatimMediaPlaylistUri,
           playlist, type, mimeType, mediaSequenceToStartTime, mediaVariables,
-          discontinuityToMediaSequence, codecs, bandwidth);
+          codecs);
     } catch (error) {
       if (error.code == shaka.util.Error.Code.HLS_INTERNAL_SKIP_STREAM) {
         shaka.log.alwaysWarn('Skipping unsupported HLS stream',
@@ -1557,7 +1644,6 @@ shaka.hls.HlsParser = class {
       minTimestamp,
       maxTimestamp: lastEndTime,
       mediaSequenceToStartTime,
-      discontinuityToMediaSequence,
       canSkipSegments,
     };
   }
@@ -1736,16 +1822,15 @@ shaka.hls.HlsParser = class {
    * @param {shaka.media.SegmentReference} previousReference
    * @param {!shaka.hls.Segment} hlsSegment
    * @param {number} startTime
-   * @param {number} timestampOffset
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
-   * @return {!shaka.media.SegmentReference}
    * @param {string} type
+   * @return {!shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      timestampOffset, variables, absoluteMediaPlaylistUri, type) {
+      variables, absoluteMediaPlaylistUri, type) {
     const tags = hlsSegment.tags;
     const absoluteSegmentUri = this.variableSubstitution_(
         hlsSegment.absoluteUri, variables);
@@ -1756,6 +1841,35 @@ 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.');
+    }
+
+    let syncTime = null;
+    if (!this.config_.hls.ignoreManifestProgramDateTime) {
+      const dateTimeTag =
+          shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-PROGRAM-DATE-TIME');
+      if (dateTimeTag && dateTimeTag.value) {
+        const time = shaka.util.XmlUtils.parseDate(dateTimeTag.value);
+        goog.asserts.assert(time != null,
+            'EXT-X-PROGRAM-DATE-TIME format not valid');
+        // Sync time offset is null on the first go-through. This indicates that
+        // we have not yet seen every stream, and thus do not yet have enough
+        // information to determine how to normalize the sync times.
+        // For that first go-through, the sync time will be applied after the
+        // references are all created. Until then, just offset by 0.
+        syncTime = time + (this.syncTimeOffset_ || 0);
+      }
+    }
+
+    let status = shaka.media.SegmentReference.Status.AVAILABLE;
+    if (shaka.hls.Utils.getFirstTagWithName(tags, 'EXT-X-GAP')) {
+      status = shaka.media.SegmentReference.Status.MISSING;
+    }
+
     // Create SegmentReferences for the partial segments.
     const partialSegmentRefs = [];
     if (this.lowLatencyMode_ && hlsSegment.partialSegments.length) {
@@ -1794,7 +1908,7 @@ shaka.hls.HlsParser = class {
             pStartByte,
             pEndByte,
             initSegmentReference,
-            timestampOffset,
+            /* timestampOffset= */ 0, // This value is ignored in sequence mode.
             /* appendWindowStart= */ 0,
             /* appendWindowEnd= */ Infinity);
         partialSegmentRefs.push(partial);
@@ -1862,12 +1976,14 @@ shaka.hls.HlsParser = class {
         startByte,
         endByte,
         initSegmentReference,
-        timestampOffset,
+        /* timestampOffset= */ 0, // This value is ignored in sequence mode.
         /* appendWindowStart= */ 0,
         /* appendWindowEnd= */ Infinity,
         partialSegmentRefs,
         tilesLayout,
         tileDuration,
+        syncTime,
+        status,
     );
   }
 
@@ -1921,15 +2037,12 @@ shaka.hls.HlsParser = class {
    * @param {string} mimeType
    * @param {!Map.<number, number>} mediaSequenceToStartTime
    * @param {!Map.<string, string>} variables
-   * @param {!Map.<number, number>} discontinuityToMediaSequence
    * @param {string} codecs
-   * @param {(number|undefined)} bandwidth
-   * @return {!Promise<!Array.<!shaka.media.SegmentReference>>}
+   * @return {!Array.<!shaka.media.SegmentReference>}
    * @private
    */
-  async createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
-      mediaSequenceToStartTime, variables, discontinuityToMediaSequence,
-      codecs, bandwidth) {
+  createSegments_(verbatimMediaPlaylistUri, playlist, type, mimeType,
+      mediaSequenceToStartTime, variables, codecs) {
     /** @type {Array.<!shaka.hls.Segment>} */
     const hlsSegments = playlist.segments;
     goog.asserts.assert(hlsSegments.length, 'Playlist should have segments!');
@@ -1946,69 +2059,26 @@ shaka.hls.HlsParser = class {
     const skippedSegments =
         skipTag ? Number(skipTag.getAttributeValue('SKIPPED-SEGMENTS')) : 0;
     let position = mediaSequenceNumber + skippedSegments;
-    let firstStartTime;
+    let firstStartTime = 0;
+
     // For live stream, use the cached value in the mediaSequenceToStartTime
     // map if available.
-    // Since createSegments_() is asynchronous and we are updating the streams
-    // in parallel, the global playlistStartTime_ may get updated by other
-    // playlist updates rather than the current one.
-
     if (this.isLive_() && mediaSequenceToStartTime.has(position)) {
       firstStartTime = mediaSequenceToStartTime.get(position);
-    } else {
-      if (this.playlistStartTime_ == null) {
-        // For VOD and EVENT playlists, all variants must start at the same
-        // time, so we can fetch the start time once and reuse for the others.
-        // This is not guaranteed when updating a LIVE stream. We assume the
-        // first segment in each live playlist is no more than one segment out
-        // of sync with the other playlists, so we can fetch the start time for
-        // once.
-        initSegmentRef = this.getInitSegmentReference_(
-            playlist.absoluteUri, hlsSegments[0].tags, variables);
-        goog.asserts.assert(
-            type != shaka.util.ManifestParserUtils.ContentType.TEXT &&
-            type != shaka.util.ManifestParserUtils.ContentType.IMAGE,
-            'Should only get start time from audio or video streams');
-        this.playlistStartTime_ = await this.getStartTime_(
-            verbatimMediaPlaylistUri, initSegmentRef, mimeType,
-            position, /* isDiscontinuity= */ false,
-            hlsSegments[0], variables, type, codecs, bandwidth);
-      }
-      firstStartTime = this.playlistStartTime_;
     }
 
     const firstSegmentUri = hlsSegments[0].absoluteUri;
     shaka.log.debug('First segment', firstSegmentUri.split('/').pop(),
         'starts at', firstStartTime);
 
-    let discontintuitySequenceNum = shaka.hls.Utils.getFirstTagWithNameAsNumber(
-        playlist.tags, 'EXT-X-DISCONTINUITY-SEQUENCE');
-    if (this.lowLatencyMode_) {
-      if (!discontinuityToMediaSequence.has(discontintuitySequenceNum)) {
-        discontinuityToMediaSequence.set(discontintuitySequenceNum, position);
-      }
-      if (skippedSegments) {
-        // With delta updates, the DISCONTINUITY may be skipped. Check if
-        // the discontintuity Sequence Number based on the media sequence
-        // number.
-        const disconMap = discontinuityToMediaSequence;
-        while (disconMap.has(discontintuitySequenceNum + 1) &&
-            disconMap.get(discontintuitySequenceNum + 1) < position) {
-          discontintuitySequenceNum++;
-        }
-      }
-    }
-    let timestampOffset =
-        this.discontinuityToTso_.get(discontintuitySequenceNum) || 0;
-
     /** @type {!Array.<!shaka.media.SegmentReference>} */
     const references = [];
 
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
       const previousReference = references[references.length - 1];
-      const startTime = (i == 0) ? firstStartTime :
-        previousReference.endTime;
+      const startTime =
+          (i == 0) ? firstStartTime : previousReference.endTime;
       position = mediaSequenceNumber + skippedSegments + i;
 
       mediaSequenceToStartTime.set(position, startTime);
@@ -2016,19 +2086,6 @@ shaka.hls.HlsParser = class {
       initSegmentRef = this.getInitSegmentReference_(playlist.absoluteUri,
           item.tags, variables);
 
-      const discontintuityTag = shaka.hls.Utils.getFirstTagWithName(item.tags,
-          'EXT-X-DISCONTINUITY');
-      if (discontintuityTag) {
-        discontintuitySequenceNum++;
-        discontinuityToMediaSequence.set(discontintuitySequenceNum, position);
-
-        // eslint-disable-next-line no-await-in-loop
-        timestampOffset = await this.getTimestampOffset_(
-            discontintuitySequenceNum, verbatimMediaPlaylistUri, initSegmentRef,
-            mimeType, position, item, variables, startTime, type, codecs,
-            bandwidth);
-      }
-
       // If the stream is low latency and the user has not configured the
       // lowLatencyMode, but if it has been configured to activate the
       // lowLatencyMode if a stream of this type is detected, we automatically
@@ -2041,514 +2098,94 @@ shaka.hls.HlsParser = class {
         }
       }
 
-      const extinfTag =
-          shaka.hls.Utils.getFirstTagWithName(item.tags, 'EXTINF');
-      if (this.lowLatencyMode_ || extinfTag) {
-        const reference = this.createSegmentReference_(
-            initSegmentRef,
-            previousReference,
-            item,
-            startTime,
-            timestampOffset,
-            variables,
-            playlist.absoluteUri,
-            type);
-
-        references.push(reference);
-      } else if (!this.lowLatencyMode_) {
-        // If a segment has no extinfTag, it must contain partial segments.
-        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.');
-      }
-    }
-
-    return references;
-  }
-
-  /**
-   * Gets the start time of the first segment of the playlist from existing
-   * value (if possible) or by downloading it and parsing it otherwise.
-   *
-   * @param {number} discontintuitySequenceNum
-   * @param {string} verbatimMediaPlaylistUri
-   * @param {shaka.media.InitSegmentReference} initSegmentRef
-   * @param {string} mimeType
-   * @param {number} mediaSequenceNumber
-   * @param {!shaka.hls.Segment} segment
-   * @param {!Map.<string, string>} variables
-   * @param {number} startTime
-   * @param {string} type
-   * @param {string} codecs
-   * @param {number|undefined} bandwidth
-   * @return {!Promise.<number>}
-   * @throws {shaka.util.Error}
-   * @private
-   */
-  async getTimestampOffset_(discontintuitySequenceNum,
-      verbatimMediaPlaylistUri, initSegmentRef,
-      mimeType, mediaSequenceNumber, segment, variables, startTime, type,
-      codecs, bandwidth) {
-    let timestampOffset = 0;
-    if (this.discontinuityToTso_.has(discontintuitySequenceNum)) {
-      timestampOffset =
-          this.discontinuityToTso_.get(discontintuitySequenceNum);
-    } else {
-      const mediaStartTime = await this.getStartTime_(
-          verbatimMediaPlaylistUri, initSegmentRef, mimeType,
-          mediaSequenceNumber, /* isDiscontinuity= */ true, segment,
-          variables, type, codecs, bandwidth);
-      timestampOffset = startTime - mediaStartTime;
-      shaka.log.v1('Segment timestampOffset =', timestampOffset);
-      this.discontinuityToTso_.set(
-          discontintuitySequenceNum, timestampOffset);
-    }
-    return timestampOffset;
-  }
-
-  /**
-   * Try to fetch the starting part of a segment, and fall back to a full
-   * segment if we have to.
-   *
-   * @param {!shaka.media.AnySegmentReference} reference
-   * @param {string} type
-   * @param {string} mimeType
-   * @param {string} codecs
-   * @param {number|undefined} bandwidth
-   * @return {!Promise.<shaka.extern.Response>}
-   * @private
-   */
-  async fetchStartOfSegment_(reference, type, mimeType, codecs, bandwidth) {
-    const requestType = shaka.net.NetworkingEngine.RequestType.SEGMENT;
-
-    // Create two requests:
-    //  1. A partial request meant to fetch the smallest part of the segment
-    //     required to get the time stamp.
-    //  2. A full request meant as a fallback for when the server does not
-    //     support partial requests.
-    const fullRequest = shaka.util.Networking.createSegmentRequest(
-        reference.getUris(),
-        reference.startByte,
-        reference.endByte,
-        this.config_.retryParameters);
-
-    // We can only add partial CMCD data here because the stream
-    // and manifest objects are still being created
-    this.playerInterface_.modifySegmentRequest(
-        fullRequest,
-        {
-          type: type,
-          init: reference instanceof shaka.media.InitSegmentReference,
-          duration: reference.endTime - reference.startTime,
-          mimeType: mimeType,
-          codecs: codecs,
-          bandwidth: bandwidth,
-        },
-    );
-
-    if (this.config_.hls.useFullSegmentsForStartTime) {
-      return this.makeNetworkRequest_(fullRequest, requestType);
-    }
-
-    const partialRequest = shaka.util.Networking.createSegmentRequest(
-        reference.getUris(),
-        reference.startByte,
-        reference.startByte + shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_ - 1,
-        this.config_.retryParameters);
-
-    this.playerInterface_.modifySegmentRequest(
-        partialRequest,
-        {
-          type: type,
-          init: reference instanceof shaka.media.InitSegmentReference,
-          duration: reference.endTime - reference.startTime,
-          mimeType: mimeType,
-          codecs: codecs,
-          bandwidth: bandwidth,
-        },
-    );
-
-    // TODO(vaage): The need to do fall back requests is not likely to be unique
-    //    to here. It would be nice if the fallback(s) could be included into
-    //    the same abortable operation as the original request.
-    //
-    //    What would need to change with networking engine to support requests
-    //    with fallback(s)?
-    try {
-      const response = await this.makeNetworkRequest_(
-          partialRequest, requestType);
-
-      return response;
-    } catch (e) {
-      // If the networking operation was aborted, we don't want to treat it as
-      // a request failure. We surface the error so that the OPERATION_ABORTED
-      // error will be handled correctly.
-      if (e.code == shaka.util.Error.Code.OPERATION_ABORTED) {
-        throw e;
-      }
-
-      // The partial request may fail for a number of reasons.
-      // Some servers do not support Range requests, and others do not support
-      // the OPTIONS request which must be made before any cross-origin Range
-      // request.  Since this fallback is expensive, warn the app developer.
-      shaka.log.alwaysWarn('Unable to fetch the starting part of HLS ' +
-                           'segment! Falling back to a full segment request, ' +
-                           'which is expensive!  Your server should ' +
-                           'support Range requests and CORS preflights.',
-      partialRequest.uris[0]);
-
-      const response = await this.makeNetworkRequest_(fullRequest, requestType);
-
-      return response;
-    }
-  }
-
-  /**
-   * Gets the start time of a segment from the existing manifest (if possible)
-   * or by downloading it and parsing it otherwise.
-   *
-   * @param {string} verbatimMediaPlaylistUri
-   * @param {shaka.media.InitSegmentReference} initSegmentRef
-   * @param {string} mimeType
-   * @param {number} mediaSequenceNumber
-   * @param {boolean} isDiscontinuity
-   * @param {!shaka.hls.Segment} segment
-   * @param {!Map.<string, string>} variables
-   * @param {string} type
-   * @param {string} codecs
-   * @param {number|undefined} bandwidth
-   * @return {!Promise.<number>}
-   * @private
-   */
-  async getStartTime_(
-      verbatimMediaPlaylistUri, initSegmentRef, mimeType, mediaSequenceNumber,
-      isDiscontinuity, segment, variables, type, codecs, bandwidth) {
-    const segmentRef = this.createSegmentReference_(
-        initSegmentRef,
-        /* previousReference= */ null,
-        segment,
-        /* startTime= */ 0,
-        /* timestampOffset= */ 0,
-        variables,
-        /* absoluteMediaPlaylistUri= */ '',
-        type);
-    // If we are updating the manifest, we can usually skip fetching the segment
-    // by examining the references we already have.  This won't be possible if
-    // there was some kind of lag or delay updating the manifest on the server,
-    // in which extreme case we would fall back to fetching a segment.  This
-    // allows us to both avoid fetching segments when possible, and recover from
-    // certain server-side issues gracefully.
-    // Do not use cached start time for the segments with discontinuity tags.
-    if (this.manifest_ && !isDiscontinuity) {
-      const streamInfo =
-          this.uriToStreamInfosMap_.get(verbatimMediaPlaylistUri);
-      const startTime = streamInfo.mediaSequenceToStartTime.get(
-          mediaSequenceNumber);
-      if (startTime != undefined) {
-        // We found it!  Avoid fetching and parsing the segment.
-        shaka.log.v1('Found segment start time in previous manifest',
-            startTime);
-        return startTime;
-      }
-
-      shaka.log.debug(
-          'Unable to find segment start time in previous manifest!');
-    }
-
-    // TODO: Introduce a new tag to extend HLS and provide the first segment's
-    // start time.  This will avoid the need for these fetches in content
-    // packaged with Shaka Packager.  This web-friendly extension to HLS can
-    // then be proposed to Apple for inclusion in a future version of HLS.
-    // See https://github.com/google/shaka-packager/issues/294
-
-    shaka.log.v1('Fetching segment to find start time');
-    mimeType = mimeType.toLowerCase();
-
-    if (shaka.hls.HlsParser.RAW_FORMATS_.includes(mimeType)) {
-      // Raw formats contain no timestamps.  Even if there is an ID3 tag with a
-      // timestamp, that's not going to be honored by MediaSource, which will
-      // use sequence mode for these segments.  We don't yet support sequence
-      // mode, so we must reject these streams.
-      // TODO(#2337): Support sequence mode and align raw format timestamps to
-      // other streams.
-      shaka.log.alwaysWarn(
-          'Raw formats are not yet supported.  Skipping ' + mimeType);
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_INTERNAL_SKIP_STREAM);
-    }
-
-    if (mimeType == 'video/webm') {
-      shaka.log.alwaysWarn('WebM in HLS is not yet supported.  Skipping.');
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.RECOVERABLE,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_INTERNAL_SKIP_STREAM);
-    }
-
-    if (mimeType == 'video/mp4' || mimeType == 'audio/mp4') {
-      // We also need the init segment to get the correct timescale. But if the
-      // stream is self-initializing, use the same response for both.
-      const fetches = [this.fetchStartOfSegment_(
-          segmentRef,
-          type,
-          mimeType,
-          codecs,
-          bandwidth,
-      )];
-
-      if (initSegmentRef) {
-        fetches.push(this.fetchStartOfSegment_(
-            initSegmentRef,
-            type,
-            mimeType,
-            codecs,
-            bandwidth,
-        ));
-      }
-
-      const responses = await Promise.all(fetches);
-
-      // If the stream is self-initializing, use the main segment in-place of
-      // the init segment.
-      const segmentResponse = responses[0];
-      const initSegmentResponse = responses[1] || responses[0];
-
-      return this.getStartTimeFromMp4Segment_(
-          verbatimMediaPlaylistUri, segmentResponse.uri,
-          segmentResponse.data, initSegmentResponse.data);
-    }
-
-    if (mimeType == 'video/mp2t') {
-      const response = await this.fetchStartOfSegment_(
-          segmentRef,
-          type,
-          mimeType,
-          codecs,
-          bandwidth,
-      );
-      goog.asserts.assert(response.data, 'Should have a response body!');
-      return this.getStartTimeFromTsSegment_(
-          verbatimMediaPlaylistUri, response.uri, response.data);
-    }
-
-    throw new shaka.util.Error(
-        shaka.util.Error.Severity.CRITICAL,
-        shaka.util.Error.Category.MANIFEST,
-        shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME,
-        verbatimMediaPlaylistUri);
-  }
-
-  /**
-   * Parses an mp4 segment to get its start time.
-   *
-   * @param {string} playlistUri
-   * @param {string} segmentUri
-   * @param {BufferSource} mediaData
-   * @param {BufferSource} initData
-   * @return {number}
-   * @private
-   */
-  getStartTimeFromMp4Segment_(playlistUri, segmentUri, mediaData, initData) {
-    const Mp4Parser = shaka.util.Mp4Parser;
-
-    let timescale = 0;
-    new Mp4Parser()
-        .box('moov', Mp4Parser.children)
-        .box('trak', Mp4Parser.children)
-        .box('mdia', Mp4Parser.children)
-        .fullBox('mdhd', (box) => {
-          goog.asserts.assert(
-              box.version == 0 || box.version == 1,
-              'MDHD version can only be 0 or 1');
-
-          const parsedMDHDBox = shaka.util.Mp4BoxParsers.parseMDHD(
-              box.reader, box.version);
-
-          timescale = parsedMDHDBox.timescale;
-          box.parser.stop();
-        }).parse(initData, /* partialOkay= */ true);
-
-    if (!timescale) {
-      shaka.log.error('Unable to find timescale in init segment!');
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME,
-          playlistUri, segmentUri);
-    }
-
-    let startTime = 0;
-    let parsedMedia = false;
-    new Mp4Parser()
-        .box('moof', Mp4Parser.children)
-        .box('traf', Mp4Parser.children)
-        .fullBox('tfdt', (box) => {
-          goog.asserts.assert(
-              box.version == 0 || box.version == 1,
-              'TFDT version can only be 0 or 1');
-
-          const parsedTFDTBox = shaka.util.Mp4BoxParsers.parseTFDT(
-              box.reader, box.version);
-          const baseTime = parsedTFDTBox.baseMediaDecodeTime;
-          startTime = baseTime / timescale;
-          parsedMedia = true;
-          box.parser.stop();
-        }).parse(mediaData, /* partialOkay= */ true);
-
-    if (!parsedMedia) {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME,
-          playlistUri, segmentUri);
-    }
-    return startTime;
-  }
-
-  /**
-   * Parses a TS segment to get its start time.
-   *
-   * @param {string} playlistUri
-   * @param {string} segmentUri
-   * @param {BufferSource} data
-   * @return {number}
-   * @private
-   */
-  getStartTimeFromTsSegment_(playlistUri, segmentUri, data) {
-    const reader = new shaka.util.DataViewReader(
-        data, shaka.util.DataViewReader.Endianness.BIG_ENDIAN);
-
-    const fail = () => {
-      throw new shaka.util.Error(
-          shaka.util.Error.Severity.CRITICAL,
-          shaka.util.Error.Category.MANIFEST,
-          shaka.util.Error.Code.HLS_COULD_NOT_PARSE_SEGMENT_START_TIME,
-          playlistUri, segmentUri);
-    };
-
-    let packetStart = 0;
-    let syncByte = 0;
-
-    const skipPacket = () => {
-      // 188-byte packets are standard, so assume that.
-      reader.seek(packetStart + 188);
-      syncByte = reader.readUint8();
-      if (syncByte != 0x47) {
-        // We haven't found the sync byte, so try it as a 192-byte packet.
-        reader.seek(packetStart + 192);
-        syncByte = reader.readUint8();
-      }
-      if (syncByte != 0x47) {
-        // We still haven't found the sync byte, so try as a 204-byte packet.
-        reader.seek(packetStart + 204);
-        syncByte = reader.readUint8();
-      }
-      if (syncByte != 0x47) {
-        // We still haven't found the sync byte, so the packet was of a
-        // non-standard size.
-        fail();
-      }
-      // Put the sync byte back so we can read it in the next loop.
-      reader.rewind(1);
-    };
-
-    // We will look a few packet-lengths forward to find the first sync byte.
-    // Note that we are using this method on what is already a subset of the
-    // file (the first |shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_| bytes), so
-    // we can't look too far ahead to begin with.
-    let syncByteScanLength = Math.min(reader.getLength() - 188, 5 * 188);
-
-    // TODO: refactor this while loop for better readability.
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      // Format reference: https://bit.ly/TsPacket
-      packetStart = reader.getPosition();
-
-      syncByte = reader.readUint8();
-      if (syncByte != 0x47) {
-        if (syncByteScanLength > 0) {
-          // This file could have started with a cut-off TS packet. Scan forward
-          // until we find a sync byte.
-          syncByteScanLength -= 1;
+      const reference = this.createSegmentReference_(
+          initSegmentRef,
+          previousReference,
+          item,
+          startTime,
+          variables,
+          playlist.absoluteUri,
+          type);
+
+      references.push(reference);
+    }
+
+    // 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);
+    if (someSyncTime) {
+      for (let i = 0; i < references.length; i++) {
+        const reference = references[i];
+        if (reference.syncTime != null) {
+          // No need to extrapolate.
           continue;
         }
-        fail();
-      }
-      // If we've found a sync byte, stop scanning forward for future packets.
-      syncByteScanLength = 0;
-
-      const flagsAndPacketId = reader.readUint16();
-      const packetId = flagsAndPacketId & 0x1fff;
-      if (packetId == 0x1fff) {
-        // A "null" TS packet.  Skip this TS packet and try again.
-        skipPacket();
-        continue;
-      }
-
-      const hasPesPacket = flagsAndPacketId & 0x4000;
-      if (!hasPesPacket) {
-        // Not a PES packet yet.  Skip this TS packet and try again.
-        skipPacket();
-        continue;
-      }
-
-      const flags = reader.readUint8();
-      const adaptationFieldControl = (flags & 0x30) >> 4;
-      if (adaptationFieldControl == 0 /* reserved */ ||
-          adaptationFieldControl == 2 /* adaptation field, no payload */) {
-        fail();
-      }
-
-      if (adaptationFieldControl == 3) {
-        // Skip over adaptation field.
-        const length = reader.readUint8();
-        reader.skip(length);
-      }
-
-      // Now we come to the PES header (hopefully).
-      // Format reference: https://bit.ly/TsPES
-      const startCode = reader.readUint32();
-      const startCodePrefix = startCode >> 8;
-      if (startCodePrefix != 1) {
-        // Not a PES packet yet.  Skip this TS packet and try again.
-        skipPacket();
-        continue;
-      }
-
-      // Skip the 16-bit PES length and the first 8 bits of the optional header.
-      reader.skip(3);
-      // The next 8 bits contain flags about DTS & PTS.
-      const ptsDtsIndicator = reader.readUint8() >> 6;
-      if (ptsDtsIndicator == 0 /* no timestamp */ ||
-          ptsDtsIndicator == 1 /* forbidden */) {
-        fail();
-      }
-
-      const pesHeaderLengthRemaining = reader.readUint8();
-      if (pesHeaderLengthRemaining == 0) {
-        fail();
+        // Find the nearest segment with syncTime, in either direction.
+        // This looks forward and backward simultaneously, keeping track of what
+        // to offset the syncTime it finds by as it goes.
+        let forwardAdd = 0;
+        let forwardI = i;
+        /**
+         * Look forwards one reference at a time, summing all durations as we
+         * go, until we find a reference with a syncTime to use as a basis.
+         * This DOES count the original reference, but DOESN'T count the first
+         * reference with a syncTime (as we approach it from behind).
+         * @return {?number}
+         */
+        const lookForward = () => {
+          const other = references[forwardI];
+          if (other) {
+            if (other.syncTime != null) {
+              return other.syncTime + forwardAdd;
+            }
+            forwardAdd -= other.endTime - other.startTime;
+            forwardI += 1;
+          }
+          return null;
+        };
+        let backwardAdd = 0;
+        let backwardI = i;
+        /**
+         * Look backwards one reference at a time, summing all durations as we
+         * go, until we find a reference with a syncTime to use as a basis.
+         * This DOESN'T count the original reference, but DOES count the first
+         * reference with a syncTime (as we approach it from ahead).
+         * @return {?number}
+         */
+        const lookBackward = () => {
+          const other = references[backwardI];
+          if (other) {
+            if (other != reference) {
+              backwardAdd += other.endTime - other.startTime;
+            }
+            if (other.syncTime != null) {
+              return other.syncTime + backwardAdd;
+            }
+            backwardI -= 1;
+          }
+          return null;
+        };
+        while (reference.syncTime == null) {
+          reference.syncTime = lookBackward();
+          if (reference.syncTime == null) {
+            reference.syncTime = lookForward();
+          }
+        }
       }
+    }
 
-      if (ptsDtsIndicator == 2 /* PTS only */) {
-        goog.asserts.assert(pesHeaderLengthRemaining == 5, 'Bad PES header?');
-      } else if (ptsDtsIndicator == 3 /* PTS and DTS */) {
-        goog.asserts.assert(pesHeaderLengthRemaining == 10, 'Bad PES header?');
+    // Split the sync times properly among partial segments.
+    if (someSyncTime) {
+      for (const reference of references) {
+        let syncTime = reference.syncTime;
+        for (const partial of reference.partialReferences) {
+          partial.syncTime = syncTime;
+          syncTime += partial.endTime - partial.startTime;
+        }
       }
-
-      const pts0 = reader.readUint8();
-      const pts1 = reader.readUint16();
-      const pts2 = reader.readUint16();
-      // Reconstruct 33-bit PTS from the 5-byte, padded structure.
-      const ptsHigh3 = (pts0 & 0x0e) >> 1;
-      const ptsLow30 = ((pts1 & 0xfffe) << 14) | ((pts2 & 0xfffe) >> 1);
-      // Reconstruct the PTS as a float.  Avoid bitwise operations to combine
-      // because bitwise ops treat the values as 32-bit ints.
-      const pts = ptsHigh3 * (1 << 30) + ptsLow30;
-      return pts / shaka.hls.HlsParser.TS_TIMESCALE_;
     }
+
+    return references;
   }
 
   /**
@@ -2615,11 +2252,10 @@ shaka.hls.HlsParser = class {
 
     if (contentType == ContentType.TEXT) {
       // The extension map didn't work.
-      if (!codecs || codecs == 'vtt' || codecs == 'wvtt') {
+      if (codecs == 'vtt' || codecs == 'wvtt') {
         // If codecs is 'vtt', it's WebVTT.
-        // If there was no codecs string, assume HLS text streams are WebVTT.
         return 'text/vtt';
-      } else {
+      } else if (codecs && codecs !== '') {
         // Otherwise, assume MP4-embedded text, since text-based formats tend
         // not to have a codecs string at all.
         return 'application/mp4';
@@ -2644,6 +2280,11 @@ shaka.hls.HlsParser = class {
     const contentMimeType = response.headers['content-type'];
 
     if (!contentMimeType) {
+      if (contentType == ContentType.TEXT) {
+        // If there was no codecs string and no content-type, assume HLS text
+        // streams are WebVTT.
+        return 'text/vtt';
+      }
       // If the HLS content is lacking in both MIME type metadata and
       // segment file extensions, we fall back to assuming it's MP4.
       const fallbackMimeType = map['mp4'];
@@ -2809,6 +2450,33 @@ shaka.hls.HlsParser = class {
     return op.promise;
   }
 
+  /**
+   * @param {!shaka.hls.Tag} drmTag
+   * @param {string} mimeType
+   * @return {?shaka.extern.DrmInfo}
+   * @private
+   */
+  static fairplayDrmParser_(drmTag, mimeType) {
+    if (mimeType == 'video/mp2t') {
+      throw new shaka.util.Error(
+          shaka.util.Error.Severity.CRITICAL,
+          shaka.util.Error.Category.MANIFEST,
+          shaka.util.Error.Code.HLS_MSE_ENCRYPTED_MP2T_NOT_SUPPORTED);
+    }
+
+    /*
+     * Even if we're not able to construct initData through the HLS tag, adding
+     * a DRMInfo will allow DRM Engine to request a media key system access
+     * with the correct keySystem and initDataType
+     */
+    const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
+        'com.apple.fps', [
+          {initDataType: 'sinf', initData: new Uint8Array(0)},
+        ]);
+
+    return drmInfo;
+  }
+
   /**
    * @param {!shaka.hls.Tag} drmTag
    * @return {?shaka.extern.DrmInfo}
@@ -2871,7 +2539,10 @@ shaka.hls.HlsParser = class {
       0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
       0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
     ]);
-    const pssh = shaka.util.Pssh.createPssh(data, systemId);
+    const keyIds = new Set();
+    const psshVersion = 0;
+    const pssh =
+        shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
     const drmInfo = shaka.util.ManifestParserUtils.createDrmInfo(
         'com.microsoft.playready', [
           {initDataType: 'cenc', initData: pssh},
@@ -2890,7 +2561,6 @@ shaka.hls.HlsParser = class {
  *   minTimestamp: number,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
- *   discontinuityToMediaSequence: !Map.<number, number>,
  *   canSkipSegments: boolean
  * }}
  *
@@ -2913,9 +2583,6 @@ shaka.hls.HlsParser = class {
  *   The maximum timestamp found in the stream.
  * @property {!Map.<number, number>} mediaSequenceToStartTime
  *   A map of media sequence numbers to media start times.
- * @property  {!Map.<number, number>} discontinuityToMediaSequence
- *   A map of discontinuity sequence numbers to the media sequence number of the
- *   segment starting with that discontinuity sequence number.
  * @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.
@@ -2959,21 +2626,6 @@ shaka.hls.HlsParser.AUDIO_EXTENSIONS_TO_MIME_TYPES_ = {
 };
 
 
-/**
- * MIME types of raw formats.
- * TODO(#2337): Support raw formats and share this list among parsers.
- *
- * @const {!Array.<string>}
- * @private
- */
-shaka.hls.HlsParser.RAW_FORMATS_ = [
-  'audio/aac',
-  'audio/ac3',
-  'audio/ec3',
-  'audio/mpeg',
-];
-
-
 /**
  * @const {!Object.<string, string>}
  * @private
@@ -3031,7 +2683,7 @@ shaka.hls.HlsParser.EXTENSION_MAP_BY_CONTENT_TYPE_ = {
 
 
 /**
- * @typedef {function(!shaka.hls.Tag):?shaka.extern.DrmInfo}
+ * @typedef {function(!shaka.hls.Tag, string):?shaka.extern.DrmInfo}
  * @private
  */
 shaka.hls.HlsParser.DrmParser_;
@@ -3042,10 +2694,8 @@ shaka.hls.HlsParser.DrmParser_;
  * @private
  */
 shaka.hls.HlsParser.KEYFORMATS_TO_DRM_PARSERS_ = {
-  /* TODO: https://github.com/google/shaka-player/issues/382
   'com.apple.streamingkeydelivery':
       shaka.hls.HlsParser.fairplayDrmParser_,
-  */
   'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed':
       shaka.hls.HlsParser.widevineDrmParser_,
   'com.microsoft.playready':
@@ -3063,28 +2713,13 @@ shaka.hls.HlsParser.PresentationType_ = {
   LIVE: 'LIVE',
 };
 
-
-/**
- * @const {number}
- * @private
- */
-shaka.hls.HlsParser.TS_TIMESCALE_ = 90000;
-
-
-/**
- * The amount of data from the start of a segment we will try to fetch when we
- * need to know the segment start time.  This allows us to avoid fetching the
- * entire segment in many cases.
- *
- * @const {number}
- * @private
- */
-shaka.hls.HlsParser.START_OF_SEGMENT_SIZE_ = 2048;
-
-
-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());
+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());
+}