shaka-player 4.3.10 → 4.4.0

package/lib/media/media_source_engine.js

@@ -12,10 +12,11 @@ goog.require('shaka.media.Capabilities');
 goog.require('shaka.media.ContentWorkarounds');
 goog.require('shaka.media.ClosedCaptionParser');
 goog.require('shaka.media.IClosedCaptionParser');
+goog.require('shaka.media.ManifestParser');
 goog.require('shaka.media.SegmentReference');
 goog.require('shaka.media.TimeRangesUtils');
-goog.require('shaka.media.Transmuxer');
 goog.require('shaka.text.TextEngine');
+goog.require('shaka.transmuxer.TransmuxerEngine');
 goog.require('shaka.util.BufferUtils');
 goog.require('shaka.util.Destroyer');
 goog.require('shaka.util.Error');
@@ -25,6 +26,8 @@ goog.require('shaka.util.IDestroyable');
 goog.require('shaka.util.Id3Utils');
 goog.require('shaka.util.ManifestParserUtils');
 goog.require('shaka.util.MimeUtils');
+goog.require('shaka.util.Mp4BoxParsers');
+goog.require('shaka.util.Mp4Parser');
 goog.require('shaka.util.Platform');
 goog.require('shaka.util.PublicPromise');
 goog.require('shaka.util.TsParser');
