Implement review changes 1

modules/RTC/RTCUtils.js

 // Disables Highpass Filter
 let disableHPF = false;
 
-// Channel count used to enable stereo.
-let channelCount = null;
+// Enables stereo.
+let stereo = null;
 
 const featureDetectionAudioEl = document.createElement('audio');
 const isAudioOutputDeviceChangeAvailable
             constraints.audio = {};
         }
 
-        // Use the standard audio constraints on non-chromium browsers.
-        if (browser.isFirefox() || browser.isWebKitBased()) {
-            constraints.audio = {
-                deviceId: options.micDeviceId,
-                autoGainControl: !disableAGC && !disableAP,
-                echoCancellation: !disableAEC && !disableAP,
-                noiseSuppression: !disableNS && !disableAP
-            };
-        } else {
-            constraints.audio = {
-                autoGainControl: { exact: !disableAGC && !disableAP },
-                channelCount,
-                deviceId: options.micDeviceId,
-                echoCancellation: { exact: !disableAEC && !disableAP },
-                noiseSuppression: { exact: !disableNS && !disableAP },
-                sampleRate: 48000
-            };
+        constraints.audio = {
+            autoGainControl: { exact: !disableAGC && !disableAP },
+            deviceId: options.micDeviceId,
+            echoCancellation: { exact: !disableAEC && !disableAP },
+            noiseSuppression: { exact: !disableNS && !disableAP }
+        };
+
+        if (stereo) {
+            Object.assign(constraints.audio, { channelCount: 2 });
         }
     } else {
         constraints.audio = false;
             disableHPF = options.disableHPF;
             logger.info(`Disable HPF: ${disableHPF}`);
         }
-
-        if (typeof options.channelCount === 'number') {
-            channelCount = options.channelCount;
-            logger.info(`Channel count: ${channelCount}`);
+        if (typeof options.stereo === 'boolean') {
+            stereo = options.stereo;
+            logger.info(`Stereo: ${stereo}`);
         }
 
         window.clearInterval(availableDevicesPollTimer);

modules/RTC/ScreenObtainer.js

             getDisplayMedia = navigator.mediaDevices.getDisplayMedia.bind(navigator.mediaDevices);
         }
 
-        const { channelCount, disableAGC, disableAP, enableHdAudio } = this.options;
+        const { disableAGC, disableAP, enableHdAudio } = this.options;
         const audioProcessingValue = !disableAGC && !disableAP;
         const audio = enableHdAudio ? {
             autoGainControl: audioProcessingValue,
-            channelCount,
+            channelCount: 2,
             echoCancellation: audioProcessingValue,
-            noiseSuppression: audioProcessingValue,
-            sampleRate: 48000
+            noiseSuppression: audioProcessingValue
         } : true;
 
         getDisplayMedia({

modules/RTC/TraceablePeerConnection.js

     return localDescription;
 };
 
-/**
- * Converts an object to a config-like string.
- *
- * @param {Object} obj - The object to be converted into a config string.
- * @returns {String} - The config string.
- */
-TraceablePeerConnection.prototype.getConfigFromObject = function(obj) {
-    let config = '';
-
-    for (const key of Object.keys(obj)) {
-        config += `${key}=${obj[key]}; `;
-    }
-
-    return config.trim();
-};
-
 /**
  * Munges the stereo flag as well as the opusMaxAverageBitrate in the SDP, based
  * on values set through config.js, if present.
  * @param {RTCSessionDescription} description that needs to be munged.
  * @returns {RTCSessionDescription} the munged description.
  */
-TraceablePeerConnection.prototype.mungeOpus = function(description) {
+TraceablePeerConnection.prototype._mungeOpus = function(description) {
     const parsedSdp = transform.parse(description.sdp);
-    const audio = parsedSdp.media.find(mLine => mLine.type === 'audio');
-    const { payload } = audio.rtp.find(protocol => protocol.codec === 'opus');
+    const mLines = parsedSdp.media;
 
-    if (!payload) {
-        // No Opus.
-        return description;
-    }
+    for (const mLine of mLines) {
+        if (mLine.type === 'audio') {
+            const { payload } = mLine.rtp.find(protocol => protocol.codec === 'opus');
 
-    let fmtpOpus = audio.fmtp.find(protocol => protocol.payload === payload);
+            if (!payload) {
+                break;
+            }
 
-    if (!fmtpOpus) {
-        fmtpOpus = {
-            payload,
-            config: ''
-        };
-    }
+            let fmtpOpus = mLine.fmtp.find(protocol => protocol.payload === payload);
+
+            if (!fmtpOpus) {
+                fmtpOpus = {
+                    payload,
+                    config: ''
+                };
+            }
 
-    const fmtpConfig = transform.parseParams(fmtpOpus.config);
-    let sdpChanged = false;
+            const fmtpConfig = transform.parseParams(fmtpOpus.config);
+            let sdpChanged = false;
 
-    if (this.options.stereo) {
-        fmtpConfig.stereo = 1;
-        sdpChanged = true;
-    }
+            if (this.options.stereo) {
+                fmtpConfig.stereo = 1;
+                sdpChanged = true;
+            }
 
-    if (this.options.opusMaxAverageBitrate) {
-        fmtpConfig.opusMaxAverageBitrate = this.options.opusMaxAverageBitrate;
-        sdpChanged = true;
-    }
+            if (this.options.opusMaxAverageBitrate) {
+                fmtpConfig.opusMaxAverageBitrate = this.options.opusMaxAverageBitrate;
+                sdpChanged = true;
+            }
 
-    if (!sdpChanged) {
-        return description;
-    }
+            if (!sdpChanged) {
+                break;
+            }
 
-    fmtpOpus.config = this.getConfigFromObject(fmtpConfig);
+            let mungedConfig = '';
+
+            for (const key of Object.keys(fmtpConfig)) {
+                mungedConfig += `${key}=${fmtpConfig[key]}; `;
+            }
+
+            fmtpOpus.config = mungedConfig.trim();
+        }
+    }
 
     return new RTCSessionDescription({
         type: description.type,
     localSdp = this._mungeCodecOrder(localSdp);
 
     // Munge stereo flag and opusMaxAverageBitrate based on config.js
-    localSdp = this.mungeOpus(localSdp);
+    localSdp = this._mungeOpus(localSdp);
 
     if (browser.usesPlanB()) {
         localSdp = this._adjustLocalMediaDirection(localSdp);
     description = this._mungeCodecOrder(description);
 
     // Munge stereo flag and opusMaxAverageBitrate based on config.js
-    description = this.mungeOpus(description);
+    description = this._mungeOpus(description);
 
     /* eslint-enable no-param-reassign */