fix: Avoid reset or changeType in MSE when not necessary (#8744)

Fixes #8737

---------

Co-authored-by: Wojciech Tyczyński <[email protected]>

Author: avelad

lib/media/media_source_engine.js

@@ -10,6 +10,7 @@ goog.require('goog.asserts');
 goog.require('shaka.log');
 goog.require('shaka.config.CodecSwitchingStrategy');
 goog.require('shaka.device.DeviceFactory');
+goog.require('shaka.device.IDevice');
 goog.require('shaka.media.Capabilities');
 goog.require('shaka.media.ContentWorkarounds');
 goog.require('shaka.media.ClosedCaptionParser');
@@ -2368,11 +2369,19 @@ shaka.media.MediaSourceEngine = class {
       codec = codecs;
     }
     let newMimeType = shaka.util.MimeUtils.getFullType(mimeType, codec);
+    const currentBasicType = MimeUtils.getBasicType(
+        this.sourceBufferTypes_.get(contentType));
+
     let needTransmux = this.config_.forceTransmux;
     if (!shaka.media.Capabilities.isTypeSupported(newMimeType) ||
         (!this.sequenceMode_ &&
         shaka.util.MimeUtils.RAW_FORMATS.includes(newMimeType))) {
       needTransmux = true;
+    } else if (!needTransmux && mimeType != currentBasicType) {
+      const device = shaka.device.DeviceFactory.getDevice();
+      needTransmux = device.getBrowserEngine() ===
+          shaka.device.IDevice.BrowserEngine.WEBKIT &&
+          shaka.util.MimeUtils.RAW_FORMATS.includes(mimeType);
     }
     const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
     if (needTransmux) {
@@ -2410,14 +2419,18 @@ shaka.media.MediaSourceEngine = class {
    * @param {string} codecs
    * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
    *               shaka.extern.Stream>} streamsByType
-   * @return {!Promise<boolean>} true if there was a codec switch,
-   *                              false otherwise.
+   * @return {{type: string, newMimeType: string,
+   *           transmuxer: ?shaka.extern.Transmuxer}}
    * @private
    */
-  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+  getInfoAboutResetOrChangeType_(contentType, mimeType, codecs, streamsByType) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     if (contentType == ContentType.TEXT) {
-      return false;
+      return {
+        type: shaka.media.MediaSourceEngine.ResetMode_.NONE,
+        newMimeType: mimeType,
+        transmuxer: null,
+      };
     }
     const MimeUtils = shaka.util.MimeUtils;
     const currentCodec = MimeUtils.getNormalizedCodec(
@@ -2451,91 +2464,91 @@ shaka.media.MediaSourceEngine = class {
     // Current/new codecs base and basic type match then no need to switch
     if (currentCodec === newCodec && currentBasicType === newBasicType &&
         muxedContentCheck) {
-      if (this.transmuxers_.has(contentType) && !transmuxer) {
-        this.transmuxers_.get(contentType).destroy();
-        this.transmuxers_.delete(contentType);
-      } else if (!this.transmuxers_.has(contentType) && transmuxer) {
-        this.transmuxers_.set(contentType, transmuxer);
-      } else if (transmuxer) {
-        // Compare if the transmuxer is different
-        if (this.transmuxers_.has(contentType) &&
-            this.transmuxers_.get(contentType).transmux !=
-              transmuxer.transmux) {
-          this.transmuxers_.get(contentType).destroy();
-          this.transmuxers_.delete(contentType);
-          this.transmuxers_.set(contentType, transmuxer);
-        } else {
-          transmuxer.destroy();
-        }
-      }
-      return false;
+      return {
+        type: shaka.media.MediaSourceEngine.ResetMode_.NONE,
+        newMimeType,
+        transmuxer,
+      };
     }
 
     let allowChangeType = true;
-    if (this.needSplitMuxedContent_ || (transmuxerMuxed &&
+    if ((this.needSplitMuxedContent_ &&
+        !streamsByType.has(ContentType.AUDIO)) || (transmuxerMuxed &&
         transmuxer && !this.transmuxers_.has(contentType))) {
       allowChangeType = false;
     }
 
     if (allowChangeType && this.config_.codecSwitchingStrategy ===
         shaka.config.CodecSwitchingStrategy.SMOOTH &&
           shaka.media.Capabilities.isChangeTypeSupported()) {
-      await this.changeType(contentType, newMimeType, transmuxer);
+      return {
+        type: shaka.media.MediaSourceEngine.ResetMode_.CHANGE_TYPE,
+        newMimeType,
+        transmuxer,
+      };
     } else {
       if (transmuxer) {
         transmuxer.destroy();
       }
-      await this.reset(streamsByType);
+      return {
+        type: shaka.media.MediaSourceEngine.ResetMode_.RESET,
+        newMimeType,
+        transmuxer: null,
+      };
     }
-    return true;
   }
 
   /**
-   * Returns true if it's necessary codec switch to load the new stream.
-   *
+   * Codec switch if necessary, this will not resolve until the codec
+   * switch is over.
    * @param {shaka.util.ManifestParserUtils.ContentType} contentType
-   * @param {string} refMimeType
-   * @param {string} refCodecs
-   * @return {boolean}
+   * @param {string} mimeType
+   * @param {string} codecs
+   * @param {!Map<shaka.util.ManifestParserUtils.ContentType,
+   *               shaka.extern.Stream>} streamsByType
+   * @return {!Promise<boolean>} true if there was a codec switch,
+   *                              false otherwise.
    * @private
    */
-  isCodecSwitchNecessary_(contentType, refMimeType, refCodecs) {
-    if (contentType == shaka.util.ManifestParserUtils.ContentType.TEXT) {
-      return false;
+  async codecSwitchIfNecessary_(contentType, mimeType, codecs, streamsByType) {
+    const ContentType = shaka.util.ManifestParserUtils.ContentType;
+    const {type, transmuxer, newMimeType} = this.getInfoAboutResetOrChangeType_(
+        contentType, mimeType, codecs, streamsByType);
+
+    const newAudioStream = streamsByType.get(ContentType.AUDIO);
+    if (newAudioStream) {
+      this.needSplitMuxedContent_ = newAudioStream.isAudioMuxedInVideo;
     }
-    const MimeUtils = shaka.util.MimeUtils;
-    const currentCodec = MimeUtils.getNormalizedCodec(
-        MimeUtils.getCodecs(this.sourceBufferTypes_.get(contentType)));
-    const currentBasicType = MimeUtils.getBasicType(
-        this.sourceBufferTypes_.get(contentType));
 
-    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))) {
-      needTransmux = true;
+    if (type == shaka.media.MediaSourceEngine.ResetMode_.NONE) {
+      if (this.transmuxers_.has(contentType) && !transmuxer) {
+        this.transmuxers_.get(contentType).destroy();
+        this.transmuxers_.delete(contentType);
+      } else if (!this.transmuxers_.has(contentType) && transmuxer) {
+        this.transmuxers_.set(contentType, transmuxer);
+      } else if (transmuxer) {
+        // Compare if the transmuxer is different
+        if (this.transmuxers_.has(contentType) &&
+            this.transmuxers_.get(contentType).transmux !==
+              transmuxer.transmux) {
+          this.transmuxers_.get(contentType).destroy();
+          this.transmuxers_.set(contentType, transmuxer);
+        } else {
+          transmuxer.destroy();
+        }
+      }
+      return false;
     }
-    const newMimeTypeWithAllCodecs =
-        shaka.util.MimeUtils.getFullTypeWithAllCodecs(
-            refMimeType, refCodecs);
-    const TransmuxerEngine = shaka.transmuxer.TransmuxerEngine;
-    if (needTransmux) {
-      const transmuxerPlugin =
-          TransmuxerEngine.findTransmuxer(newMimeTypeWithAllCodecs);
-      if (transmuxerPlugin) {
-        const transmuxer = transmuxerPlugin();
-        newMimeType =
-            transmuxer.convertCodecs(contentType, newMimeTypeWithAllCodecs);
+
+    if (type == shaka.media.MediaSourceEngine.ResetMode_.CHANGE_TYPE) {
+      await this.changeType(contentType, newMimeType, transmuxer);
+    } else if (type == shaka.media.MediaSourceEngine.ResetMode_.RESET) {
+      if (transmuxer) {
         transmuxer.destroy();
       }
+      await this.reset(streamsByType);
     }
-
-    const newCodec = MimeUtils.getNormalizedCodec(
-        MimeUtils.getCodecs(newMimeType));
-    const newBasicType = MimeUtils.getBasicType(newMimeType);
-
-    return currentCodec !== newCodec || currentBasicType !== newBasicType;
+    return true;
   }
 
   /**
@@ -2547,15 +2560,13 @@ shaka.media.MediaSourceEngine = class {
    * @param {string} codecs
    * @return {boolean}
    */
-  isResetMediaSourceNecessary(contentType, mimeType, codecs) {
-    if (!this.isCodecSwitchNecessary_(contentType, mimeType, codecs)) {
-      return false;
+  isResetMediaSourceNecessary(contentType, mimeType, codecs, streamsByType) {
+    const info = this.getInfoAboutResetOrChangeType_(
+        contentType, mimeType, codecs, streamsByType);
+    if (info.transmuxer) {
+      info.transmuxer.destroy();
     }
-
-    return this.config_.codecSwitchingStrategy !==
-        shaka.config.CodecSwitchingStrategy.SMOOTH ||
-        !shaka.media.Capabilities.isChangeTypeSupported() ||
-        this.needSplitMuxedContent_;
+    return info.type == shaka.media.MediaSourceEngine.ResetMode_.RESET;
   }
 
   /**
@@ -2619,6 +2630,17 @@ shaka.media.MediaSourceEngine.SourceBufferMode_ = {
 };
 
 
+/**
+ * @enum {string}
+ * @private
+ */
+shaka.media.MediaSourceEngine.ResetMode_ = {
+  NONE: 'none',
+  RESET: 'reset',
+  CHANGE_TYPE: 'changeType',
+};
+
+
 /**
  * @typedef {{
  *   getKeySystem: function():?string,