shaka-player 4.7.11 → 4.7.13

package/lib/hls/hls_parser.js

@@ -552,7 +552,7 @@ shaka.hls.HlsParser = class {
         if (goog.DEBUG) {
           const firstSequenceStartTime =
               mediaSequenceToStartTime.values().next().value;
-          goog.asserts.assert(
+          shaka.log.warning(
               firstSequenceStartTime == segment0.startTime,
               'Sequence number map is not ordered as expected!');
         }
@@ -586,16 +586,18 @@ shaka.hls.HlsParser = class {
         // Drop any earlier references.
         const numSegmentsToDrop =
             this.minSequenceNumber_ - streamInfo.firstSequenceNumber;
-        segmentIndex.dropFirstReferences(numSegmentsToDrop);
-
-        // Now adjust timestamps back to begin at 0.
-        const segmentN = segmentIndex.earliestReference();
-        if (segmentN) {
-          const streamOffset = -segmentN.startTime;
-          // Modify all SegmentReferences equally.
-          streamInfo.stream.segmentIndex.offset(streamOffset);
-          // Update other parts of streamInfo the same way.
-          this.offsetStreamInfo_(streamInfo, streamOffset);
+        if (numSegmentsToDrop > 0) {
+          segmentIndex.dropFirstReferences(numSegmentsToDrop);
+
+          // Now adjust timestamps back to begin at 0.
+          const segmentN = segmentIndex.earliestReference();
+          if (segmentN) {
+            const streamOffset = -segmentN.startTime;
+            // Modify all SegmentReferences equally.
+            streamInfo.stream.segmentIndex.offset(streamOffset);
+            // Update other parts of streamInfo the same way.
+            this.offsetStreamInfo_(streamInfo, streamOffset);
+          }
         }
       }
     }
@@ -986,17 +988,17 @@ shaka.hls.HlsParser = class {
       }
 
       if (!this.presentationTimeline_.isStartTimeLocked()) {
-        const streamInfos = Array.from(this.uriToStreamInfosMap_.values());
-        const activeStreamInfos =
-            streamInfos.filter((s) => s.stream.segmentIndex);
-        for (const streamInfo of activeStreamInfos) {
+        for (const streamInfo of this.uriToStreamInfosMap_.values()) {
+          if (!streamInfo.stream.segmentIndex) {
+            continue; // Not active.
+          }
           if (streamInfo.type != 'audio' && streamInfo.type != 'video') {
             continue;
           }
           const firstReference = streamInfo.stream.segmentIndex.get(0);
           if (firstReference && firstReference.syncTime) {
             const syncTime = firstReference.syncTime;
-            this.presentationTimeline_.setPresentationStartTime(syncTime);
+            this.presentationTimeline_.setInitialProgramDateTime(syncTime);
           }
         }
       }
@@ -1222,6 +1224,7 @@ shaka.hls.HlsParser = class {
             textStreamInfo.stream.mimeType =
                 this.guessMimeTypeBeforeLoading_(type, codecs) ||
                 this.guessMimeTypeFallback_(type);
+            this.setFullTypeForStream_(textStreamInfo.stream);
           }
         }
       }
@@ -1231,6 +1234,15 @@ shaka.hls.HlsParser = class {
     return textStreams.filter((s) => s);
   }
 
+  /**
+   * @param {!shaka.extern.Stream} stream
+   * @private
+   */
+  setFullTypeForStream_(stream) {
+    stream.fullMimeTypes = new Set([shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs)]);
+  }
+
   /**
    * @param {!Array.<!shaka.hls.Tag>} imageTags from the playlist.
    * @param {!Array.<!shaka.hls.Tag>} iFrameTags from the playlist.
@@ -2264,6 +2276,7 @@ shaka.hls.HlsParser = class {
       stream.mimeType = realStream.mimeType;
       stream.bandwidth = stream.bandwidth || realStream.bandwidth;
       stream.codecs = stream.codecs || realStream.codecs;
+      this.setFullTypeForStream_(stream);
 
       // Since we lazy-loaded this content, the player may need to create new
       // sessions for the DRM info in this stream.
@@ -2278,6 +2291,7 @@ shaka.hls.HlsParser = class {
             // To aid manifest filtering, assume before loading that all video
             // renditions have the same MIME type.  (And likewise for audio.)
             otherStreamInfo.stream.mimeType = realStream.mimeType;
+            this.setFullTypeForStream_(otherStreamInfo.stream);
           }
         }
       }
@@ -2286,6 +2300,7 @@ shaka.hls.HlsParser = class {
         const firstSegment = realStream.segmentIndex.get(0);
         if (firstSegment && firstSegment.initSegmentReference) {
           stream.mimeType = 'application/mp4';
+          this.setFullTypeForStream_(stream);
         }
       }
 
@@ -2535,6 +2550,7 @@ shaka.hls.HlsParser = class {
     stream.drmInfos = drmInfos;
     stream.keyIds = keyIds;
     stream.mimeType = mimeType;
+    this.setFullTypeForStream_(stream);
 
     const mediaSequenceToStartTime = this.isLive_() ?
         this.mediaSequenceToStartTimeByType_.get(type) : new Map();
@@ -2690,7 +2706,7 @@ shaka.hls.HlsParser = class {
       roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
     }
 
-    return {
+    const stream = {
       id: this.globalId_++,
       originalId: name,
       groupId: null,
@@ -2728,7 +2744,10 @@ shaka.hls.HlsParser = class {
       accessibilityPurpose: accessibilityPurpose,
       external: false,
       fastSwitching: false,
+      fullMimeTypes: new Set(),
     };
+    this.setFullTypeForStream_(stream);
+    return stream;
   }
 
   /**

package/lib/media/drm_engine.js

@@ -697,9 +697,12 @@ shaka.media.DrmEngine = class {
           initDataOverride.initDataType, initDataOverride.initData);
     }
 
-    // If we have no sessions, we need to resolve the promise right now or else
-    // it will never get resolved.
-    if (!initDatas.length) {
+    // If there were no sessions to load, we need to resolve the promise right
+    // now or else it will never get resolved.
+    // We determine this by checking areAllSessionsLoaded_, rather than checking
+    // the number of initDatas, since the newInitData method can reject init
+    // datas in some circumstances.
+    if (this.areAllSessionsLoaded_()) {
       this.allSessionsLoaded_.resolve();
     }
 

package/lib/media/media_source_engine.js

@@ -31,6 +31,7 @@ goog.require('shaka.util.Mp4BoxParsers');
 goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PublicPromise');
+goog.require('shaka.util.StreamUtils');
 goog.require('shaka.util.TsParser');
 goog.require('shaka.lcevc.Dec');
 
@@ -151,6 +152,9 @@ shaka.media.MediaSourceEngine = class {
 
     /** @private {?number} */
     this.lastDuration_ = null;
