shaka-player 4.7.12 → 4.7.13

package/externs/shaka/manifest.js

@@ -400,7 +400,8 @@ shaka.extern.FetchCryptoKeysFunction;
  *      undefined),
  *   mssPrivateData: (shaka.extern.MssPrivateData|undefined),
  *   external: boolean,
- *   fastSwitching: boolean
+ *   fastSwitching: boolean,
+ *   fullMimeTypes: !Set.<string>
  * }}
  *
  * @description
@@ -430,10 +431,14 @@ shaka.extern.FetchCryptoKeysFunction;
  * @property {string} mimeType
  *   <i>Required.</i> <br>
  *   The Stream's MIME type, e.g., 'audio/mp4', 'video/webm', or 'text/vtt'.
+ *   In the case of a stream that adapts between different periods with
+ *   different MIME types, this represents only the first period.
  * @property {string} codecs
  *   <i>Defaults to '' (i.e., unknown / not needed).</i> <br>
  *   The Stream's codecs, e.g., 'avc1.4d4015' or 'vp9', which must be
  *   compatible with the Stream's MIME type. <br>
+ *   In the case of a stream that adapts between different periods with
+ *   different codecs, this represents only the first period.
  *   See {@link https://tools.ietf.org/html/rfc6381}
  * @property {(number|undefined)} frameRate
  *   <i>Video streams only.</i> <br>
@@ -535,6 +540,11 @@ shaka.extern.FetchCryptoKeysFunction;
  *   Eg: external text tracks.
  * @property {boolean} fastSwitching
  *   Indicate if the stream should be used for fast switching.
+ * @property {!Set.<string>} fullMimeTypes
+ *   A set of full MIME types (e.g. MIME types plus codecs information), that
+ *   represents the types used in each period of the original manifest.
+ *   Meant for being used by compatibility checking, such as with
+ *   MediaSource.isTypeSupported.
  *
  * @exportDoc
  */

package/externs/shaka/offline.js

@@ -230,7 +230,9 @@ shaka.extern.StreamDB;
  *   tilesLayout: ?string,
  *   pendingSegmentRefId: (string|undefined),
  *   pendingInitSegmentRefId: (string|undefined),
- *   dataKey: number
+ *   dataKey: number,
+ *   mimeType: ?string,
+ *   codecs: ?string
  * }}
  *
  * @property {?number} initSegmentKey
@@ -263,6 +265,10 @@ shaka.extern.StreamDB;
  *   downloaded.
  * @property {number} dataKey
  *   The key to the data in storage.
+ * @property {?string} mimeType
+ *   The mimeType of the segment.
+ * @property {?string} codecs
+ *   The codecs of the segment.
  */
 shaka.extern.SegmentDB;
 

package/lib/dash/dash_parser.js

@@ -1485,8 +1485,13 @@ shaka.dash.DashParser = class {
         const getBaseUris = context.representation.getBaseUris;
         streamInfo = {
           generateSegmentIndex: () => {
-            return Promise.resolve(shaka.media.SegmentIndex.forSingleSegment(
-                periodStart, duration, getBaseUris()));
+            const segmentIndex = shaka.media.SegmentIndex.forSingleSegment(
+                periodStart, duration, getBaseUris());
+            segmentIndex.forEachTopLevelReference((ref) => {
+              ref.mimeType = context.representation.mimeType;
+              ref.codecs = context.representation.codecs;
+            });
+            return Promise.resolve(segmentIndex);
           },
         };
       }
@@ -1585,7 +1590,7 @@ shaka.dash.DashParser = class {
         },
         segmentIndex: null,
         mimeType: context.representation.mimeType,
-        codecs: context.representation.codecs,
+        codecs,
         frameRate: context.representation.frameRate,
         pixelAspectRatio: context.representation.pixelAspectRatio,
         bandwidth: context.bandwidth,
@@ -1615,6 +1620,8 @@ shaka.dash.DashParser = class {
         accessibilityPurpose,
         external: false,
         fastSwitching: false,
+        fullMimeTypes: new Set([shaka.util.MimeUtils.getFullType(
+            context.representation.mimeType, context.representation.codecs)]),
       };
     }
 

package/lib/dash/segment_base.js