@@ -100,7 +103,7 @@ shaka.media.MediaSourceEngine = class {
     /** @private {shaka.util.EventManager} */
     this.eventManager_ = new shaka.util.EventManager();
 
-    /** @private {!Object.<string, !shaka.media.Transmuxer>} */
+    /** @private {!Object.<string, !shaka.extern.Transmuxer>} */
     this.transmuxers_ = {};
 
     /** @private {?shaka.media.IClosedCaptionParser} */
@@ -115,12 +118,24 @@ shaka.media.MediaSourceEngine = class {
     /** @private {MediaSource} */
     this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
 
+    /** @private {boolean} */
+    this.reloadingMediaSource_ = false;
+
     /** @type {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
 
     /** @private {boolean} */
     this.sequenceMode_ = false;
 
+    /** @private {string} */
+    this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
+
+    /** @private {boolean} */
+    this.ignoreManifestTimestampsInSegmentsMode_ = false;
+
+    /** @private {boolean} */
+    this.attemptTimestampOffsetCalculation_ = false;
+
     /** @private {!shaka.util.PublicPromise.<number>} */
     this.textSequenceModeOffset_ = new shaka.util.PublicPromise();
   }
@@ -174,12 +189,15 @@ shaka.media.MediaSourceEngine = class {
    * @return {boolean}
    */
   static isStreamSupported(stream) {
-    const fullMimeType = shaka.util.MimeUtils.getFullType(
+    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 extendedMimeType = shaka.util.MimeUtils.getExtendedType(stream);
+    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     return shaka.text.TextEngine.isTypeSupported(fullMimeType) ||
         shaka.media.Capabilities.isTypeSupported(extendedMimeType) ||
-        shaka.media.Transmuxer.isSupported(fullMimeType, stream.type);
+        TransmuxerEngine.isSupported(fullMimeTypeWithAllCodecs, stream.type);
   }
 
   /**
@@ -227,7 +245,7 @@ shaka.media.MediaSourceEngine = class {
       'application/ttml+xml',
       'application/mp4; codecs="stpp"',
       // Containerless types
-      ...shaka.media.MediaSourceEngine.RAW_FORMATS,
+      ...shaka.util.MimeUtils.RAW_FORMATS,
     ];
 
     const support = {};
@@ -238,7 +256,7 @@ shaka.media.MediaSourceEngine = class {
           support[type] = true;
         } else {
           support[type] = shaka.media.Capabilities.isTypeSupported(type) ||
-                          shaka.media.Transmuxer.isSupported(type);
+                          shaka.transmuxer.TransmuxerEngine.isSupported(type);
         }
       } else {
         support[type] = shaka.util.Platform.supportsMediaType(type);
@@ -344,70 +362,112 @@ shaka.media.MediaSourceEngine = class {
    *               shaka.extern.Stream>} streamsByType
    *   A map of content types to streams.  All streams must be supported
    *   according to MediaSourceEngine.isStreamSupported.
-   * @param {boolean} forceTransmux
-   *   If true, this will transmux AAC and TS content even if it is natively
-   *   supported.
    * @param {boolean=} sequenceMode
    *   If true, the media segments are appended to the SourceBuffer in strict
    *   sequence.
+   * @param {string=} manifestType
+   *   Indicates the type of the manifest.
+   * @param {boolean=} ignoreManifestTimestampsInSegmentsMode
+   *   If true, don't adjust the timestamp offset to account for manifest
+   *   segment durations being out of sync with segment durations. In other
+   *   words, assume that there are no gaps in the segments when appending
+   *   to the SourceBuffer, even if the manifest and segment times disagree.
+   *   Indicates if the manifest has text streams.
    *
    * @return {!Promise}
    */
-  async init(streamsByType, forceTransmux, sequenceMode=false) {
-    const ContentType = shaka.util.ManifestParserUtils.ContentType;
-
+  async init(streamsByType, sequenceMode=false,
+      manifestType=shaka.media.ManifestParser.UNKNOWN,
+      ignoreManifestTimestampsInSegmentsMode=false) {
     await this.mediaSourceOpen_;
 
     this.sequenceMode_ = sequenceMode;
+    this.manifestType_ = manifestType;
+    this.ignoreManifestTimestampsInSegmentsMode_ =
+      ignoreManifestTimestampsInSegmentsMode;
+
+    this.attemptTimestampOffsetCalculation_ = !this.sequenceMode_ &&
+        this.manifestType_ == shaka.media.ManifestParser.HLS &&
+        !this.ignoreManifestTimestampsInSegmentsMode_;
 
     for (const contentType of streamsByType.keys()) {
       const stream = streamsByType.get(contentType);
-      goog.asserts.assert(
-          shaka.media.MediaSourceEngine.isStreamSupported(stream),
-          'Type negotiation should happen before MediaSourceEngine.init!');
+      this.initSourceBuffer_(contentType, stream);
+      this.queues_[contentType] = [];
+    }
+  }
 
-      let mimeType = shaka.util.MimeUtils.getFullType(
-          stream.mimeType, stream.codecs);
-      if (contentType == ContentType.TEXT) {
-        this.reinitText(mimeType, sequenceMode, stream.external);
-      } else {
-        if ((forceTransmux ||
-            !shaka.media.Capabilities.isTypeSupported(mimeType)) &&
-            shaka.media.Transmuxer.isSupported(mimeType, contentType)) {
-          this.transmuxers_[contentType] =
-              new shaka.media.Transmuxer(mimeType);
+  /**
+   * Initialize a specific SourceBuffer.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {shaka.extern.Stream} stream
+   * @private
+   */
+  initSourceBuffer_(contentType, stream) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+
+    goog.asserts.assert(
+        shaka.media.MediaSourceEngine.isStreamSupported(stream),
+        'Type negotiation should happen before MediaSourceEngine.init!');
+
+    let mimeType = shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs);
+    if (contentType == ContentType.TEXT) {
+      this.reinitText(mimeType, this.sequenceMode_, stream.external);
+    } else {
+      let needTransmux = this.config_.forceTransmux;
+      if (!shaka.media.Capabilities.isTypeSupported(mimeType) ||
+          (!this.sequenceMode_ &&
+          shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType))) {
+        needTransmux = true;
+      }
+      const mimeTypeWithAllCodecs =
+          shaka.util.MimeUtils.getFullTypeWithAllCodecs(
+              stream.mimeType, stream.codecs);
+      const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
+      if (needTransmux) {
+        const transmuxerPlugin =
+            TransmuxerEngine.findTransmuxer(mimeTypeWithAllCodecs);
+        if (transmuxerPlugin) {
+          const transmuxer = transmuxerPlugin();
+          this.transmuxers_[contentType] = transmuxer;
           mimeType =
-              shaka.media.Transmuxer.convertCodecs(contentType, mimeType);
+              transmuxer.convertCodecs(contentType, mimeTypeWithAllCodecs);
         }
-        const type = mimeType + this.config_.sourceBufferExtraFeatures;
+      }
+      const type = mimeType + this.config_.sourceBufferExtraFeatures;
 
-        this.destroyer_.ensureNotDestroyed();
+      this.destroyer_.ensureNotDestroyed();
 
-        let sourceBuffer;
+      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\'');
-        }
+      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',
-            () => this.onError_(contentType));
-        this.eventManager_.listen(
-            sourceBuffer, 'updateend',
-            () => this.onUpdateEnd_(contentType));
-        this.sourceBuffers_[contentType] = sourceBuffer;
-        this.sourceBufferTypes_[contentType] = mimeType;
-        this.queues_[contentType] = [];
-        this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
+      if (this.sequenceMode_) {
+        sourceBuffer.mode =
+            shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
       }
+
+      this.eventManager_.listen(
+          sourceBuffer, 'error',
+          () => this.onError_(contentType));
+      this.eventManager_.listen(
+          sourceBuffer, 'updateend',
+          () => this.onUpdateEnd_(contentType));
+      this.sourceBuffers_[contentType] = sourceBuffer;
+      this.sourceBufferTypes_[contentType] = mimeType;
+      this.expectedEncryption_[contentType] = !!stream.drmInfos.length;
     }
   }
 
