feat: Add codec selection mechanism.

Determine the preferred codec for a given endpoint based on the config.js settings and the codecs supported by the endpoint.
The preferred codec is published in presence and then used by the other endpoints in the call during join/leave to determine
if the codec needs to be changed on the fly. Different codecs can be configuered for p2p/jvb connections.
The preferredCodec/disabledCodec settings under videoQuality will have precedence over the older settins like preferH264/disableH264.

JitsiConference.js

 import * as JitsiTrackErrors from './JitsiTrackErrors';
 import * as JitsiTrackEvents from './JitsiTrackEvents';
 import authenticateAndUpgradeRole from './authenticateAndUpgradeRole';
+import { CodecSelection } from './modules/RTC/CodecSelection';
 import RTC from './modules/RTC/RTC';
 import browser from './modules/browser';
 import ConnectionQuality from './modules/connectivity/ConnectionQuality';
     FEATURE_JIGASI,
     JITSI_MEET_MUC_TYPE
 } from './modules/xmpp/xmpp';
+import CodecMimeType from './service/RTC/CodecMimeType';
 import * as MediaType from './service/RTC/MediaType';
 import VideoType from './service/RTC/VideoType';
 import {
 
     const { config } = this.options;
 
+    // Get the codec preference settings from config.js.
+    // 'preferH264' and 'disableH264' settings have been deprecated for a while,
+    // 'preferredCodec' and 'disabledCodec' will have precedence over them.
+    const codecSettings = {
+        disabledCodec: config.videoQuality
+            ? config.videoQuality.disabledCodec
+            : config.p2p && config.p2p.disableH264 && CodecMimeType.H264,
+        enforcePreferredCodec: config.videoQuality && config.videoQuality.enforcePreferredCodec,
+        jvbCodec: (config.videoQuality && config.videoQuality.preferredCodec)
+            || (config.preferH264 && CodecMimeType.H264),
+        p2pCodec: config.p2p
+            ? config.p2p.preferredCodec || (config.p2p.preferH264 && CodecMimeType.H264)
+            : CodecMimeType.VP8
+    };
+
+    this.codecSelection = new CodecSelection(this, codecSettings);
     this._statsCurrentId = config.statisticsId ? config.statisticsId : Settings.callStatsUserName;
     this.room = this.xmpp.createRoom(
         this.options.name, {
             ...config,
+            preferredCodec: this.codecSelection.getPreferredCodec(),
             statsId: this._statsCurrentId
         },
         JitsiConference.resourceCreator

modules/RTC/CodecSelection.js

+
+import { getLogger } from 'jitsi-meet-logger';
+
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import CodecMimeType from '../../service/RTC/CodecMimeType';
+import * as MediaType from '../../service/RTC/MediaType';
+import browser from '../browser';
+
+const logger = getLogger(__filename);
+
+/**
+ * This class handles the codec selection mechanism for the conference based on the config.js settings.
+ * The preferred codec is selected based on the settings and the list of codecs supported by the browser.
+ * The preferred codec is published in presence which is then used by the other endpoints in the
+ * conference to pick a supported codec at join time and when the call transitions between p2p and jvb
+ * connections.
+ */
+export class CodecSelection {
+    /**
+     * Creates a new instance for a given conference.
+     *
+     * @param {JitsiConference} conference the conference instance
+     * @param {*} options
+     * @param {string} options.disabledCodec the codec that needs to be disabled.
+     * @param {boolean} options.enforcePreferredCodec whether codec preference has to be
+     * enforced even when an endpoints that doesn't support the preferred codec joins the call.
+     * Falling back to the standard codec will be skipped when this option is true, endpoints
+     * that do not support the preferred codec may not be able to encode/decode video when this happens.
+     * @param {string} options.jvbCodec the codec that is preferred on jvb connection.
+     * @param {string} options.p2pCodec the codec that is preferred on p2p connection.
+     */
+    constructor(conference, options) {
+        this.conference = conference;
+
+        // VP8 cannot be disabled and it will be the default codec when no preference is set.
+        this.disabledCodec = options.disabledCodec === CodecMimeType.VP8
+            ? undefined
+            : this._getCodecMimeType(options.disabledCodec);
+
+        // Check if the codec values passed are valid.
+        const jvbCodec = this._getCodecMimeType(options.jvbCodec);
+        const p2pCodec = this._getCodecMimeType(options.p2pCodec);
+
+        this.jvbPreferredCodec = jvbCodec && this._isCodecSupported(jvbCodec) ? jvbCodec : CodecMimeType.VP8;
+        this.p2pPreferredCodec = p2pCodec && this._isCodecSupported(p2pCodec) ? p2pCodec : CodecMimeType.VP8;
+        this.enforcePreferredCodec = options.enforcePreferredCodec;
+
+        // Do not prefer VP9 on Firefox because of the following bug.
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1633876
+        if (browser.isFirefox() && this.jvbPreferredCodec === CodecMimeType.VP9) {
+            this.jvbPreferredCodec = CodecMimeType.VP8;
+        }
+
+        // Keep a list of participants that join the call with a non-preferred codec.
+        // The call is upgraded to the preferred codec once that list is empty.
+        this.nonPreferredParticipants = [];
+
+        this.conference.on(
+            JitsiConferenceEvents.USER_JOINED,
+            this._onParticipantJoined.bind(this));
+        this.conference.on(
+            JitsiConferenceEvents.USER_LEFT,
+            this._onParticipantLeft.bind(this));
+        this.conference.on(
+            JitsiConferenceEvents._MEDIA_SESSION_STARTED,
+            session => this._onMediaSessionStared(session));
+    }
+
+    /**
+     * Checks if a given string is a valid video codec mime type.
+     *
+     * @param {string} codec the codec string that needs to be validated.
+     * @returns {CodecMimeType|null} mime type if valid, null otherwise.
+     * @private
+     */
+    _getCodecMimeType(codec) {
+        if (typeof codec === 'string') {
+            return Object.values(CodecMimeType).find(value => value === codec.toLowerCase());
+        }
+
+        return null;
+    }
+
+    /**
+     * Checks if the given codec is supported by the browser.
+     *
+     * @param {CodecMimeType} preferredCodec codec to be checked.
+     * @returns {boolean} true if the given codec is supported, false otherwise.
+     * @private
+     */
+    _isCodecSupported(preferredCodec) {
+        // Skip the check on FF and RN because they do not support the getCapabilities API.
+        // It is safe to assume both of them support all the codecs supported by Chrome.
+        if (browser.isFirefox() || browser.isReactNative()) {
+            return true;
+        }
+
+        return window.RTCRtpReceiver
+            && window.RTCRtpReceiver.getCapabilities('video').codecs
+            .some(codec => codec.mimeType.toLowerCase() === `video/${preferredCodec}`);
+    }
+
+    /**
+     * Handles the {@link JitsiConferenceEvents._MEDIA_SESSION_STARTED} event. Codecs need to be
+     * configured on the media session that is newly created.
+     *
+     * @param {JingleSessionPC} mediaSession media session that started.
+     * @returns {void}
+     * @private
+     */
+    _onMediaSessionStared(mediaSession) {
+        const preferredCodec = mediaSession.isP2P ? this.p2pPreferredCodec : this.jvbPreferredCodec;
+        const disabledCodec = this.disabledCodec && this._isCodecSupported(this.disabledCodec)
+            ? this.disabledCodec
+            : null;
+
+        mediaSession.setVideoCodecs(preferredCodec, disabledCodec);
+    }
+
+    /**
+     * Handles the {@link JitsiConferenceEvents.USER_JOINED} event. When a new user joins the call,
+     * the codec types are compared and the codec configued on the peerconnection is updated when
+     * needed.
+     *
+     * @param {string} id endpoint id of the newly joined user.
+     * @returns {void}
+     * @private
+     */
+    _onParticipantJoined(id) {
+        const session = this.conference.jvbJingleSession;
+
+        if (session && !this.enforcePreferredCodec) {
+            const peerMediaInfo = session.signalingLayer.getPeerMediaInfo(id, MediaType.VIDEO);
+
+            if (peerMediaInfo) {
+                const newCodec = peerMediaInfo.codecType;
+                const currentCodec = session.getConfiguredVideoCodec();
+
+                // Add the participant to the list of participants that
+                // don't support the preferred codec.
+                if (newCodec !== this.jvbPreferredCodec) {
+                    this.nonPreferredParticipants.push(id);
+                }
+                logger.warn(`Current: ${currentCodec}, new: ${newCodec}`);
+                if (newCodec
+                    && newCodec !== this.jvbPreferredCodec
+                    && newCodec !== currentCodec
+                    && this._isCodecSupported(newCodec)) {
+                    session.setVideoCodecs(newCodec);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handles the {@link JitsiConferenceEvents.USER_LEFT} event. When a user leaves the call,
+     * the codec configured on the peerconnection is updated to the preferred codec if all the
+     * users that do not support the preferred codec have left the call.
+     *
+     * @param {string} id endpoint id of the user that has left the call.
+     * @returns {void}
+     * @private
+     */
+    _onParticipantLeft(id) {
+        const session = this.conference.jvbJingleSession;
+
+        if (session && !this.enforcePreferredCodec) {
+            const index = this.nonPreferredParticipants.findIndex(participantId => participantId === id);
+
+            if (index > -1) {
+                this.nonPreferredParticipants.splice(index, 1);
+            }
+
+            // If all the participants that have joined the conference with a
+            // non-preferred codec have left, switch to the preferred codec.
+            if (!this.nonPreferredParticipants.length) {
+                session.setVideoCodecs(this.jvbPreferredCodec);
+            }
+        }
+    }
+
+    /**
+     * Returns the preferred codec for the conference.
+     *
+     * @returns {CodecMimeType} preferred codec.
+     */
+    getPreferredCodec() {
+        return this.conference.isP2PActive() ? this.p2pPreferredCodec : this.jvbPreferredCodec;
+    }
+}

modules/RTC/TraceablePeerConnection.js

      */
     this.senderVideoMaxHeight = null;
 
-    // We currently support preferring/disabling video codecs only.
-    const getCodecMimeType = codec => {
-        if (typeof codec === 'string') {
-            return Object.values(CodecMimeType).find(value => value === codec.toLowerCase());
-        }
-
-        return null;
-    };
-
-    // Set the codec preference that will be applied on the SDP based on the config.js settings.
-    let preferredCodec = getCodecMimeType(
-        this.options.preferredCodec || (this.options.preferH264 && CodecMimeType.H264)
-    );
-
-    // Do not prefer VP9 on Firefox because of the following bug.
-    // https://bugzilla.mozilla.org/show_bug.cgi?id=1633876
-    if (browser.isFirefox() && preferredCodec === CodecMimeType.VP9) {
-        preferredCodec = null;
-    }
-
-    // Determine the codec that needs to be disabled based on config.js settings.
-    let disabledCodec = getCodecMimeType(
-        this.options.disabledCodec || (this.options.disableH264 && CodecMimeType.H264)
-    );
-
-    // Make sure we don't disable VP8 since it is a mandatory codec.
-    if (disabledCodec === CodecMimeType.VP8) {
-        logger.warn('Disabling VP8 is not permitted, setting is ignored!');
-        disabledCodec = null;
-    }
-
-    if (preferredCodec || disabledCodec) {
-        // If both enable and disable are set for the same codec, disable setting will prevail.
-        this.codecPreference = {
-            enable: disabledCodec === null,
-            mediaType: MediaType.VIDEO,
-            mimeType: disabledCodec ? disabledCodec : preferredCodec
-        };
-    }
-
     // override as desired
     this.trace = (what, info) => {
         logger.debug(what, info);
     return doesBelong;
 };
 
+/**
+ * Returns the codec that is configured on the client as the preferred video codec.
+ * This takes into account the current order of codecs in the local description sdp.
+ *
+ * @returns {CodecMimeType} The codec that is set as the preferred codec to receive
+ * video in the local SDP.
+ */
+TraceablePeerConnection.prototype.getConfiguredVideoCodec = function() {
+    const sdp = this.localDescription.sdp;
+    const parsedSdp = transform.parse(sdp);
+    const mLine = parsedSdp.media.find(m => m.type === MediaType.VIDEO);
+    const codec = mLine.rtp[0].codec;
+
+    if (codec) {
+        return Object.values(CodecMimeType).find(value => value === codec.toLowerCase());
+    }
+
+    return CodecMimeType.VP8;
+};
+
+/**
+ * Sets the codec preference on the peerconnection. The codec preference goes into effect when
+ * the next renegotiation happens.
+ *
+ * @param {CodecMimeType} preferredCodec the preferred codec.
+ * @param {CodecMimeType} disabledCodec the codec that needs to be disabled.
+ * @returns {void}
+ */
+TraceablePeerConnection.prototype.setVideoCodecs = function(preferredCodec = null, disabledCodec = null) {
+    // If both enable and disable are set, disable settings will prevail.
+    const enable = disabledCodec === null;
+    const mimeType = disabledCodec ? disabledCodec : preferredCodec;
+
+    if (this.codecPreference && (preferredCodec || disabledCodec)) {
+        this.codecPreference.enable = enable;
+        this.codecPreference.mimeType = mimeType;
+    } else if (preferredCodec || disabledCodec) {
+        this.codecPreference = {
+            enable,
+            mediaType: MediaType.VIDEO,
+            mimeType
+        };
+    } else {
+        logger.warn(`Invalid codec settings: preferred ${preferredCodec}, disabled ${disabledCodec},
+            atleast one value is needed`);
+    }
+
+    if (browser.supportsCodecPreferences()) {
+        // TODO implement codec preference using RTCRtpTransceiver.setCodecPreferences()
+        // We are using SDP munging for now until all browsers support this.
+    }
+};
+
 /**
  * Tells if the given WebRTC <tt>MediaStream</tt> has been added to
  * the underlying WebRTC PeerConnection.

modules/xmpp/ChatRoom.js

         // here.
         this.addVideoInfoToPresence(false);
 
+        // Set the default codec.
+        this.addCodecInfoToPresence(this.options.preferredCodec);
+
         if (options.deploymentInfo && options.deploymentInfo.userRegion) {
             this.presMap.nodes.push({
                 'tagName': 'region',
         this.sendPresence();
     }
 
+    /**
+     * Add the codec key to the presence map.
+     *
+     * @param {string} codec - the mime type of the codec that needs to be
+     * published via presence to other users in the conference.
+     *
+     * @returns {void}
+     */
+    addCodecInfoToPresence(codec) {
+        this.addToPresence(
+            'codecType',
+            {
+                attributes: { 'xmlns': 'http://jitsi.org/jitmeet/codec' },
+                value: codec.toString()
+            });
+    }
+
+    /**
+     * Adds the codec key to presence map and sends the presence info
+     * to the room.
+     *
+     * @param {string} codec - the mime type of the codec that needs to be
+     * published via presence to other users in the conference.
+     *
+     * @returns {void}
+     */
+    sendCodecInfoPresence(codec) {
+        this.addCodecInfoToPresence(codec);
+        this.sendPresence();
+    }
+
     /**
      * Obtains the info about given media advertised in the MUC presence of
      * the participant identified by the given endpoint JID.
             mutedNode = filterNodeFromPresenceJSON(pres, 'audiomuted');
         } else if (mediaType === MediaType.VIDEO) {
             mutedNode = filterNodeFromPresenceJSON(pres, 'videomuted');
+            const codecTypeNode = filterNodeFromPresenceJSON(pres, 'codecType');
             const videoTypeNode = filterNodeFromPresenceJSON(pres, 'videoType');
 
             if (videoTypeNode.length > 0) {
                 data.videoType = videoTypeNode[0].value;
             }
+            if (codecTypeNode.length > 0) {
+                data.codecType = codecTypeNode[0].value;
+            }
         } else {
             logger.error(`Unsupported media type: ${mediaType}`);
 

modules/xmpp/JingleSessionPC.js

 import { getLogger } from 'jitsi-meet-logger';
 import { $iq, Strophe } from 'strophe.js';
 
-import CodecMimeType from '../../service/RTC/CodecMimeType';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import {
     ICE_DURATION,
  * @property {boolean} gatherStats - Described in the config.js[1].
  * @property {object} p2p - Peer to peer related options (FIXME those could be
  * fetched from config.p2p on the upper level).
- * @property {boolean} p2p.disableH264 - Described in the config.js[1].
- * @property {boolean} p2p.preferH264 - Described in the config.js[1].
  * @property {boolean} preferH264 - Described in the config.js[1].
  * @property {Object} testing - Testing and/or experimental options.
  * @property {boolean} webrtcIceUdpDisable - Described in the config.js[1].
         pcOptions.videoQuality = options.videoQuality;
         pcOptions.forceTurnRelay = options.forceTurnRelay;
 
-        // codec preference options for jvb connection.
-        if (pcOptions.videoQuality) {
-            pcOptions.disabledCodec = pcOptions.videoQuality.disabledCodec;
-            pcOptions.preferredCodec = pcOptions.videoQuality.preferredCodec;
-        }
-
         if (this.isP2P) {
             // simulcast needs to be disabled for P2P (121) calls
             pcOptions.disableSimulcast = true;
-            pcOptions.disableH264 = options.p2p && options.p2p.disableH264;
-            pcOptions.preferH264 = options.p2p && options.p2p.preferH264;
-
-            // codec preference options for p2p.
-            if (options.p2p) {
-                // Do not negotiate H246 codec when insertable streams is used because of issues like this -
-                // https://bugs.chromium.org/p/webrtc/issues/detail?id=11886
-                pcOptions.disabledCodec = options.enableInsertableStreams
-                    ? CodecMimeType.H264
-                    : options.p2p.disabledCodec;
-                pcOptions.preferredCodec = options.p2p.preferredCodec;
-            }
-
             const abtestSuspendVideo = this._abtestSuspendVideoEnabled(options);
 
             if (typeof abtestSuspendVideo !== 'undefined') {
             pcOptions.disableSimulcast
                 = options.disableSimulcast
                     || (options.preferH264 && !options.disableH264);
-            pcOptions.preferH264 = options.preferH264;
 
             // disable simulcast for screenshare and set the max bitrate to
             // 500Kbps if the testing flag is present in config.js.
         }
     }
 
+    /**
+     *
+     */
+    getConfiguredVideoCodec() {
+        return this.peerconnection.getConfiguredVideoCodec();
+    }
+
     /* eslint-disable max-params */
     /**
      * Accepts incoming Jingle 'session-initiate' and should send
             });
     }
 
+    /**
+     *
+     * @param {*} codec
+     */
+    setVideoCodecs(preferred = null, disabled = null) {
+        const current = this.peerconnection.getConfiguredVideoCodec();
+
+        if (this._assertNotEnded() && preferred !== current) {
+            logger.info(`${this} Switching video codec from ${current} to ${preferred}`);
+            this.peerconnection.setVideoCodecs(preferred, disabled);
+
+            // Initiate a renegotiate for the codec setting to take effect.
+            const workFunction = finishedCallback => {
+                this._renegotiate().then(() => finishedCallback(), error => finishedCallback(error));
+            };
+
+            // Queue and execute
+            this.modificationQueue.push(workFunction);
+        }
+    }
+
     /* eslint-enable max-params */
 
     /**
             sdp: remoteSdp
         });
 
-        if (this.isInitiator) {
-            return this._initiatorRenegotiate(remoteDescription);
-        }
+        const promise = this.isInitiator
+            ? this._initiatorRenegotiate(remoteDescription)
+            : this._responderRenegotiate(remoteDescription);
+
+        return promise.then(() => {
+            // Publish the codec info to the other endpoints in the conference if it has changed
+            // as a result of the renegotiation (only on current active session).
+            const codec = this.peerconnection.getConfiguredVideoCodec();
 
-        return this._responderRenegotiate(remoteDescription);
+            if (this.currentCodec !== codec && this._localVideoActive) {
+                this.room.sendCodecInfoPresence(codec);
+                this.currentCodec = codec;
+            }
+        });
     }
 
     /**