@@ -62,7 +62,7 @@ shaka.dash.SegmentBase = class {
 
     const getUris = () => resolvedUris;
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
-    return new shaka.media.InitSegmentReference(
+    const ref = new shaka.media.InitSegmentReference(
         getUris,
         startByte,
         endByte,
@@ -70,6 +70,9 @@ shaka.dash.SegmentBase = class {
         /* timescale= */ null,
         /* segmentData= */ null,
         aes128Key);
+    ref.codecs = context.representation.codecs;
+    ref.mimeType = context.representation.mimeType;
+    return ref;
   }
 
   /**
@@ -184,6 +187,10 @@ shaka.dash.SegmentBase = class {
           indexData, initData, uris, initSegmentReference, timestampOffset,
           appendWindowStart, appendWindowEnd);
     }
+    for (const ref of references) {
+      ref.codecs = context.representation.codecs;
+      ref.mimeType = context.representation.mimeType;
+    }
 
     presentationTimeline.notifySegments(references);
 

package/lib/dash/segment_list.js

@@ -60,7 +60,8 @@ shaka.dash.SegmentList = class {
     const references = SegmentList.createSegmentReferences_(
         context.periodInfo.start, context.periodInfo.duration,
         info.startNumber, context.representation.getBaseUris, info,
-        initSegmentReference, aes128Key);
+        initSegmentReference, aes128Key, context.representation.mimeType,
+        context.representation.codecs);
 
     const isNew = !segmentIndex;
     if (segmentIndex) {
@@ -199,12 +200,14 @@ shaka.dash.SegmentList = class {
    * @param {shaka.dash.SegmentList.SegmentListInfo} info
    * @param {shaka.media.InitSegmentReference} initSegmentReference
    * @param {shaka.extern.aes128Key|undefined} aes128Key
+   * @param {string} mimeType
+   * @param {string} codecs
    * @return {!Array.<!shaka.media.SegmentReference>}
    * @private
    */
   static createSegmentReferences_(
       periodStart, periodDuration, startNumber, getBaseUris, info,
-      initSegmentReference, aes128Key) {
+      initSegmentReference, aes128Key, mimeType, codecs) {
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
 
     let max = info.mediaSegments.length;
@@ -251,22 +254,25 @@ shaka.dash.SegmentList = class {
         }
         return uris;
       };
-      references.push(
-          new shaka.media.SegmentReference(
-              periodStart + startTime,
-              periodStart + endTime,
-              getUris,
-              segment.start,
-              segment.end,
-              initSegmentReference,
-              timestampOffset,
-              appendWindowStart, appendWindowEnd,
-              /* partialReferences= */ [],
-              /* tilesLayout= */ '',
-              /* tileDuration= */ null,
-              /* syncTime= */ null,
-              shaka.media.SegmentReference.Status.AVAILABLE,
-              aes128Key));
+
+      const ref = new shaka.media.SegmentReference(
+          periodStart + startTime,
+          periodStart + endTime,
+          getUris,
+          segment.start,
+          segment.end,
+          initSegmentReference,
+          timestampOffset,
+          appendWindowStart, appendWindowEnd,
+          /* partialReferences= */ [],
+          /* tilesLayout= */ '',
+          /* tileDuration= */ null,
+          /* syncTime= */ null,
+          shaka.media.SegmentReference.Status.AVAILABLE,
+          aes128Key);
+      ref.codecs = codecs;
+      ref.mimeType = mimeType;
+      references.push(ref);
       prevEndTime = endTime;
     }
 

package/lib/dash/segment_template.js

@@ -213,6 +213,8 @@ shaka.dash.SegmentTemplate = class {
       timeline: segmentInfo.timeline,
       mediaTemplate: media,
       indexTemplate: index,
+      mimeType: context.representation.mimeType,
+      codecs: context.representation.codecs,
     };
   }
 
@@ -463,6 +465,8 @@ shaka.dash.SegmentTemplate = class {
           /* syncTime= */ null,
           shaka.media.SegmentReference.Status.AVAILABLE,
           aes128Key);
+      ref.codecs = context.representation.codecs;
+      ref.mimeType = context.representation.mimeType;
       // This is necessary information for thumbnail streams:
       ref.trueEndTime = trueSegmentEnd;
       return ref;
@@ -552,7 +556,7 @@ shaka.dash.SegmentTemplate = class {
       return resolvedUris;
     };
     const qualityInfo = shaka.dash.SegmentBase.createQualityInfo(context);
-    return new shaka.media.InitSegmentReference(
+    const ref = new shaka.media.InitSegmentReference(
         getUris,
         /* startByte= */ 0,
         /* endByte= */ null,
@@ -560,6 +564,9 @@ shaka.dash.SegmentTemplate = class {
         /* timescale= */ null,
         /* segmentData= */ null,
         aes128Key);
+    ref.codecs = context.representation.codecs;
+    ref.mimeType = context.representation.mimeType;
+    return ref;
   }
 };
 
