fix(codec-selection): Fix VP9 codec switching issue in Chrome unified-plan.

Munge only the m-line that corresponds to the source that the browser will be sending.
Do not select VP9 on Firefox.
Detect support for RTCRtpTransceiver#setCodecPreferences correctly.

modules/RTC/CodecSelection.js

      */
     _selectPreferredCodec(mediaSession = null, preferredCodec = null, disabledCodec = null) {
         const session = mediaSession ? mediaSession : this.conference.jvbJingleSession;
-        const codec = preferredCodec ? preferredCodec : this.jvbPreferredCodec;
-        let selectedCodec = codec;
+        const currentCodec = preferredCodec ? preferredCodec : this.jvbPreferredCodec;
+        let selectedCodec = currentCodec;
 
         if (session && !session.isP2P && !this.options.enforcePreferredCodec) {
             const remoteParticipants = this.conference.getParticipants().map(participant => participant.getId());
 
             for (const remote of remoteParticipants) {
                 const peerMediaInfo = session.signalingLayer.getPeerMediaInfo(remote, MediaType.VIDEO);
-
-                if (peerMediaInfo && peerMediaInfo.codecType && peerMediaInfo.codecType !== codec) {
-                    selectedCodec = peerMediaInfo.codecType;
+                const peerCodec = peerMediaInfo?.codecType;
+
+                // We do not want Firefox to switch to VP9 because of the following bug.
+                // https://bugzilla.mozilla.org/show_bug.cgi?id=1492500.
+                if (peerCodec
+                    && peerCodec !== currentCodec
+                    && !(browser.isFirefox() && peerCodec === CodecMimeType.VP9)) {
+                    selectedCodec = peerCodec;
                 }
             }
         }

modules/RTC/TraceablePeerConnection.js

  * @returns {RTCSessionDescription} the munged description.
  */
 TraceablePeerConnection.prototype._mungeCodecOrder = function(description) {
-    if (!this.codecPreference || this._usesTransceiverCodecPreferences) {
+    if (!this.codecPreference) {
         return description;
     }
 
     const parsedSdp = transform.parse(description.sdp);
 
-    for (const mLine of parsedSdp.media) {
-        if (this.codecPreference.enable && mLine.type === this.codecPreference.mediaType) {
-            SDPUtil.preferCodec(mLine, this.codecPreference.mimeType);
-
-            // Strip the high profile H264 codecs on mobile clients for p2p connection.
-            // High profile codecs give better quality at the expense of higher load which
-            // we do not want on mobile clients.
-            // Jicofo offers only the baseline code for the jvb connection.
-            // TODO - add check for mobile browsers once js-utils provides that check.
-            if (this.codecPreference.mimeType === CodecMimeType.H264 && browser.isReactNative() && this.isP2P) {
-                SDPUtil.stripCodec(mLine, this.codecPreference.mimeType, true /* high profile */);
-            }
+    // Only the m-line that defines the source the browser will be sending should need to change.
+    // This is typically the first m-line with the matching media type.
+    const mLine = parsedSdp.media.find(m => m.type === this.codecPreference.mediaType);
 
-            // Set the max bitrate here on the SDP so that the configured max. bitrate is effective
-            // as soon as the browser switches to VP9.
-            if (this.codecPreference.mimeType === CodecMimeType.VP9) {
-                const bitrates = this.videoBitrates.VP9 || this.videoBitrates;
-                const hdBitrate = bitrates.high ? bitrates.high : HD_BITRATE;
-                const limit = Math.floor((this._isSharingScreen() ? HD_BITRATE : hdBitrate) / 1000);
-
-                // Use only the HD bitrate for now as there is no API available yet for configuring
-                // the bitrates on the individual SVC layers.
-                mLine.bandwidth = [ {
-                    type: 'AS',
-                    limit
-                } ];
-            } else {
-                // Clear the bandwidth limit in SDP when VP9 is no longer the preferred codec.
-                // This is needed on react native clients as react-native-webrtc returns the
-                // SDP that the application passed instead of returning the SDP off the native side.
-                // This line automatically gets cleared on web on every renegotiation.
-                mLine.bandwidth = undefined;
-            }
-        } else if (mLine.type === this.codecPreference.mediaType) {
-            SDPUtil.stripCodec(mLine, this.codecPreference.mimeType);
+    if (!mLine) {
+        return description;
+    }
+
+    if (this.codecPreference.enable) {
+        SDPUtil.preferCodec(mLine, this.codecPreference.mimeType);
+
+        // Strip the high profile H264 codecs on mobile clients for p2p connection.
+        // High profile codecs give better quality at the expense of higher load which
+        // we do not want on mobile clients.
+        // Jicofo offers only the baseline code for the jvb connection.
+        // TODO - add check for mobile browsers once js-utils provides that check.
+        if (this.codecPreference.mimeType === CodecMimeType.H264 && browser.isReactNative() && this.isP2P) {
+            SDPUtil.stripCodec(mLine, this.codecPreference.mimeType, true /* high profile */);
+        }
+
+        // Set the max bitrate here on the SDP so that the configured max. bitrate is effective
+        // as soon as the browser switches to VP9.
+        if (this.codecPreference.mimeType === CodecMimeType.VP9) {
+            const bitrates = this.videoBitrates.VP9 || this.videoBitrates;
+            const hdBitrate = bitrates.high ? bitrates.high : HD_BITRATE;
+            const limit = Math.floor((this._isSharingScreen() ? HD_BITRATE : hdBitrate) / 1000);
+
+            // Use only the HD bitrate for now as there is no API available yet for configuring
+            // the bitrates on the individual SVC layers.
+            mLine.bandwidth = [ {
+                type: 'AS',
+                limit
+            } ];
+        } else {
+            // Clear the bandwidth limit in SDP when VP9 is no longer the preferred codec.
+            // This is needed on react native clients as react-native-webrtc returns the
+            // SDP that the application passed instead of returning the SDP off the native side.
+            // This line automatically gets cleared on web on every renegotiation.
+            mLine.bandwidth = undefined;
         }
+    } else {
+        SDPUtil.stripCodec(mLine, this.codecPreference.mimeType);
     }
 
     return new RTCSessionDescription({
 
     this.trace('setLocalDescription::preTransform', dumpSDP(localSdp));
 
-    // Munge the order of the codecs based on the preferences set through config.js
-    localSdp = this._mungeCodecOrder(localSdp);
-
     // Munge stereo flag and opusMaxAverageBitrate based on config.js
     localSdp = this._mungeOpus(localSdp);
 
             dumpSDP(localSdp));
     }
 
+    // Munge the order of the codecs based on the preferences set through config.js if we are using SDP munging.
+    if (!this._usesTransceiverCodecPreferences) {
+        localSdp = this._mungeCodecOrder(localSdp);
+    }
+
     return new Promise((resolve, reject) => {
         this.peerconnection.setLocalDescription(localSdp)
             .then(() => {
     this.trace('setRemoteDescription::preTransform', dumpSDP(description));
 
     /* eslint-disable no-param-reassign */
-
-    // Munge the order of the codecs based on the preferences set through config.js
-    description = this._mungeCodecOrder(description);
-
     // Munge stereo flag and opusMaxAverageBitrate based on config.js
     description = this._mungeOpus(description);
 
         }
     }
 
+    // Munge the order of the codecs based on the preferences set through config.js.
+    // eslint-disable-next-line no-param-reassign
+    description = this._mungeCodecOrder(description);
+
     if (this._usesUnifiedPlan) {
         // eslint-disable-next-line no-param-reassign
         description = this.tpcUtils.ensureCorrectOrderOfSsrcs(description);

modules/browser/BrowserCapabilities.js

      */
     supportsCodecPreferences() {
         return Boolean(window.RTCRtpTransceiver
-            && typeof window.RTCRtpTransceiver.setCodecPreferences !== 'undefined'
+            && 'setCodecPreferences' in window.RTCRtpTransceiver.prototype
             && window.RTCRtpReceiver
             && typeof window.RTCRtpReceiver.getCapabilities !== 'undefined')