feat(HDAudio): Initial implementation.

modules/RTC/RTCUtils.js

 // Disables Highpass Filter
 let disableHPF = false;
 
+// Channel count used to enable stereo.
+let channelCount = null;
+
 const featureDetectionAudioEl = document.createElement('audio');
 const isAudioOutputDeviceChangeAvailable
     = typeof featureDetectionAudioEl.setSinkId !== 'undefined';
                 noiseSuppression: !disableNS && !disableAP
             };
         } else {
-            // NOTE(brian): the new-style ('advanced' instead of 'optional')
-            // doesn't seem to carry through the googXXX constraints
-            // Changing back to 'optional' here (even with video using
-            // the 'advanced' style) allows them to be passed through
-            // but also requires the device id to capture to be set in optional
-            // as sourceId otherwise the constraints are considered malformed.
-            if (!constraints.audio.optional) {
-                constraints.audio.optional = [];
-            }
-            constraints.audio.optional.push(
-                { sourceId: options.micDeviceId },
-                { echoCancellation: !disableAEC && !disableAP },
-                { googEchoCancellation: !disableAEC && !disableAP },
-                { googAutoGainControl: !disableAGC && !disableAP },
-                { googNoiseSuppression: !disableNS && !disableAP },
-                { googHighpassFilter: !disableHPF && !disableAP },
-                { googNoiseSuppression2: !disableNS && !disableAP },
-                { googEchoCancellation2: !disableAEC && !disableAP },
-                { googAutoGainControl2: !disableAGC && !disableAP }
-            );
+            constraints.audio = {
+                autoGainControl: { exact: !disableAGC && !disableAP },
+                channelCount,
+                deviceId: options.micDeviceId,
+                echoCancellation: { exact: !disableAEC && !disableAP },
+                noiseSuppression: { exact: !disableNS && !disableAP },
+                sampleRate: 48000
+            };
         }
     } else {
         constraints.audio = false;
             logger.info(`Disable HPF: ${disableHPF}`);
         }
 
+        if (typeof options.channelCount === 'number') {
+            channelCount = options.channelCount;
+            logger.info(`Channel count: ${channelCount}`);
+        }
+
         window.clearInterval(availableDevicesPollTimer);
         availableDevicesPollTimer = undefined;
 

modules/RTC/ScreenObtainer.js

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

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) {
+    const parsedSdp = transform.parse(description.sdp);
+    const audio = parsedSdp.media.find(mLine => mLine.type === 'audio');
+    const { payload } = audio.rtp.find(protocol => protocol.codec === 'opus');
+
+    if (!payload) {
+        // No Opus.
+        return description;
+    }
+
+    let fmtpOpus = audio.fmtp.find(protocol => protocol.payload === payload);
+
+    if (!fmtpOpus) {
+        fmtpOpus = {
+            payload,
+            config: ''
+        };
+    }
+
+    const fmtpConfig = transform.parseParams(fmtpOpus.config);
+    let sdpChanged = false;
+
+    if (this.options.stereo) {
+        fmtpConfig.stereo = 1;
+        sdpChanged = true;
+    }
+
+    if (this.options.opusMaxAverageBitrate) {
+        fmtpConfig.opusMaxAverageBitrate = this.options.opusMaxAverageBitrate;
+        sdpChanged = true;
+    }
+
+    if (!sdpChanged) {
+        return description;
+    }
+
+    fmtpOpus.config = this.getConfigFromObject(fmtpConfig);
+
+    return new RTCSessionDescription({
+        type: description.type,
+        sdp: transform.write(parsedSdp)
+    });
+};
+
 TraceablePeerConnection.prototype.setLocalDescription = function(description) {
     let localSdp = description;
 
     // 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);
+
     if (browser.usesPlanB()) {
         localSdp = this._adjustLocalMediaDirection(localSdp);
         localSdp = this._ensureSimulcastGroupIsLast(localSdp);
 TraceablePeerConnection.prototype.setRemoteDescription = function(description) {
     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
-    // eslint-disable-next-line no-param-reassign
     description = this._mungeCodecOrder(description);
 
+    // Munge stereo flag and opusMaxAverageBitrate based on config.js
+    description = this.mungeOpus(description);
+
+    /* eslint-enable no-param-reassign */
+
     if (browser.usesPlanB()) {
         // TODO the focus should squeze or explode the remote simulcast
         if (this.isSimulcastOn()) {

modules/xmpp/JingleSessionPC.js

         pcOptions.enableInsertableStreams = options.enableInsertableStreams;
         pcOptions.videoQuality = options.videoQuality;
         pcOptions.forceTurnRelay = options.forceTurnRelay;
+        pcOptions.stereo = options.stereo;
+        pcOptions.opusMaxAverageBitrate = options.opusMaxAverageBitrate;
 
         if (this.isP2P) {
             // simulcast needs to be disabled for P2P (121) calls

modules/xmpp/moderator.js

             }).up();
     }
 
-    if (config.opusMaxAverageBitrate) {
-        elem.c(
-            'property', {
-                name: 'opusMaxAverageBitrate',
-                value: config.opusMaxAverageBitrate
-            }).up();
-    }
     if (this.options.conference.startAudioMuted !== undefined) {
         elem.c(
             'property', {
                 value: this.options.conference.startVideoMuted
             }).up();
     }
-    if (this.options.conference.stereo !== undefined) {
-        elem.c(
-            'property', {
-                name: 'stereo',
-                value: this.options.conference.stereo
-            }).up();
-    }
     elem.up();
 
     return elem;