@@ -835,6 +842,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
           this.periodEnd_ !== Infinity) {
         segmentEnd = this.periodEnd_;
       }
+      const codecs = this.templateInfo_.codecs;
+      const mimeType = this.templateInfo_.mimeType;
 
       const partialSegmentRefs = [];
 
@@ -877,6 +886,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
             /* syncTime= */ null,
             shaka.media.SegmentReference.Status.AVAILABLE,
             this.aes128Key_);
+        partial.codecs = codecs;
+        partial.mimeType = mimeType;
         if (this.segmentSequenceCadence_ == 0) {
           if (i > 0) {
             partial.markAsNonIndependent();
@@ -920,6 +931,8 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
           shaka.media.SegmentReference.Status.AVAILABLE,
           this.aes128Key_,
           /* allPartialSegments= */ range.partialSegments > 0);
+      ref.codecs = codecs;
+      ref.mimeType = mimeType;
       ref.trueEndTime = trueSegmentEnd;
       this.references[correctedPosition] = ref;
     }
@@ -955,7 +968,9 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
  *   unscaledPresentationTimeOffset: number,
  *   timeline: Array.<shaka.media.PresentationTimeline.TimeRange>,
  *   mediaTemplate: ?string,
- *   indexTemplate: ?string
+ *   indexTemplate: ?string,
+ *   mimeType: string,
+ *   codecs: string
  * }}
  *
  * @description
@@ -977,5 +992,9 @@ shaka.dash.TimelineSegmentIndex = class extends shaka.media.SegmentIndex {
  *   The media URI template, if given.
  * @property {?string} indexTemplate
  *   The index URI template, if given.
+ * @property {string} mimeType
+ *   The mimeType.
+ * @property {string} codecs
+ *   The codecs.
  */
 shaka.dash.SegmentTemplate.SegmentTemplateInfo;

package/lib/hls/hls_parser.js

@@ -1224,6 +1224,7 @@ shaka.hls.HlsParser = class {
             textStreamInfo.stream.mimeType =
                 this.guessMimeTypeBeforeLoading_(type, codecs) ||
                 this.guessMimeTypeFallback_(type);
+            this.setFullTypeForStream_(textStreamInfo.stream);
           }
         }
       }
@@ -1233,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.
@@ -2266,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.
@@ -2280,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);
           }
         }
       }
@@ -2288,6 +2300,7 @@ shaka.hls.HlsParser = class {
         const firstSegment = realStream.segmentIndex.get(0);
         if (firstSegment && firstSegment.initSegmentReference) {
           stream.mimeType = 'application/mp4';
+          this.setFullTypeForStream_(stream);
         }
       }
 
@@ -2537,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();
@@ -2692,7 +2706,7 @@ shaka.hls.HlsParser = class {
       roles.push(shaka.util.ManifestParserUtils.TextStreamKind.SUBTITLE);
     }
 
-    return {
+    const stream = {
       id: this.globalId_++,
       originalId: name,
       groupId: null,
@@ -2730,7 +2744,10 @@ shaka.hls.HlsParser = class {
       accessibilityPurpose: accessibilityPurpose,
       external: false,
       fastSwitching: false,
+      fullMimeTypes: new Set(),
     };
+    this.setFullTypeForStream_(stream);
+    return stream;
   }
 
   /**

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');
 
@@ -237,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;
   }
 
   /**
@@ -451,7 +495,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] = [];
@@ -467,13 +512,15 @@ shaka.media.MediaSourceEngine = class {
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
    * @param {shaka.extern.Stream} stream
    * @param {string} codecs
+   * @return {!Promise}
    * @private
    */
-  initSourceBuffer_(contentType, stream, codecs) {
+  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(
@@ -490,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(','));
@@ -498,12 +544,12 @@ shaka.media.MediaSourceEngine = class {
             ContentType.VIDEO, (codecs || '').split(','));
         if (audioCodec && videoCodec) {
           this.needSplitMuxedContent_ = true;
-          this.initSourceBuffer_(ContentType.AUDIO, stream, audioCodec);
-          this.initSourceBuffer_(ContentType.VIDEO, stream, videoCodec);
+          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;
@@ -1802,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] = [];
@@ -1935,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;
     }
@@ -1948,8 +1997,7 @@ 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_ &&
@@ -1958,7 +2006,7 @@ shaka.media.MediaSourceEngine = class {
     }
     const newMimeTypeWithAllCodecs =
         shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            stream.mimeType, stream.codecs);
+            refMimeType, refCodecs);
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
       const transmuxerPlugin =
@@ -1984,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/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/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.