ref(sdp): Add a more generic option for codec preference

Use 'preferredCodec' and 'disabledCodec' under videoQuality config.js settings for setting codec preferences.
Do not prefer VP9 on Firefox because of https://bugzilla.mozilla.org/show_bug.cgi?id=1633876.

modules/RTC/TraceablePeerConnection.js

 import { getLogger } from 'jitsi-meet-logger';
 import transform from 'sdp-transform';
 
+import * as CodecMimeType from '../../service/RTC/CodecMimeType';
 import * as MediaType from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
 import * as SignalingEvents from '../../service/RTC/SignalingEvents';
      */
     this.senderVideoMaxHeight = null;
 
-    // Set the codec preference that will be applied on the SDP
-    // based on the config.js settings.
-    if (this.options.preferH264 || this.options.preferVP9) {
+    // We currently support preferring/disabling video codecs only.
+    const getCodecMimeType
+        = codec => Object.values(CodecMimeType).find(value => value === codec.toLowerCase());
+
+    // Set the codec preference that will be applied on the SDP based on the config.js settings.
+    if (this.options.preferH264 || this.options.preferredCodec) {
+        let prefferedCodec = null;
+
+        // Do not prefer VP9 on Firefox because of the following bug.
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=1633876
+        if (this.options.preferredCodec) {
+            const mimeType = getCodecMimeType(this.options.preferredCodec);
+
+            if (!(browser.isFirefox() && mimeType === CodecMimeType.VP9)) {
+                prefferedCodec = mimeType;
+            }
+        }
+
         this.codecPreference = {
             enable: true,
             mediaType: MediaType.VIDEO,
             mimeType: this.options.preferH264
-                ? 'h264'
-                : 'vp9'
+                ? CodecMimeType.H264
+                : prefferedCodec
         };
     }
 
-    // If both enable and disable are set for the same codec, disable
-    // setting will prevail.
-    if (this.options.disableH264 || this.options.disableVP9) {
+    // If both enable and disable are set for the same codec, disable setting will prevail.
+    if (this.options.disableH264 || this.options.disabledCodec) {
+        let disabledCodec = null;
+
+        // Make sure we don't disable VP8 since it is a mandatory codec.
+        if (this.options.disabledCodec) {
+            const mimeType = getCodecMimeType(this.options.disabledCodec);
+
+            if (mimeType === CodecMimeType.VP8) {
+                logger.warn('Disabling VP8 is not permitted, setting is ignored!');
+            } else {
+                disabledCodec = mimeType;
+            }
+        }
+
         this.codecPreference = {
             enable: false,
             mediaType: MediaType.VIDEO,
             mimeType: this.options.disableH264
-                ? 'h264'
-                : 'vp9'
+                ? CodecMimeType.H264
+                : disabledCodec
         };
     }
 
  * @returns {RTCSessionDescription} the munged description.
  */
 TraceablePeerConnection.prototype._mungeCodecOrder = function(description) {
-    if (!this.codecPreference || browser.supportsCodecPreferences()) {
+    if (!(this.codecPreference && this.codecPreference.mimeType) || browser.supportsCodecPreferences()) {
         return description;
     }
 
     const parsedSdp = transform.parse(description.sdp);
     const mLine = parsedSdp.media.find(m => m.type === this.codecPreference.mediaType);
 
-    if (this.codecPreference.enable && this.codecPreference.mimeType) {
+    if (this.codecPreference.enable) {
         SDPUtil.preferCodec(mLine, this.codecPreference.mimeType);
 
         // Strip the high profile H264 codecs on mobile clients for p2p connection.
         // 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 === 'h264' && browser.isReactNative() && this.isP2P) {
+        if (this.codecPreference.mimeType === CodecMimeType.H264 && browser.isReactNative() && this.isP2P) {
             SDPUtil.stripCodec(mLine, this.codecPreference.mimeType, true /* high profile */);
         }
-    } else if (this.codecPreference.mimeType) {
+    } else {
         SDPUtil.stripCodec(mLine, this.codecPreference.mimeType);
     }
 

modules/xmpp/JingleSessionPC.js

         pcOptions.enableInsertableStreams = options.enableInsertableStreams;
         pcOptions.videoQuality = options.videoQuality;
 
+        // 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;
-            pcOptions.preferVP9 = options.p2p && options.p2p.preferVP9;
+
+            // codec preference options for p2p.
+            if (options.p2p) {
+                pcOptions.disabledCodec = options.p2p.disabledCodec;
+                pcOptions.preferredCodec = options.p2p.preferredCodec;
+            }
 
             const abtestSuspendVideo = this._abtestSuspendVideoEnabled(options);
 
                 = options.disableSimulcast
                     || (options.preferH264 && !options.disableH264);
             pcOptions.preferH264 = options.preferH264;
-            pcOptions.preferVP9 = options.preferVP9;
 
             // disable simulcast for screenshare and set the max bitrate to
             // 500Kbps if the testing flag is present in config.js.

modules/xmpp/SDPUtil.js

 import { getLogger } from 'jitsi-meet-logger';
 const logger = getLogger(__filename);
 
+import CodecMimeType from '../../service/RTC/CodecMimeType';
 import browser from '../browser';
 import RandomUtil from '../util/RandomUtil';
 
      *
      * @param {object} mLine the mline object from an sdp as parsed by transform.parse.
      * @param {string} codecName the name of the codec which will be stripped.
+     * @param {boolean} highProfile determines if only the high profile H264 codec needs to be
+     * stripped from the sdp when the passed codecName is H264.
      */
     stripCodec(mLine, codecName, highProfile = false) {
         if (!mLine || !codecName) {
 
         const h264Pts = [];
         let removePts = [];
-        const stripH264HighCodec = codecName.toLowerCase() === 'h264' && highProfile;
+        const stripH264HighCodec = codecName.toLowerCase() === CodecMimeType.H264 && highProfile;
 
         for (const rtp of mLine.rtp) {
             if (rtp.codec

service/RTC/CodecMimeType.js

+/* global module */
+/**
+ * Enumeration of the codec mime types
+ * @type {{H264: string, VP8: string, VP9: string}}
+ */
+const CodecMimeType = {
+    /**
+     * The h264 codec mime type
+     */
+    H264: 'h264',
+
+    /**
+     * The vp8 codec mime type.
+     */
+    VP8: 'vp8',
+
+    /**
+     * The vp9 codec mime type.
+     */
+    VP9: 'vp9'
+
+};
+
+module.exports = CodecMimeType;