+
+    /** @private {?shaka.util.TsParser} */
+    this.tsParser_ = null;
   }
 
   /**
@@ -234,18 +238,61 @@ shaka.media.MediaSourceEngine = class {
    * Checks if a certain type is supported.
    *
    * @param {shaka.extern.Stream} stream
-   * @return {boolean}
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @return {!Promise.<boolean>}
    */
-  static isStreamSupported(stream) {
+  static async isStreamSupported(stream, contentType) {
+    if (stream.createSegmentIndex) {
+      await stream.createSegmentIndex();
+    }
+    if (!stream.segmentIndex) {
+      return false;
+    }
+    if (stream.segmentIndex.isEmpty()) {
+      return true;
+    }
     const MimeUtils = shaka.util.MimeUtils;
-    const fullMimeType = MimeUtils.getFullType(stream.mimeType, stream.codecs);
-    const extendedMimeType = MimeUtils.getExtendedType(stream);
-    const fullMimeTypeWithAllCodecs = MimeUtils.getFullTypeWithAllCodecs(
-        stream.mimeType, stream.codecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
-    return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
-        shaka.media.Capabilities.isTypeSupported(extendedMimeType) ||
-        TransmuxerEngine.isSupported(fullMimeTypeWithAllCodecs, stream.type);
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const StreamUtils = shaka.util.StreamUtils;
+    const seenCombos = new Set();
+    // Check each combination of mimeType and codecs within the segment index.
+    // Unfortunately we cannot use fullMimeTypes, as we ALSO need to check the
+    // getFullTypeWithAllCodecs (for the sake of the transmuxer) and we have no
+    // way of going from a full mimeType to a full mimeType with all codecs.
+    // As this function is only called in debug mode, a little inefficiency is
+    // acceptable.
+    for (const ref of stream.segmentIndex) {
+      const mimeType = ref.mimeType || stream.mimeType || '';
+      let codecs = ref.codecs || stream.codecs || '';
+      // Don't check the same combination of mimetype + codecs twice.
+      const combo = mimeType + ':' + codecs;
+      if (seenCombos.has(combo)) {
+        continue;
+      }
+      seenCombos.add(combo);
+      if (contentType == ContentType.TEXT) {
+        const fullMimeType = MimeUtils.getFullType(mimeType, codecs);
+        if (!shaka.text.TextEngine.isTypeSupported(fullMimeType)) {
+          return false;
+        }
+      } else {
+        if (contentType == ContentType.VIDEO) {
+          codecs = StreamUtils.getCorrectVideoCodecs(codecs);
+        } else if (contentType == ContentType.AUDIO) {
+          codecs = StreamUtils.getCorrectAudioCodecs(codecs);
+        }
+        const extendedMimeType = MimeUtils.getExtendedType(
+            stream, mimeType, codecs);
+        const fullMimeType = MimeUtils.getFullTypeWithAllCodecs(
+            mimeType, codecs);
+        if (!shaka.media.Capabilities.isTypeSupported(extendedMimeType) &&
+            !TransmuxerEngine.isSupported(fullMimeType, stream.type)) {
+          return false;
+        }
+      }
+    }
+    return true;
   }
 
   /**
@@ -392,6 +439,8 @@ shaka.media.MediaSourceEngine = class {
 
     // This object is owned by Player
     this.lcevcDec_ = null;
+
+    this.tsParser_ = null;
   }
 
   /**
@@ -442,9 +491,12 @@ shaka.media.MediaSourceEngine = class {
         this.manifestType_ == shaka.media.ManifestParser.HLS &&
         !this.ignoreManifestTimestampsInSegmentsMode_;
 
+    this.tsParser_ = null;
+
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
-      this.initSourceBuffer_(contentType, stream, stream.codecs);
+      // eslint-disable-next-line no-await-in-loop
+      await this.initSourceBuffer_(contentType, stream, stream.codecs);
       if (this.needSplitMuxedContent_) {
         this.queues_[ContentType.AUDIO] = [];
         this.queues_[ContentType.VIDEO] = [];
@@ -460,14 +512,15 @@ shaka.media.MediaSourceEngine = class {
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
    * @param {string} codecs
-   * @param {boolean=} forceTransmux
+   * @return {!Promise}
    * @private
    */
-  initSourceBuffer_(contentType, stream, codecs, forceTransmux = false) {
+  async initSourceBuffer_(contentType, stream, codecs) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
     goog.asserts.assert(
-        shaka.media.MediaSourceEngine.isStreamSupported(stream),
+        await shaka.media.MediaSourceEngine.isStreamSupported(
+            stream, contentType),
         'Type negotiation should happen before MediaSourceEngine.init!');
 
     let mimeType = shaka.util.MimeUtils.getFullType(
@@ -475,7 +528,7 @@ shaka.media.MediaSourceEngine = class {
     if (contentType == ContentType.TEXT) {
       this.reinitText(mimeType, this.sequenceMode_, stream.external);
     } else {
-      let needTransmux = this.config_.forceTransmux || forceTransmux;
+      let needTransmux = this.config_.forceTransmux;
       if (!shaka.media.Capabilities.isTypeSupported(mimeType) ||
           (!this.sequenceMode_ &&
           shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType))) {
@@ -484,7 +537,6 @@ shaka.media.MediaSourceEngine = class {
       const mimeTypeWithAllCodecs =
           shaka.util.MimeUtils.getFullTypeWithAllCodecs(
               stream.mimeType, codecs);
-      const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
       if (needTransmux) {
         const audioCodec = shaka.util.ManifestParserUtils.guessCodecsSafe(
             ContentType.AUDIO, (codecs || '').split(','));
@@ -492,14 +544,12 @@ shaka.media.MediaSourceEngine = class {
             ContentType.VIDEO, (codecs || '').split(','));
         if (audioCodec && videoCodec) {
           this.needSplitMuxedContent_ = true;
-          this.initSourceBuffer_(
-              ContentType.AUDIO, stream, audioCodec, /* forceTransmux= */ true);
-          this.initSourceBuffer_(
-              ContentType.VIDEO, stream, videoCodec, /* forceTransmux= */ true);
+          await this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
+          await this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
           return;
         }
-        const transmuxerPlugin =
-            TransmuxerEngine.findTransmuxer(mimeTypeWithAllCodecs);
+        const transmuxerPlugin = shaka.transmuxer.TransmuxerEngine
+            .findTransmuxer(mimeTypeWithAllCodecs);
         if (transmuxerPlugin) {
           const transmuxer = transmuxerPlugin();
           this.transmuxers_[contentType] = transmuxer;
@@ -789,7 +839,12 @@ shaka.media.MediaSourceEngine = class {
       }
     } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
         shaka.util.TsParser.probe(uint8ArrayData)) {
-      const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
+      if (!this.tsParser_) {
+        this.tsParser_ = new shaka.util.TsParser();
+      } else {
+        this.tsParser_.clearData();
+      }
+      const tsParser = this.tsParser_.parse(uint8ArrayData);
       const startTime = tsParser.getStartTime(contentType);
       if (startTime != null) {
         timestamp = startTime;
@@ -1177,6 +1232,12 @@ shaka.media.MediaSourceEngine = class {
       return;
     }
 
+    // Reset the promise in case the timestamp offset changed during
+    // a period/discontinuity transition.
+    if (contentType == ContentType.VIDEO) {
+      this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
+    }
+
     // Queue an abort() to help MSE splice together overlapping segments.
     // We set appendWindowEnd when we change periods in DASH content, and the
     // period transition may result in overlap.
@@ -1787,7 +1848,8 @@ shaka.media.MediaSourceEngine = class {
 
       for (const contentType of streamsByType.keys()) {
         const stream = streamsByType.get(contentType);
-        this.initSourceBuffer_(contentType, stream, stream.codecs);
+        // eslint-disable-next-line no-await-in-loop
+        await this.initSourceBuffer_(contentType, stream, stream.codecs);
         if (this.needSplitMuxedContent_) {
           this.queues_[ContentType.AUDIO] = [];
           this.queues_[ContentType.VIDEO] = [];
@@ -1857,8 +1919,7 @@ shaka.media.MediaSourceEngine = class {
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
-        shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType)) ||
-        codecs.includes(',')) {
+        shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
       needTransmux = true;
     }
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
@@ -1921,10 +1982,12 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} refMimeType
+   * @param {string} refCodecs
    * @return {boolean}
    * @private
    */
-  isCodecSwitchNecessary_(contentType, stream) {
+  isCodecSwitchNecessary_(contentType, stream, refMimeType, refCodecs) {
     if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
       return false;
     }
@@ -1934,18 +1997,16 @@ shaka.media.MediaSourceEngine = class {
     const currentBasicType = MimeUtils.getBasicType(
         this.sourceBufferTypes_[contentType]);
 
-    let newMimeType = shaka.util.MimeUtils.getFullType(
-        stream.mimeType, stream.codecs);
+    let newMimeType = shaka.util.MimeUtils.getFullType(refMimeType, refCodecs);
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
-        shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType)) ||
-        stream.codecs.includes(',')) {
+        shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
       needTransmux = true;
     }
     const newMimeTypeWithAllCodecs =
         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            stream.mimeType, stream.codecs);
+            refMimeType, refCodecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
       const transmuxerPlugin =
@@ -1971,10 +2032,12 @@ shaka.media.MediaSourceEngine = class {
    *
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, stream) {
-    if (!this.isCodecSwitchNecessary_(contentType, stream)) {
+  isResetMediaSourceNecessary(contentType, stream, mimeType, codecs) {
+    if (!this.isCodecSwitchNecessary_(contentType, stream, mimeType, codecs)) {
       return false;
     }
 

package/lib/media/playhead.js

@@ -382,10 +382,10 @@ shaka.media.MediaSourcePlayhead = class {
       seekStart = seekEnd - this.minSeekRange_;
     }
 
-    if (currentTime < seekStart) {
-      // The seek range has moved past the playhead.  Move ahead to catch up.
+    if (currentTime < seekStart || currentTime > seekEnd) {
+      // playhead is outside of the seekrange.  Move playhead to catch up.
       const targetTime = this.reposition_(currentTime);
-      shaka.log.info('Jumping forward ' + (targetTime - currentTime) +
+      shaka.log.info('Jumping by ' + (targetTime - currentTime) +
                      ' seconds to catch up with the seek range.');
       this.mediaElement_.currentTime = targetTime;
     }

package/lib/media/presentation_timeline.js

@@ -96,6 +96,9 @@ shaka.media.PresentationTimeline = class {
 
     /** @private {boolean} */
     this.startTimeLocked_ = false;
+
+    /** @private {?number} */
+    this.initialProgramDateTime_ = null;
   }
 
 
@@ -339,6 +342,26 @@ shaka.media.PresentationTimeline = class {
   }
 
 
+  /**
+   * Sets the initial program date time.
+   *
+   * @param {number} initialProgramDateTime
+   * @export
+   */
+  setInitialProgramDateTime(initialProgramDateTime) {
+    this.initialProgramDateTime_ = initialProgramDateTime;
+  }
+
+
+  /**
+   * @return {?number} The initial program date time in seconds.
+   * @export
+   */
+  getInitialProgramDateTime() {
+    return this.initialProgramDateTime_;
+  }
+
+
   /**
    * Gives PresentationTimeline a Stream's minimum segment start time.
    *

package/lib/media/segment_index.js

@@ -363,26 +363,27 @@ shaka.media.SegmentIndex = class {
 
     // Adjust the last SegmentReference.
     const lastReference = this.references[this.references.length - 1];
-    this.references[this.references.length - 1] =
-        new shaka.media.SegmentReference(
-            lastReference.startTime,
-            /* endTime= */ windowEnd,
-            lastReference.getUrisInner,
-            lastReference.startByte,
-            lastReference.endByte,
-            lastReference.initSegmentReference,
-            lastReference.timestampOffset,
-            lastReference.appendWindowStart,
-            lastReference.appendWindowEnd,
-            lastReference.partialReferences,
-            lastReference.tilesLayout,
-            lastReference.tileDuration,
-            lastReference.syncTime,
-            lastReference.status,
-            lastReference.aes128Key,
-        );
-    this.references[this.references.length - 1].discontinuitySequence =
-        lastReference.discontinuitySequence;
+    const newReference = new shaka.media.SegmentReference(
+        lastReference.startTime,
+        /* endTime= */ windowEnd,
+        lastReference.getUrisInner,
+        lastReference.startByte,
+        lastReference.endByte,
+        lastReference.initSegmentReference,
+        lastReference.timestampOffset,
+        lastReference.appendWindowStart,
+        lastReference.appendWindowEnd,
+        lastReference.partialReferences,
+        lastReference.tilesLayout,
+        lastReference.tileDuration,
+        lastReference.syncTime,
+        lastReference.status,
+        lastReference.aes128Key,
+    );
+    newReference.mimeType = lastReference.mimeType;
+    newReference.codecs = lastReference.codecs;
+    newReference.discontinuitySequence = lastReference.discontinuitySequence;
+    this.references[this.references.length - 1] = newReference;
   }
 
 

package/lib/media/segment_utils.js

@@ -55,6 +55,7 @@ shaka.media.SegmentUtils = class {
     let hasVideo = false;
     switch (tsCodecs.audio) {
       case 'aac':
+      case 'aac-loas':
         codecs.push('mp4a.40.2');
         hasAudio = true;
         break;
@@ -70,6 +71,10 @@ shaka.media.SegmentUtils = class {
         codecs.push('ec-3');
         hasAudio = true;
         break;
+      case 'opus':
+        codecs.push('opus');
+        hasAudio = true;
+        break;
     }
     switch (tsCodecs.video) {
       case 'avc':
@@ -88,6 +93,10 @@ shaka.media.SegmentUtils = class {
         }
         hasVideo = true;
         break;
+      case 'av1':
+        codecs.push('av01.0.01M.08');
+        hasVideo = true;
+        break;
     }
     if (!codecs.length) {
       return null;
@@ -256,7 +265,7 @@ shaka.media.SegmentUtils = class {
         // This signals an encrypted sample, which we can go inside of to
         // find the codec used.
         // Note: If encrypted, you can only have audio or video, not both.
-        .box('enca', Mp4Parser.visualSampleEntry)
+        .box('enca', Mp4Parser.audioSampleEntry)
         .box('encv', Mp4Parser.visualSampleEntry)
         .box('sinf', Mp4Parser.children)
         .box('frma', (box) => {

package/lib/media/streaming_engine.js

@@ -881,7 +881,6 @@ shaka.media.StreamingEngine = class {
       // The playhead might be seeking on startup, if a start time is set, so
       // start "seeked" as true.
       seeked: true,
-      needsResync: false,
       recovering: false,
       hasError: false,
       operation: null,
@@ -1248,11 +1247,6 @@ shaka.media.StreamingEngine = class {
       shaka.log.v1(
           logPrefix, 'looking up segment from new stream endTime:', time);
 
-      // Using a new iterator means we need to resync the stream in sequence
-      // mode.  The buffered range might not align perfectly with the last
-      // segment end time, so we may end up repeating a segment.  Resyncing
-      // makes this safe to do.
-      mediaState.needsResync = true;
       mediaState.segmentIterator =
           mediaState.stream.segmentIndex.getIteratorForTime(time);
       const ref = mediaState.segmentIterator &&
@@ -1730,7 +1724,7 @@ shaka.media.StreamingEngine = class {
       const isResetMediaSourceNecessary =
           mediaState.lastCodecs && mediaState.lastMimeType &&
           this.playerInterface_.mediaSourceEngine.isResetMediaSourceNecessary(
-              mediaState.type, mediaState.stream);
+              mediaState.type, mediaState.stream, mimeType, codecs);
       if (isResetMediaSourceNecessary) {
         let otherState = null;
         if (mediaState.type === ContentType.VIDEO) {
@@ -1879,9 +1873,7 @@ shaka.media.StreamingEngine = class {
       // 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.
-      if (reference.discontinuitySequence != lastDiscontinuitySequence ||
-          mediaState.needsResync) {
-        mediaState.needsResync = false;
+      if (reference.discontinuitySequence != lastDiscontinuitySequence) {
         operations.push(this.playerInterface_.mediaSourceEngine.resync(
             mediaState.type, reference.startTime));
       }
@@ -2591,7 +2583,6 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   clearBufferSafeMargin: number,
  *   clearingBuffer: boolean,
  *   seeked: boolean,
- *   needsResync: boolean,
  *   adaptation: boolean,
  *   recovering: boolean,
  *   hasError: boolean,
@@ -2646,9 +2637,6 @@ shaka.media.StreamingEngine.PlayerInterface;
  *   True indicates that the presentation just seeked.
  * @property {boolean} adaptation
  *   True indicates that the presentation just automatically switched variants.
- * @property {boolean} needsResync
- *   True indicates that the stream needs to be resynced in sequence mode,
- *   regardless of discontinuity sequence.
  * @property {boolean} recovering
  *   True indicates that the last segment was not appended because it could not
  *   fit in the buffer.

package/lib/mss/mss_parser.js

@@ -19,6 +19,7 @@ goog.require('shaka.net.NetworkingEngine');
 goog.require('shaka.util.Error');
 goog.require('shaka.util.LanguageUtils');
 goog.require('shaka.util.ManifestParserUtils');
+goog.require('shaka.util.MimeUtils');
 goog.require('shaka.util.Mp4Generator');
 goog.require('shaka.util.OperationManager');
 goog.require('shaka.util.Timer');
@@ -556,6 +557,7 @@ shaka.mss.MssParser = class {
       accessibilityPurpose: null,
       external: false,
       fastSwitching: false,
+      fullMimeTypes: new Set(),
     };
 
     // This is specifically for text tracks.
@@ -634,6 +636,8 @@ shaka.mss.MssParser = class {
         }
         break;
     }
+    stream.fullMimeTypes.add(shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs));
 
     // Lazy-Load the segment index to avoid create all init segment at the
     // same time

package/lib/offline/indexeddb/v1_storage_cell.js

@@ -211,6 +211,8 @@ shaka.offline.indexeddb.V1StorageCell = class
       appendWindowEnd,
       timestampOffset,
       tilesLayout: '',
+      mimeType: null,
+      codecs: null,
     };
   }
 

package/lib/offline/indexeddb/v2_storage_cell.js

@@ -155,6 +155,8 @@ shaka.offline.indexeddb.V2StorageCell = class
       timestampOffset,
       dataKey: old.dataKey,
       tilesLayout: '',
+      mimeType: null,
+      codecs: null,
     };
   }
 };