shaka-player 4.3.5 → 4.3.7

package/lib/hls/hls_parser.js

@@ -319,6 +319,9 @@ shaka.hls.HlsParser = class {
       this.presentationTimeline_.setDuration(Math.min(...maxTimestamps));
       this.playerInterface_.updateDuration();
     }
+    if (stillLive) {
+      this.determineDuration_();
+    }
   }
 
   /**
@@ -400,9 +403,16 @@ shaka.hls.HlsParser = class {
           mediaSequenceNumber);
       stream.segmentIndex.evict(playlistStartTime);
     }
+    const oldSegment = segments[0];
+    goog.asserts.assert(oldSegment, 'Should have segments!');
+
+    streamInfo.minTimestamp = oldSegment.startTime;
+
     const newestSegment = segments[segments.length - 1];
     goog.asserts.assert(newestSegment, 'Should have segments!');
 
+    streamInfo.maxTimestamp = newestSegment.endTime;
+
     // Once the last segment has been added to the playlist,
     // #EXT-X-ENDLIST tag will be appended.
     // If that happened, treat the rest of the EVENT presentation as VOD.
@@ -413,7 +423,6 @@ shaka.hls.HlsParser = class {
       // Flag this for later.  We don't convert the whole presentation into VOD
       // until we've seen the ENDLIST tag for all active playlists.
       streamInfo.hasEndList = true;
-      streamInfo.maxTimestamp = newestSegment.endTime;
     }
   }
 
@@ -576,6 +585,9 @@ shaka.hls.HlsParser = class {
    * @private
    */
   offsetStreamInfo_(streamInfo, offset) {
+    // Adjust our accounting of the minimum timestamp.
+    streamInfo.minTimestamp += offset;
+
     // Adjust our accounting of the maximum timestamp.
     streamInfo.maxTimestamp += offset;
     goog.asserts.assert(streamInfo.maxTimestamp >= 0,
@@ -804,7 +816,7 @@ shaka.hls.HlsParser = class {
       const PresentationType = shaka.hls.HlsParser.PresentationType_;
 
       if (this.presentationType_ == PresentationType.LIVE) {
-        let segmentAvailabilityDuration = this.getMinDuration_();
+        let segmentAvailabilityDuration = this.getLiveDuration_();
 
         // This defaults to the presentation delay, which has the effect of
         // making the live stream unseekable.  This is consistent with Apple's
@@ -1458,9 +1470,9 @@ shaka.hls.HlsParser = class {
     let codecs = '';
     /** @type {string} */
     const type = this.getType_(tag);
-    // Text does not require a codec.
-    if (type != shaka.util.ManifestParserUtils.ContentType.TEXT && groupId &&
-        this.groupIdToCodecsMap_.has(groupId)) {
+    if (type == shaka.util.ManifestParserUtils.ContentType.TEXT) {
+      codecs = tag.getAttributeValue('CODECS') || '';
+    } else if (groupId && this.groupIdToCodecsMap_.has(groupId)) {
       codecs = this.groupIdToCodecsMap_.get(groupId);
     }
 
@@ -1655,6 +1667,7 @@ shaka.hls.HlsParser = class {
       verbatimMediaPlaylistUri,
       // These values are filled out or updated after lazy-loading:
       absoluteMediaPlaylistUri: initialMediaPlaylistUri,
+      minTimestamp: 0,
       maxTimestamp: 0,
       mediaSequenceToStartTime: new Map(),
       canSkipSegments: false,
@@ -1700,6 +1713,7 @@ shaka.hls.HlsParser = class {
 
       // Copy values from the real stream info to our initial one.
       streamInfo.absoluteMediaPlaylistUri = absoluteMediaPlaylistUri;
+      streamInfo.minTimestamp = realStreamInfo.minTimestamp;
       streamInfo.maxTimestamp = realStreamInfo.maxTimestamp;
       streamInfo.canSkipSegments = realStreamInfo.canSkipSegments;
       streamInfo.hasEndList = realStreamInfo.hasEndList;
@@ -1736,6 +1750,13 @@ shaka.hls.HlsParser = class {
         }
       }
 
+      if (type == ContentType.TEXT) {
+        const firstSegment = realStream.segmentIndex.get(0);
+        if (firstSegment && firstSegment.initSegmentReference) {
+          stream.mimeType = 'application/mp4';
+        }
+      }
+
       // 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_()) {
@@ -1826,6 +1847,22 @@ shaka.hls.HlsParser = class {
     return minDuration;
   }
 
+  /**
+   * @return {number}
+   * @private
+   */
+  getLiveDuration_() {
+    let maxTimestamp = Infinity;
+    let minTimestamp = Infinity;
+    for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+      if (streamInfo.stream.segmentIndex && streamInfo.stream.type != 'text') {
+        maxTimestamp = Math.min(maxTimestamp, streamInfo.maxTimestamp);
+        minTimestamp = Math.min(minTimestamp, streamInfo.minTimestamp);
+      }
+    }
+    return maxTimestamp - minTimestamp;
+  }
+
   /**
    * @param {!Array.<!shaka.extern.Stream>} streams
    * @private
@@ -1971,6 +2008,7 @@ shaka.hls.HlsParser = class {
       this.determinePresentationType_(playlist);
     }
 
+    const firstStartTime = segments[0].startTime;
     const lastEndTime = segments[segments.length - 1].endTime;
     /** @type {!shaka.media.SegmentIndex} */
     const segmentIndex = new shaka.media.SegmentIndex(segments);
@@ -1993,6 +2031,7 @@ shaka.hls.HlsParser = class {
       type,
       verbatimMediaPlaylistUri,
       absoluteMediaPlaylistUri,
+      minTimestamp: firstStartTime,
       maxTimestamp: lastEndTime,
       canSkipSegments,
       hasEndList: false,
@@ -2371,13 +2410,15 @@ shaka.hls.HlsParser = class {
    * @param {!Map.<string, string>} variables
    * @param {string} absoluteMediaPlaylistUri
    * @param {string} type
+   * @param {number} timestampOffset
    * @param {shaka.extern.HlsAes128Key=} hlsAes128Key
    * @return {shaka.media.SegmentReference}
    * @private
    */
   createSegmentReference_(
       initSegmentReference, previousReference, hlsSegment, startTime,
-      variables, absoluteMediaPlaylistUri, type, hlsAes128Key) {
+      variables, absoluteMediaPlaylistUri, type, timestampOffset,
+      hlsAes128Key) {
     const tags = hlsSegment.tags;
     const absoluteSegmentUri = this.variableSubstitution_(
         hlsSegment.absoluteUri, variables);
@@ -2489,6 +2530,9 @@ shaka.hls.HlsParser = class {
             /* tileDuration= */ null,
             /* syncTime= */ null,
             partialStatus);
+        if (item.name == 'EXT-X-PRELOAD-HINT') {
+          partial.markAsPreload();
+        }
         partialSegmentRefs.push(partial);
       } // for-loop of hlsSegment.partialSegments
     }
@@ -2547,7 +2591,7 @@ shaka.hls.HlsParser = class {
         startByte,
         endByte,
         initSegmentReference,
-        /* timestampOffset= */ 0, // This value is ignored in sequence mode.
+        timestampOffset, // This value is ignored in sequence mode.
         /* appendWindowStart= */ 0,
         /* appendWindowEnd= */ Infinity,
         partialSegmentRefs,
@@ -2632,6 +2676,7 @@ shaka.hls.HlsParser = class {
     const references = [];
 
     let previousReference = null;
+    let lastDiscontinuityStartTime = firstStartTime;
 
     for (let i = 0; i < hlsSegments.length; i++) {
       const item = hlsSegments[i];
@@ -2643,6 +2688,7 @@ shaka.hls.HlsParser = class {
           item.tags, 'EXT-X-DISCONTINUITY');
       if (discontinuityTag) {
         discontinuitySequence++;
+        lastDiscontinuityStartTime = startTime;
       }
 
       // Apply new AES-128 tags as you see them, keeping a running total.
@@ -2681,6 +2727,7 @@ shaka.hls.HlsParser = class {
           variables,
           playlist.absoluteUri,
           type,
+          lastDiscontinuityStartTime,
           hlsAes128Key);
       previousReference = reference;
 
@@ -2795,6 +2842,9 @@ shaka.hls.HlsParser = class {
    * @private
    */
   variableSubstitution_(uri, variables) {
+    if (!variables.size) {
+      return uri;
+    }
     let newUri = String(uri).replace(/%7B/g, '{').replace(/%7D/g, '}');
 
     const uriVariables = newUri.match(/{\$\w*}/g);
@@ -3240,6 +3290,7 @@ shaka.hls.HlsParser = class {
  *   type: string,
  *   verbatimMediaPlaylistUri: string,
  *   absoluteMediaPlaylistUri: string,
+ *   minTimestamp: number,
  *   maxTimestamp: number,
  *   mediaSequenceToStartTime: !Map.<number, number>,
  *   canSkipSegments: boolean,
@@ -3263,6 +3314,8 @@ shaka.hls.HlsParser = class {
  * @property {string} absoluteMediaPlaylistUri
  *   The absolute media playlist URI, resolved relative to the master playlist
  *   and updated to reflect any redirects.
+ * @property {number} minTimestamp
+ *   The minimum timestamp found in the stream.
  * @property {number} maxTimestamp
  *   The maximum timestamp found in the stream.
  * @property {!Map.<number, number>} mediaSequenceToStartTime

package/lib/hls/manifest_text_parser.js

@@ -158,7 +158,15 @@ shaka.hls.ManifestTextParser = class {
             partialSegmentTags.push(tag);
           } else if (tag.name == 'EXT-X-PRELOAD-HINT') {
             if (tag.getAttributeValue('TYPE') == 'PART') {
-              partialSegmentTags.push(tag);
+              // Note: BYTERANGE-START without BYTERANGE-LENGTH is being
+              // ignored.
+              if (tag.getAttributeValue('BYTERANGE-START') != null) {
+                if (tag.getAttributeValue('BYTERANGE-LENGTH') != null) {
+                  partialSegmentTags.push(tag);
+                }
+              } else {
+                partialSegmentTags.push(tag);
+              }
             } else if (tag.getAttributeValue('TYPE') == 'MAP') {
               // Rename the Preload Hint tag to be a Map tag.
               tag.setName('EXT-X-MAP');
@@ -300,6 +308,7 @@ shaka.hls.ManifestTextParser.MEDIA_PLAYLIST_TAGS = [
   'EXT-X-ENDLIST',
   'EXT-X-SERVER-CONTROL',
   'EXT-X-SKIP',
+  'EXT-X-PART-INF',
 ];
 
 

package/lib/media/drm_engine.js

@@ -133,6 +133,9 @@ shaka.media.DrmEngine = class {
 
     /** @private {Promise} */
     this.mediaKeysAttached_ = null;
+
+    /** @private {?shaka.extern.InitDataOverride} */
+    this.manifestInitData_ = null;
   }
 
   /** @override */
@@ -480,10 +483,10 @@ shaka.media.DrmEngine = class {
           () => this.closeOpenSessions_());
     }
 
-    const manifestInitData = this.currentDrmInfo_ ?
-      this.currentDrmInfo_.initData.find(
+    this.manifestInitData_ = this.currentDrmInfo_ ?
+      (this.currentDrmInfo_.initData.find(
           (initDataOverride) => initDataOverride.initData.length > 0,
-      ) : null;
+      ) || null) : null;
 
     /**
      * We can attach media keys before the playback actually begins when:
@@ -491,7 +494,7 @@ shaka.media.DrmEngine = class {
      *  - Some initData already has been generated (through the manifest)
      *  - In case of an offline session
      */
-    if (manifestInitData ||
+    if (this.manifestInitData_ ||
         this.currentDrmInfo_.keySystem !== 'com.apple.fps' ||
         this.offlineSessionIds_.length) {
       await this.attachMediaKeys_();
@@ -504,7 +507,7 @@ shaka.media.DrmEngine = class {
     // Also suppress 'encrypted' events when parsing in-band ppsh
     // from media segments because that serves the same purpose as the
     // 'encrypted' events.
-    if (!manifestInitData && !this.offlineSessionIds_.length &&
+    if (!this.manifestInitData_ && !this.offlineSessionIds_.length &&
         !this.config_.parseInbandPsshEnabled) {
       this.eventManager_.listen(
           this.video_, 'encrypted', (e) => this.onEncryptedEvent_(e));
@@ -2361,7 +2364,7 @@ shaka.media.DrmEngine = class {
    * @return {!Promise<void>}
    */
   parseInbandPssh(contentType, mediaSegment) {
-    if (!this.config_.parseInbandPsshEnabled) {
+    if (!this.config_.parseInbandPsshEnabled || this.manifestInitData_) {
       return Promise.resolve();
     }
 

package/lib/media/media_source_engine.js

@@ -109,15 +109,15 @@ shaka.media.MediaSourceEngine = class {
     /** @private {!shaka.util.PublicPromise} */
     this.mediaSourceOpen_ = new shaka.util.PublicPromise();
 
+    /** @private {string} */
+    this.url_ = '';
+
     /** @private {MediaSource} */
     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
 
     /** @type {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
 
-    /** @private {string} */
-    this.url_ = '';
-
     /** @private {boolean} */
     this.sequenceMode_ = false;
 
@@ -154,6 +154,8 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   onSourceOpen_(p) {
+    goog.asserts.assert(this.url_, 'Must have object URL');
+
     // Release the object URL that was previously created, to prevent memory
     // leak.
     // createObjectURL creates a strong reference to the MediaSource object
@@ -202,6 +204,9 @@ shaka.media.MediaSourceEngine = class {
       'audio/mp4; codecs="ec-3"',
       'audio/mp4; codecs="opus"',
       'audio/mp4; codecs="flac"',
+      'audio/mp4; codecs="dtsc"', // DTS Digital Surround
+      'audio/mp4; codecs="dtse"', // DTS Express
+      'audio/mp4; codecs="dtsx"', // DTS:X
       // WebM types
       'video/webm; codecs="vp8"',
       'video/webm; codecs="vp9"',
@@ -375,7 +380,22 @@ shaka.media.MediaSourceEngine = class {
               shaka.media.Transmuxer.convertCodecs(contentType, mimeType);
         }
         const type = mimeType + this.config_.sourceBufferExtraFeatures;
-        const sourceBuffer = this.mediaSource_.addSourceBuffer(type);
+
+        this.destroyer_.ensureNotDestroyed();
+
+        let sourceBuffer;
+
+        try {
+          sourceBuffer = this.mediaSource_.addSourceBuffer(type);
+        } catch (exception) {
+          throw new shaka.util.Error(
+              shaka.util.Error.Severity.CRITICAL,
+              shaka.util.Error.Category.MEDIA,
+              shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
+              exception,
+              'The mediaSource_ status was' + this.mediaSource_.readyState +
+              'expected \'open\'');
+        }
 
         this.eventManager_.listen(
             sourceBuffer, 'error',
@@ -628,7 +648,8 @@ shaka.media.MediaSourceEngine = class {
       // For HLS CEA-608/708 CLOSED-CAPTIONS, text data is embedded in
       // the video stream, so textEngine may not have been initialized.
       if (!this.textEngine_) {
-        this.reinitText('text/vtt', this.sequenceMode_);
+        this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
+            this.sequenceMode_);
       }
       // This doesn't work for native TS support (ex. Edge/Chromecast),
       // since no transmuxing is needed for native TS.
@@ -647,7 +668,8 @@ shaka.media.MediaSourceEngine = class {
       data = transmuxedData.data;
     } else if (hasClosedCaptions && contentType == ContentType.VIDEO) {
       if (!this.textEngine_) {
-        this.reinitText('text/vtt', this.sequenceMode_);
+        this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
+            this.sequenceMode_);
       }
       if (!this.captionParser_) {
         this.captionParser_ = this.getCaptionParser(mimeType);
@@ -771,7 +793,7 @@ shaka.media.MediaSourceEngine = class {
       this.append_(contentType, data);
     });
 
-    if (goog.DEBUG && reference) {
+    if (goog.DEBUG && reference && !reference.isPreload()) {
       const bufferedAfter = this.getBuffered_(contentType);
       const newBuffered = shaka.media.TimeRangesUtils.computeAddedRange(
           bufferedBefore, bufferedAfter);
@@ -937,7 +959,6 @@ shaka.media.MediaSourceEngine = class {
 
   /**
    * Adjust timestamp offset to maintain AV sync across discontinuities.
-   * Only used in sequence mode.
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {number} timestampOffset
@@ -946,9 +967,6 @@ shaka.media.MediaSourceEngine = class {
   async resync(contentType, timestampOffset) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
-    goog.asserts.assert(this.sequenceMode_,
-        'resync only used with sequence mode!');
-
     if (contentType == ContentType.TEXT) {
       // This operation is for audio and video only.
       return;
@@ -978,8 +996,10 @@ shaka.media.MediaSourceEngine = class {
   async endOfStream(reason) {
     await this.enqueueBlockingOperation_(() => {
       // If endOfStream() has already been called on the media source,
-      // don't call it again.
-      if (this.ended()) {
+      // don't call it again. Also do not call if readyState is
+      // 'closed' (not attached to video element) since it is not a
+      // valid operation.
+      if (this.ended() || this.mediaSource_.readyState === 'closed') {
         return;
       }
       // Tizen won't let us pass undefined, but it will let us omit the

package/lib/media/presentation_timeline.js

@@ -236,7 +236,16 @@ shaka.media.PresentationTimeline = class {
 
     let firstReferenceStartTime = references[0].startTime;
     let lastReferenceEndTime = references[0].endTime;
+
+    // Date.now() is in milliseconds, from which we compute "now" in seconds.
+    const now = (Date.now() + this.clockOffset_) / 1000.0;
+
     for (const reference of references) {
+      // Exclude segments that are in the "future".
+      if (now < reference.startTime) {
+        continue;
+      }
+
       firstReferenceStartTime = Math.min(
           firstReferenceStartTime, reference.startTime);
       lastReferenceEndTime = Math.max(lastReferenceEndTime, reference.endTime);
@@ -251,8 +260,6 @@ shaka.media.PresentationTimeline = class {
         !this.startTimeLocked_) {
       // Since we have explicit segment end times, calculate a presentation
       // start based on them.  This start time accounts for drift.
-      // Date.now() is in milliseconds, from which we compute "now" in seconds.
-      const now = (Date.now() + this.clockOffset_) / 1000.0;
       this.presentationStartTime_ =
           now - this.maxSegmentEndTime_ - this.maxSegmentDuration_;
     }

package/lib/media/segment_index.js

@@ -363,6 +363,8 @@ shaka.media.SegmentIndex = class {
             lastReference.status,
             lastReference.hlsAes128Key,
         );
+    this.references[this.references.length - 1].discontinuitySequence =
+        lastReference.discontinuitySequence;
   }
 
 

package/lib/media/segment_reference.js

@@ -144,8 +144,9 @@ shaka.media.SegmentReference = class {
    *   minus the first segment's tfdt box's 'baseMediaDecodeTime' field (after
    *   it has been converted to seconds).
    *   <br>
-   *   For HLS, this value should be 0 to keep the presentation time at the most
-   *   recent discontinuity minus the corresponding media time.
+   *   For HLS, this value should be the start time of the most recent
+   *   discontinuity, or 0 if there is no preceding discontinuity. Only used
+   *   in segments mode.
    * @param {number} appendWindowStart
    *   The start of the append window for this reference, relative to the
    *   presentation.  Any content from before this time will be removed by
@@ -242,6 +243,9 @@ shaka.media.SegmentReference = class {
     /** @type {shaka.media.SegmentReference.Status} */
     this.status = status;
 
+    /** @type {boolean} */
+    this.preload = false;
+
     /** @type {?shaka.extern.HlsAes128Key} */
     this.hlsAes128Key = hlsAes128Key;
 
@@ -365,6 +369,25 @@ shaka.media.SegmentReference = class {
     this.status = shaka.media.SegmentReference.Status.UNAVAILABLE;
   }
 
+  /**
+   * Mark the reference as preload.
+   *
+   * @export
+   */
+  markAsPreload() {
+    this.preload = true;
+  }
+
+  /**
+   * Returns true if the segment is preloaded.
+   *
+   * @return {boolean}
+   * @export
+   */
+  isPreload() {
+    return this.preload;
+  }
+
   /**
    * Set the segment's thumbnail sprite.
    *

package/lib/media/streaming_engine.js

@@ -78,6 +78,9 @@ shaka.media.StreamingEngine = class {
     /** @private {?shaka.extern.Stream} */
     this.currentTextStream_ = null;
 
+    /** @private {number} */
+    this.textStreamSequenceId_ = 0;
+
     /** @private {boolean} */
     this.parsedPrftEventRaised_ = false;
 
@@ -224,6 +227,8 @@ shaka.media.StreamingEngine = class {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     goog.asserts.assert(!this.mediaStates_.has(ContentType.TEXT),
         'Should not call loadNewTextStream_ while streaming text!');
+    this.textStreamSequenceId_++;
+    const currentSequenceId = this.textStreamSequenceId_;
 
     try {
       // Clear MediaSource's buffered text, so that the new text stream will
@@ -246,7 +251,7 @@ shaka.media.StreamingEngine = class {
     const streamText =
         textDisplayer.isTextVisible() || this.config_.alwaysStreamText;
 
-    if (streamText) {
+    if (streamText && (this.textStreamSequenceId_ == currentSequenceId)) {
       const state = this.createMediaState_(stream);
       this.mediaStates_.set(ContentType.TEXT, state);
       this.scheduleUpdate_(state, 0);
@@ -357,7 +362,7 @@ shaka.media.StreamingEngine = class {
   /**
    * @param {shaka.extern.Stream} textStream
    */
-  switchTextStream(textStream) {
+  async switchTextStream(textStream) {
     this.currentTextStream_ = textStream;
 
     if (!this.startupComplete_) {
@@ -369,6 +374,13 @@ shaka.media.StreamingEngine = class {
     goog.asserts.assert(textStream && textStream.type == ContentType.TEXT,
         'Wrong stream type passed to switchTextStream!');
 
+    // In HLS it is possible that the mimetype changes when the media
+    // playlist is downloaded, so it is necessary to have the updated data
+    // here.
+    if (!textStream.segmentIndex) {
+      await textStream.createSegmentIndex();
+    }
+
     this.switchInternal_(
         textStream, /* clearBuffer= */ true,
         /* safeMargin= */ 0, /* force= */ false);
@@ -639,10 +651,15 @@ shaka.media.StreamingEngine = class {
       const mediaState = this.mediaStates_.get(type);
       const logPrefix = shaka.media.StreamingEngine.logPrefix_(mediaState);
 
-      // Always clear the iterator since we need to start streaming from the
-      // new time.  This also happens in clearBuffer_, but if we don't clear,
-      // we still want to reset the iterator.
-      mediaState.segmentIterator = null;
+      let segment = null;
+      if (mediaState.segmentIterator) {
+        segment = mediaState.segmentIterator.current();
+      }
+      // Only reset the iterator if we seek outside the current segment.
+      if (!segment || segment.startTime > presentationTime ||
+          segment.endTime < presentationTime) {
+        mediaState.segmentIterator = null;
+      }
 
       if (!newTimeIsBuffered(type)) {
         const bufferEnd =
@@ -1564,10 +1581,10 @@ shaka.media.StreamingEngine = class {
           'waiting for another stream to recover...');
     }
 
-    // QuotaExceededError gets thrown if evication didn't help to make room
+    // QuotaExceededError gets thrown if eviction didn't help to make room
     // for a segment. We want to wait for a while (4 seconds is just an
     // arbitrary number) before updating to give the playhead a chance to
-    // advance, so we don't immidiately throw again.
+    // advance, so we don't immediately throw again.
     this.scheduleUpdate_(mediaState, 4);
   }
 
@@ -1675,19 +1692,31 @@ shaka.media.StreamingEngine = class {
       }
     }
 
+    const lastDiscontinuitySequence =
+        mediaState.lastSegmentReference ?
+            mediaState.lastSegmentReference.discontinuitySequence : null;
     if (this.manifest_.sequenceMode) {
       // Across discontinuity bounds, we should resync timestamps for
       // sequence mode playbacks.  The next segment appended should
       // land at its theoretical timestamp from the segment index.
-      const lastDiscontinuitySequence =
-          mediaState.lastSegmentReference ?
-              mediaState.lastSegmentReference.discontinuitySequence : null;
       if (reference.discontinuitySequence != lastDiscontinuitySequence ||
           mediaState.needsResync) {
         mediaState.needsResync = false;
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
+    } else {
+      // In segments mode, we need to resync to set the timestampOffset
+      // to the start of the current discontinuity sequence. This is
+      // because individual discontinuity sequences may have internal
+      // timestamps that overlap, so we adjust the timestampOffset to avoid
+      // having the SourceBuffer get overwritten.
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
+        operations.push(
+            this.playerInterface_.mediaSourceEngine.resync(
+                mediaState.type,
+                reference.timestampOffset));
+      }
     }
 
     await Promise.all(operations);