@@ -440,6 +500,9 @@ shaka.media.MediaSourceEngine = class {
    *   object has been destroyed.
    */
   ended() {
+    if (this.reloadingMediaSource_) {
+      return false;
+    }
     return this.mediaSource_ ? this.mediaSource_.readyState == 'ended' : true;
   }
 
@@ -450,6 +513,9 @@ shaka.media.MediaSourceEngine = class {
    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
    */
   bufferStart(contentType) {
+    if (this.reloadingMediaSource_) {
+      return null;
+    }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       return this.textEngine_.bufferStart();
@@ -465,6 +531,9 @@ shaka.media.MediaSourceEngine = class {
    * @return {?number} The timestamp in seconds, or null if nothing is buffered.
    */
   bufferEnd(contentType) {
+    if (this.reloadingMediaSource_) {
+      return null;
+    }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       return this.textEngine_.bufferEnd();
@@ -482,6 +551,9 @@ shaka.media.MediaSourceEngine = class {
    * @return {boolean}
    */
   isBuffered(contentType, time) {
+    if (this.reloadingMediaSource_) {
+      return false;
+    }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       return this.textEngine_.isBuffered(time);
@@ -500,6 +572,9 @@ shaka.media.MediaSourceEngine = class {
    * @return {number} The amount of time buffered ahead in seconds.
    */
   bufferedAheadOf(contentType, time) {
+    if (this.reloadingMediaSource_) {
+      return 0;
+    }
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
       return this.textEngine_.bufferedAheadOf(time);
@@ -518,11 +593,12 @@ shaka.media.MediaSourceEngine = class {
     const TimeRangesUtils = shaka.media.TimeRangesUtils;
 
     const info = {
-      total: TimeRangesUtils.getBufferedInfo(this.video_.buffered),
-      audio: TimeRangesUtils.getBufferedInfo(
-          this.getBuffered_(ContentType.AUDIO)),
-      video: TimeRangesUtils.getBufferedInfo(
-          this.getBuffered_(ContentType.VIDEO)),
+      total: this.reloadingMediaSource_ ? [] :
+        TimeRangesUtils.getBufferedInfo(this.video_.buffered),
+      audio: this.reloadingMediaSource_ ? [] :
+        TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.AUDIO)),
+      video: this.reloadingMediaSource_ ? [] :
+        TimeRangesUtils.getBufferedInfo(this.getBuffered_(ContentType.VIDEO)),
       text: [],
     };
 
@@ -568,6 +644,83 @@ shaka.media.MediaSourceEngine = class {
     return new shaka.media.ClosedCaptionParser(mimeType);
   }
 
+  /**
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {!BufferSource} data
+   * @param {?shaka.media.SegmentReference} reference The segment reference
+   *   we are appending, or null for init segments
+   * @param {!string} mimeType
+   * @param {!number} timestampOffset
+   * @return {?number}
+   * @private
+   */
+  getTimestampAndDispatchMetadata_(contentType, data, reference, mimeType,
+      timestampOffset) {
+    let timestamp = null;
+
+    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+    if (shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType)) {
+      const frames = shaka.util.Id3Utils.getID3Frames(uint8ArrayData);
+      if (frames.length && reference) {
+        const metadataTimestamp = frames.find((frame) => {
+          return frame.description ===
+              'com.apple.streaming.transportStreamTimestamp';
+        });
+        if (metadataTimestamp && metadataTimestamp.data) {
+          timestamp = Math.round(metadataTimestamp.data) / 1000;
+        }
+        /** @private {shaka.extern.ID3Metadata} */
+        const metadata = {
+          cueTime: reference.startTime,
+          data: uint8ArrayData,
+          frames: frames,
+          dts: reference.startTime,
+          pts: reference.startTime,
+        };
+        this.onMetadata_([metadata], /* offset= */ 0, reference.endTime);
+      }
+    } else if (mimeType.includes('/mp4') &&
+        reference && reference.timestampOffset == 0 &&
+        reference.initSegmentReference &&
+        reference.initSegmentReference.timescale) {
+      const timescale = reference.initSegmentReference.timescale;
+      if (!isNaN(timescale)) {
+        const Mp4Parser = shaka.util.Mp4Parser;
+        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 parsed = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
+                  box.reader, box.version);
+              startTime = parsed.baseMediaDecodeTime / timescale;
+              parsedMedia = true;
+              box.parser.stop();
+            }).parse(data, /* partialOkay= */ true);
+        if (parsedMedia) {
+          timestamp = startTime;
+        }
+      }
+    } else if (!mimeType.includes('/mp4') && !mimeType.includes('/webm') &&
+        shaka.util.TsParser.probe(uint8ArrayData)) {
+      const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
+      const startTime = tsParser.getStartTime()[contentType];
+      if (startTime != null) {
+        timestamp = startTime;
+      }
+      const metadata = tsParser.getMetadata();
+      if (metadata.length) {
+        this.onMetadata_(metadata, timestampOffset,
+            reference ? reference.endTime : null);
+      }
+    }
+    return timestamp;
+  }
+
   /**
    * Enqueue an operation to append data to the SourceBuffer.
    * Start and end times are needed for TextEngine, but not for MediaSource.
@@ -578,6 +731,7 @@ shaka.media.MediaSourceEngine = class {
    * @param {!BufferSource} data
    * @param {?shaka.media.SegmentReference} reference The segment reference
    *   we are appending, or null for init segments
+   * @param {shaka.extern.Stream} stream
    * @param {?boolean} hasClosedCaptions True if the buffer contains CEA closed
    *   captions
    * @param {boolean=} seeked True if we just seeked
@@ -588,7 +742,7 @@ shaka.media.MediaSourceEngine = class {
    * @return {!Promise}
    */
   async appendBuffer(
-      contentType, data, reference, hasClosedCaptions, seeked = false,
+      contentType, data, reference, stream, hasClosedCaptions, seeked = false,
       adaptation = false, isChunkedData = false) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
 
@@ -605,77 +759,49 @@ shaka.media.MediaSourceEngine = class {
       return;
     }
 
-    const uint8ArrayData = shaka.util.BufferUtils.toUint8(data);
+    let timestampOffset = this.sourceBuffers_[contentType].timestampOffset;
+
     let mimeType = this.sourceBufferTypes_[contentType];
     if (this.transmuxers_[contentType]) {
       mimeType = this.transmuxers_[contentType].getOrginalMimeType();
     }
-    if (shaka.util.TsParser.probe(uint8ArrayData)) {
-      const tsParser = new shaka.util.TsParser().parse(uint8ArrayData);
-      // The SourceBuffer timestampOffset may or may not be set yet, so this is
-      // the timestamp offset that would eventually compute for this segment
-      // either way.
-      const timestampOffset =
-          reference.startTime - (tsParser.getStartTime()[contentType] || 0);
-      const metadata = tsParser.getMetadata();
-      if (metadata.length) {
-        this.onMetadata_(metadata, timestampOffset,
-            reference ? reference.endTime : null);
-      }
-    } else {
-      if (shaka.media.MediaSourceEngine.RAW_FORMATS.includes(mimeType)) {
-        const frames = shaka.util.Id3Utils.getID3Frames(uint8ArrayData);
-        if (frames.length && reference) {
-          /** @private {shaka.extern.ID3Metadata} */
-          const metadata = {
-            cueTime: reference.startTime,
-            data: uint8ArrayData,
-            frames: frames,
-            dts: reference.startTime,
-            pts: reference.startTime,
-          };
-          this.onMetadata_([metadata], /* offset= */ 0, reference.endTime);
+    if (reference) {
+      const timestamp = this.getTimestampAndDispatchMetadata_(
+          contentType, data, reference, mimeType, timestampOffset);
+      if (timestamp != null) {
+        const calculatedTimestampOffset = reference.startTime - timestamp;
+        const timestampOffsetDifference =
+            Math.abs(timestampOffset - calculatedTimestampOffset);
+        if (timestampOffsetDifference >= 0.1 || seeked || adaptation) {
+          timestampOffset = calculatedTimestampOffset;
+          if (this.attemptTimestampOffsetCalculation_) {
+            this.enqueueOperation_(
+                contentType,
+                () => this.abort_(contentType));
+            this.enqueueOperation_(
+                contentType,
+                () => this.setTimestampOffset_(contentType, timestampOffset));
+          }
+        }
+        // Timestamps can only be reliably extracted from video, not audio.
+        // Packed audio formats do not have internal timestamps at all.
+        // Prefer video for this when available.
+        const isBestSourceBufferForTimestamps =
+            contentType == ContentType.VIDEO ||
+            !(ContentType.VIDEO in this.sourceBuffers_);
+        if (this.sequenceMode_ && isBestSourceBufferForTimestamps) {
+          this.textSequenceModeOffset_.resolve(timestampOffset);
         }
       }
     }
-
-    if (this.transmuxers_[contentType]) {
-      // When seeked we should reset the transmuxer captionstreams
-      // so it does not ignores the captions from previous segments
-      if (seeked) {
-        this.transmuxers_[contentType].resetCaptions();
-      }
-
-      const transmuxedData =
-          await this.transmuxers_[contentType].transmux(data);
-      // 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(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
-            this.sequenceMode_, /* external= */ false);
-      }
-      // This doesn't work for native TS support (ex. Edge/Chromecast),
-      // since no transmuxing is needed for native TS.
-      if (transmuxedData.captions && transmuxedData.captions.length) {
-        const videoOffset =
-        this.sourceBuffers_[ContentType.VIDEO].timestampOffset;
-        const closedCaptions = this.textEngine_
-            .convertMuxjsCaptionsToShakaCaptions(transmuxedData.captions);
-        this.textEngine_.storeAndAppendClosedCaptions(
-            closedCaptions,
-            reference ? reference.startTime : null,
-            reference ? reference.endTime : null,
-            videoOffset);
-      }
-
-      data = transmuxedData.data;
-    } else if (hasClosedCaptions && contentType == ContentType.VIDEO) {
+    if (hasClosedCaptions && contentType == ContentType.VIDEO) {
       if (!this.textEngine_) {
         this.reinitText(shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE,
             this.sequenceMode_, /* external= */ false);
       }
       if (!this.captionParser_) {
-        this.captionParser_ = this.getCaptionParser(mimeType);
+        const basicType = mimeType.split(';', 1)[0];
+        this.captionParser_ = this.getCaptionParser(basicType);
       }
       // If it is the init segment for closed captions, initialize the closed
       // caption parser.
@@ -684,92 +810,23 @@ shaka.media.MediaSourceEngine = class {
       } else {
         const closedCaptions = this.captionParser_.parseFrom(data);
         if (closedCaptions.length) {
-          const videoOffset =
-            this.sourceBuffers_[ContentType.VIDEO].timestampOffset;
           this.textEngine_.storeAndAppendClosedCaptions(
               closedCaptions,
               reference.startTime,
               reference.endTime,
-              videoOffset);
+              timestampOffset);
         }
       }
     }
 
+    if (this.transmuxers_[contentType]) {
+      data = await this.transmuxers_[contentType].transmux(
+          data, stream, reference, this.mediaSource_.duration);
+    }
+
     data = this.workAroundBrokenPlatforms_(
         data, reference ? reference.startTime : null, contentType);
 
-    const sourceBuffer = this.sourceBuffers_[contentType];
-    const SEQUENCE = shaka.media.MediaSourceEngine.SourceBufferMode_.SEQUENCE;
-
-    if (this.sequenceMode_ && sourceBuffer.mode != SEQUENCE && reference) {
-      // This is the first media segment to be appended to a SourceBuffer in
-      // sequence mode.  We set the mode late so that we can trick MediaSource
-      // into extracting a timestamp for us to align text segments in sequence
-      // mode.
-
-      const duration = this.mediaSource_.duration;
-
-      // Timestamps can only be reliably extracted from video, not audio.
-      // Packed audio formats do not have internal timestamps at all.
-      // Prefer video for this when available.
-      const isBestSourceBufferForTimestamps =
-          contentType == ContentType.VIDEO ||
-          !(ContentType.VIDEO in this.sourceBuffers_);
-      if (isBestSourceBufferForTimestamps) {
-        // Append the segment in segments mode first, with offset of 0 and an
-        // open append window.
-        const originalRange =
-            [sourceBuffer.appendWindowStart, sourceBuffer.appendWindowEnd];
-        sourceBuffer.appendWindowStart = 0;
-        sourceBuffer.appendWindowEnd = Infinity;
-
-        const originalOffset = sourceBuffer.timestampOffset;
-        sourceBuffer.timestampOffset = 0;
-
-        await this.enqueueOperation_(
-            contentType, () => this.append_(contentType, data));
-        // If the input buffer passed to SourceBuffer#appendBuffer() does not
-        // contain a complete media segment, the call will exit while the
-        // SourceBuffer's append state is
-        // still PARSING_MEDIA_SEGMENT. Reset the parser state by calling
-        // abort() to safely reset timestampOffset to 'originalOffset'.
-        // https://www.w3.org/TR/media-source-2/#sourcebuffer-segment-parser-loop
-        await this.enqueueOperation_(
-            contentType, () => this.abort_(contentType));
-
-        // Reset the offset and append window.
-        sourceBuffer.timestampOffset = originalOffset;
-        sourceBuffer.appendWindowStart = originalRange[0];
-        sourceBuffer.appendWindowEnd = originalRange[1];
-
-        // Now get the timestamp of the segment and compute the offset for text
-        // segments.
-        const mediaStartTime = shaka.media.TimeRangesUtils.bufferStart(
-            this.getBuffered_(contentType));
-        const textOffset = (reference.startTime || 0) - (mediaStartTime || 0);
-        this.textSequenceModeOffset_.resolve(textOffset);
-
-        // Clear the buffer.
-        await this.enqueueOperation_(
-            contentType,
-            () => this.remove_(contentType, 0, duration));
-
-        // Finally, flush the buffer in case of choppy video start on HLS fMP4.
-        if (contentType == ContentType.VIDEO) {
-          await this.enqueueOperation_(
-              contentType,
-              () => this.flush_(contentType));
-        }
-      }
-
-      // Now switch to sequence mode and fall through to our normal operations.
-      sourceBuffer.mode = SEQUENCE;
-
-      // When we change the buffer mode the duration is lost, so we need to set
-      // it explicitly.
-      await this.setDuration(duration);
-    }
-
     if (reference && this.sequenceMode_ && contentType != ContentType.TEXT) {
       // In sequence mode, for non-text streams, if we just cleared the buffer
       // and are either performing an unbuffered seek or handling an automatic
@@ -919,23 +976,33 @@ shaka.media.MediaSourceEngine = class {
    * @param {number} appendWindowEnd The timestamp to set the append window end
    *   to.  For future appends, frames/samples with timestamps greater than this
    *   value will be dropped.
-   * @param {boolean} sequenceMode  If true, the timestampOffset will not be
-   *   applied in this step.
+   * @param {boolean} ignoreTimestampOffset  If true, the timestampOffset will
+   *   not be applied in this step.
+   * @param {shaka.extern.Stream} stream The current stream.
+   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   *   A map of content types to streams.  All streams must be supported
+   *   according to MediaSourceEngine.isStreamSupported.
+   *
    * @return {!Promise}
    */
   async setStreamProperties(
       contentType, timestampOffset, appendWindowStart, appendWindowEnd,
-      sequenceMode) {
+      ignoreTimestampOffset, stream, streamsByType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
-      if (!sequenceMode) {
+      if (!ignoreTimestampOffset) {
         this.textEngine_.setTimestampOffset(timestampOffset);
       }
       this.textEngine_.setAppendWindow(appendWindowStart, appendWindowEnd);
       return;
     }
+    const operations = [];
 
-    await Promise.all([
+    const hasChangedCodecs =
+        await this.codecSwitchIfNecessary_(contentType, stream, streamsByType);
+
+    if (!hasChangedCodecs) {
       // 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.
@@ -944,20 +1011,21 @@ shaka.media.MediaSourceEngine = class {
       // always enter a PARSING_MEDIA_SEGMENT state and we can't change the
       // timestamp offset.  By calling abort(), we reset the state so we can
       // set it.
-      this.enqueueOperation_(
-          contentType,
-          () => this.abort_(contentType)),
-      // Don't set the timestampOffset here when in sequenceMode, since we
-      // use timestampOffset for a different purpose in that mode (e.g. to
-      // indicate where the current segment is).
-      sequenceMode ? Promise.resolve() : this.enqueueOperation_(
+      operations.push(this.enqueueOperation_(
           contentType,
-          () => this.setTimestampOffset_(contentType, timestampOffset)),
-      this.enqueueOperation_(
+          () => this.abort_(contentType)));
+    }
+    if (!ignoreTimestampOffset) {
+      operations.push(this.enqueueOperation_(
           contentType,
-          () => this.setAppendWindow_(
-              contentType, appendWindowStart, appendWindowEnd)),
-    ]);
+          () => this.setTimestampOffset_(contentType, timestampOffset)));
+    }
+    operations.push(this.enqueueOperation_(
+        contentType,
+        () => this.setAppendWindow_(
+            contentType, appendWindowStart, appendWindowEnd)));
+
+    await Promise.all(operations);
   }
 
   /**
@@ -1200,6 +1268,9 @@ shaka.media.MediaSourceEngine = class {
    * @private
    */
   onUpdateEnd_(contentType) {
+    if (this.reloadingMediaSource_) {
+      return;
+    }
     const operation = this.queues_[contentType][0];
     goog.asserts.assert(operation, 'Spurious updateend event!');
     if (!operation) {
@@ -1238,7 +1309,7 @@ shaka.media.MediaSourceEngine = class {
    * Enqueue an operation which must block all other operations on all
    * SourceBuffers.
    *
-   * @param {function()} run
+   * @param {function():(Promise|undefined)} run
    * @return {!Promise}
    * @private
    */
@@ -1304,15 +1375,16 @@ shaka.media.MediaSourceEngine = class {
       }
     }
 
-    // Run the real operation, which is synchronous.
+    // Run the real operation, which can be asynchronous.
     try {
-      run();
+      await run();
     } 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);
+          exception,
+          this.video_.error || 'No error in the media element');
     } finally {
       // Unblock the queues.
       for (const contentType in this.sourceBuffers_) {
@@ -1355,7 +1427,8 @@ shaka.media.MediaSourceEngine = class {
               shaka.util.Error.Severity.CRITICAL,
               shaka.util.Error.Category.MEDIA,
               shaka.util.Error.Code.MEDIA_SOURCE_OPERATION_THREW,
-              exception));
+              exception,
+              this.video_.error || 'No error in the media element'));
         }
         this.popFromQueue_(contentType);
       }
@@ -1410,15 +1483,17 @@ shaka.media.MediaSourceEngine = class {
     const encryptionExpected = this.expectedEncryption_[contentType];
 
     // If:
-    //   1. this is an init segment,
-    //   2. and encryption is expected,
-    //   3. and the platform requires encryption in all init segments,
-    //   4. and the content is MP4 (mimeType == "video/mp4" or "audio/mp4"),
+    //   1. the configuration tells to insert fake encryption,
+    //   2. and this is an init segment,
+    //   3. and encryption is expected,
+    //   4. and the platform requires encryption in all init segments,
+    //   5. and the content is MP4 (mimeType == "video/mp4" or "audio/mp4"),
     // then insert fake encryption metadata for init segments that lack it.
     // The MP4 requirement is because we can currently only do this
     // transformation on MP4 containers.
     // See: https://github.com/shaka-project/shaka-player/issues/2759
-    if (isInitSegment &&
+    if (this.config_.insertFakeEncryptionInInit &&
+        isInitSegment &&
         encryptionExpected &&
         shaka.util.Platform.requiresEncryptionInfoInAllInitSegments() &&
         shaka.util.MimeUtils.getContainerType(
@@ -1430,6 +1505,188 @@ shaka.media.MediaSourceEngine = class {
     return segment;
   }
 
+  /**
+   * Prepare the SourceBuffer to parse a potentially new type or codec.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {string} mimeType
+   * @param {?shaka.extern.Transmuxer} transmuxer
+   * @private
+   */
+  change_(contentType, mimeType, transmuxer) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    if (contentType === ContentType.TEXT) {
+      shaka.log.debug(`Change not supported for ${contentType}`);
+      return;
+    }
+    shaka.log.debug(
+        `Change Type: ${this.sourceBufferTypes_[contentType]} -> ${mimeType}`);
+    if (shaka.media.Capabilities.isChangeTypeSupported()) {
+      if (this.transmuxers_[contentType]) {
+        this.transmuxers_[contentType].destroy();
+      }
+      if (transmuxer) {
+        this.transmuxers_[contentType] = transmuxer;
+      }
+      const type = mimeType + this.config_.sourceBufferExtraFeatures;
+      this.sourceBuffers_[contentType].changeType(type);
+      this.sourceBufferTypes_[contentType] = mimeType;
+    } else {
+      shaka.log.debug('Change Type not supported');
+    }
+
+    // Fake an 'updateend' event to resolve the operation.
+    this.onUpdateEnd_(contentType);
+  }
+
+  /**
+   * Enqueue an operation to prepare the SourceBuffer to parse a potentially new
+   * type or codec.
+   *
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {string} mimeType
+   * @param {?shaka.extern.Transmuxer} transmuxer
+   * @return {!Promise}
+   */
+  changeType(contentType, mimeType, transmuxer) {
+    return this.enqueueOperation_(
+        contentType,
+        () => this.change_(contentType, mimeType, transmuxer));
+  }
+
+  /**
+   * Resets the MediaSource and re-adds source buffers due to codec mismatch
+   *
+   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   * @private
+   */
+  async reset_(streamsByType) {
+    this.reloadingMediaSource_ = true;
+    const currentTime = this.video_.currentTime;
+    try {
+      this.eventManager_.removeAll();
+      this.sourceBuffers_ = {};
+
+      const cleanup = [];
+      for (const contentType in this.transmuxers_) {
+        cleanup.push(this.transmuxers_[contentType].destroy());
+      }
+      for (const contentType in this.sourceBuffers_) {
+        const sourceBuffer = this.sourceBuffers_[contentType];
+        try {
+          this.mediaSource_.removeSourceBuffer(sourceBuffer);
+        } catch (e) {}
+      }
+      await Promise.all(cleanup);
+      this.transmuxers_ = {};
+
+      const previousDuration = this.mediaSource_.duration;
+      this.mediaSourceOpen_ = new shaka.util.PublicPromise();
+      this.mediaSource_ = this.createMediaSource(this.mediaSourceOpen_);
+      await this.mediaSourceOpen_;
+      this.mediaSource_.duration = previousDuration;
+
+      const sourceBufferAdded = new shaka.util.PublicPromise();
+      const sourceBuffers =
+        /** @type {EventTarget} */(this.mediaSource_.sourceBuffers);
+
+      const totalOfBuffers = streamsByType.size;
+      let numberOfSourceBufferAdded = 0;
+      this.eventManager_.listen(sourceBuffers, 'addsourcebuffer', (event) => {
+        numberOfSourceBufferAdded++;
+        if (numberOfSourceBufferAdded === totalOfBuffers) {
+          sourceBufferAdded.resolve();
+        }
+      });
+
+      for (const contentType of streamsByType.keys()) {
+        const stream = streamsByType.get(contentType);
+        this.initSourceBuffer_(contentType, stream);
+      }
+
+      // Fake a seek to catchup the playhead.
+      this.video_.currentTime = currentTime;
+
+      await sourceBufferAdded;
+    } finally {
+      this.reloadingMediaSource_ = false;
+    }
+  }
+
+  /**
+   * Resets the Media Source
+   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   * @return {!Promise}
+   */
+  reset(streamsByType) {
+    return this.enqueueBlockingOperation_(
+        () => this.reset_(streamsByType));
+  }
+
+  /**
+   * Codec switch if necessary, this will not resolve until the codec
+   * switch is over.
+   * @param {shaka.util.ManifestParserUtils.ContentType} contentType
+   * @param {shaka.extern.Stream} stream
+   * @param {!Map.<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   * @return {!Promise.<boolean>} true if there was a codec switch,
+   *                              false otherwise.
+   * @private
+   */
+  async codecSwitchIfNecessary_(contentType, stream, streamsByType) {
+    const MimeUtils = shaka.util.MimeUtils;
+    const currentCodec = MimeUtils.getCodecBase(
+        MimeUtils.getCodecs(this.sourceBufferTypes_[contentType]));
+    const currentBasicType = MimeUtils.getBasicType(
+        this.sourceBufferTypes_[contentType]);
+
+    /** @type {?shaka.extern.Transmuxer} */
+    let transmuxer;
+    let newMimeType = shaka.util.MimeUtils.getFullType(
+        stream.mimeType, stream.codecs);
+    let needTransmux = this.config_.forceTransmux;
+    if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
+        (!this.sequenceMode_ &&
+        shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
+      needTransmux = true;
+    }
+    const newMimeTypeWithAllCodecs =
+        shaka.util.MimeUtils.getFullTypeWithAllCodecs(
+            stream.mimeType, stream.codecs);
+    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
+    if (needTransmux) {
+      const transmuxerPlugin =
+          TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
+      if (transmuxerPlugin) {
+        transmuxer = transmuxerPlugin();
+        newMimeType =
+            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+      }
+    }
+
+    const newCodec = MimeUtils.getCodecBase(
+        MimeUtils.getCodecs(newMimeType));
+    const newBasicType = MimeUtils.getBasicType(newMimeType);
+
+    // Current/new codecs base and basic type match then no need to switch
+    if (currentCodec === newCodec && currentBasicType === newBasicType) {
+      return false;
+    }
+
+    if (shaka.media.Capabilities.isChangeTypeSupported()) {
+      await this.changeType(contentType, newMimeType, transmuxer);
+    } else {
+      if (transmuxer) {
+        transmuxer.destroy();
+      }
+      await this.reset(streamsByType);
+    }
+    return true;
+  }
+
   /**
    * Update LCEVC DIL object when ready for LCEVC Decodes
    * @param {?shaka.lcevc.Dil} lcevcDil
@@ -1473,16 +1730,3 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
   SEQUENCE: 'sequence',
   SEGMENTS: 'segments',
 };
-
-
-/**
- * MIME types of raw formats.
- *
- * @const {!Array.<string>}
- */
-shaka.media.MediaSourceEngine.RAW_FORMATS = [
-  'audio/aac',
-  'audio/ac3',
-  'audio/ec3',
-  'audio/mpeg',
-];