edge: add ORTC based WebRTC shim for full Edge support

modules/RTC/RTC.js

@@ -554,13 +554,21 @@ export default class RTC extends Listenable {
     }
 
     /**
-     *
-     * @param stream
+     * Returns the id of the given stream.
+     * @param {MediaStream} stream
      */
     static getStreamID(stream) {
         return RTCUtils.getStreamID(stream);
     }
 
+    /**
+     * Returns the id of the given track.
+     * @param {MediaStreamTrack} track
+     */
+    static getTrackID(track) {
+        return RTCUtils.getTrackID(track);
+    }
+
     /**
      * Returns true if retrieving the the list of input devices is supported
      * and false if not.

modules/RTC/RTCBrowserType.js

@@ -34,7 +34,7 @@ const RTCBrowserType = {
      * strategy or <tt>false</tt> otherwise.
      */
     doesVideoMuteByStreamRemove() {
-        return !RTCBrowserType.isFirefox();
+        return !(RTCBrowserType.isFirefox() || RTCBrowserType.isEdge());
     },
 
     /**
@@ -129,7 +129,7 @@ const RTCBrowserType = {
      * otherwise.
      */
     isP2PSupported() {
-        return true;
+        return !RTCBrowserType.isEdge();
     },
 
     /**
@@ -215,7 +215,7 @@ const RTCBrowserType = {
     supportsBandwidthStatistics() {
         // FIXME bandwidth stats are currently not implemented for FF on our
         // side, but not sure if not possible ?
-        return !RTCBrowserType.isFirefox();
+        return !RTCBrowserType.isFirefox() && !RTCBrowserType.isEdge();
     },
 
     /**
@@ -241,7 +241,7 @@ const RTCBrowserType = {
         // (is reported as 1):
         // https://bugzilla.mozilla.org/show_bug.cgi?id=1241066
         // For Chrome and others we rely on 'googRtt'.
-        return !RTCBrowserType.isFirefox();
+        return !RTCBrowserType.isFirefox() && !RTCBrowserType.isEdge();
     },
 
     /**

modules/RTC/RTCUtils.js

@@ -29,9 +29,6 @@ import VideoType from '../../service/RTC/VideoType';
 
 const logger = getLogger(__filename);
 
-// Disable Edge until fully implemented.
-const ENABLE_EDGE = false;
-
 // XXX Don't require Temasys unless it's to be used because it doesn't run on
 // React Native, for example.
 const AdapterJS
@@ -121,10 +118,10 @@ function setResolutionConstraints(
     if (Resolutions[resolution]) {
         if (isNewStyleConstraintsSupported) {
             constraints.video.width = {
-                exact: Resolutions[resolution].width
+                ideal: Resolutions[resolution].width
             };
             constraints.video.height = {
-                exact: Resolutions[resolution].height
+                ideal: Resolutions[resolution].height
             };
         }
 
@@ -794,6 +791,9 @@ class RTCUtils extends Listenable {
 
                     return SDPUtil.filterSpecialChars(id);
                 };
+                this.getTrackID = function(track) {
+                    return track.id;
+                };
 
                 /* eslint-disable no-global-assign, no-native-reassign */
                 RTCSessionDescription = mozRTCSessionDescription;
@@ -844,6 +844,9 @@ class RTCUtils extends Listenable {
                             ? id
                             : SDPUtil.filterSpecialChars(id));
                 };
+                this.getTrackID = function(track) {
+                    return track.id;
+                };
 
                 this.pcConstraints = { optional: [] };
 
@@ -870,14 +873,6 @@ class RTCUtils extends Listenable {
                     };
                 }
             } else if (RTCBrowserType.isEdge()) {
-                // Disable until fully implemented.
-                if (!ENABLE_EDGE) {
-                    rejectWithWebRTCNotSupported(
-                        'Microsoft Edge not yet supported', reject);
-
-                    return;
-                }
-
                 this.RTCPeerConnectionType = ortcRTCPeerConnection;
                 this.getUserMedia
                     = wrapGetUserMedia(
@@ -895,14 +890,23 @@ class RTCUtils extends Listenable {
                         return element;
                     });
 
-                // TODO: needed in Edge?
+                // ORTC does not generate remote MediaStreams so those are
+                // manually created by the ORTC shim. This means that their
+                // id (internally generated) does not match the stream id
+                // signaled into the remote SDP. Therefore, the shim adds a
+                // custom jitsiRemoteId property with the original stream id.
                 this.getStreamID = function(stream) {
-                    const id = stream.id;
+                    const id = stream.jitsiRemoteId || stream.id;
 
-                    return (
-                        typeof id === 'number'
-                            ? id
-                            : SDPUtil.filterSpecialChars(id));
+                    return SDPUtil.filterSpecialChars(id);
+                };
+
+                // Remote MediaStreamTracks generated by ORTC (within a
+                // RTCRtpReceiver) have an internally/random id which does not
+                // match the track id signaled in the remote SDP. The shim adds
+                // a custom jitsi-id property with the original track id.
+                this.getTrackID = function(track) {
+                    return track.jitsiRemoteId || track.id;
                 };
             } else if (RTCBrowserType.isTemasysPluginUsed()) {
                 // Detect IE/Safari
@@ -942,6 +946,8 @@ class RTCUtils extends Listenable {
                         });
                     this.getStreamID
                         = stream => SDPUtil.filterSpecialChars(stream.label);
+                    this.getTrackID
+                        = track => track.id;
 
                     onReady(
                         options,
@@ -1294,7 +1300,8 @@ class RTCUtils extends Listenable {
                 || RTCBrowserType.isOpera()
                 || RTCBrowserType.isTemasysPluginUsed()
                 || RTCBrowserType.isNWJS()
-                || RTCBrowserType.isElectron();
+                || RTCBrowserType.isElectron()
+                || RTCBrowserType.isEdge();
     }
 
     /**

modules/RTC/TraceablePeerConnection.js

@@ -517,12 +517,12 @@ TraceablePeerConnection.prototype._remoteStreamAdded = function(stream) {
 
     // Bind 'addtrack'/'removetrack' event handlers
     if (RTCBrowserType.isChrome() || RTCBrowserType.isNWJS()
-        || RTCBrowserType.isElectron()) {
+        || RTCBrowserType.isElectron() || RTCBrowserType.isEdge()) {
         stream.onaddtrack = event => {
-            this._remoteTrackAdded(event.target, event.track);
+            this._remoteTrackAdded(stream, event.track);
         };
         stream.onremovetrack = event => {
-            this._remoteTrackRemoved(event.target, event.track);
+            this._remoteTrackRemoved(stream, event.track);
         };
     }
 
@@ -726,7 +726,7 @@ TraceablePeerConnection.prototype._remoteStreamRemoved = function(stream) {
 TraceablePeerConnection.prototype._remoteTrackRemoved
 = function(stream, track) {
     const streamId = RTC.getStreamID(stream);
-    const trackId = track && track.id;
+    const trackId = track && RTC.getTrackID(track);
 
     logger.info(`${this} - remote track removed: ${streamId}, ${trackId}`);
 

modules/RTC/ortc/README.md

@@ -0,0 +1,93 @@
+# ORTC shim for Edge
+
+The `modules/RTC/ortc` folder contains a `RTCPeerConnection` shim for Edge based on ORTC among with other shims (such as `RTCSessionDescription`) and some utilities/helpers to deal with both, SDP and ORTC objects.
+
+
+## Files in `ortc` folder
+
+
+### RTCPeerConnection.js
+
+Exports a `RTCPeerConnection` shim. The interface is based on the [W3C specification of 2015](https://www.w3.org/TR/2015/WD-webrtc-20150210/), which matches (mostly) the current implementation of Chrome.
+
+It also implements Plan-B for multi-stream.
+
+
+#### Limitations
+
+* BUNDLE is assumed (single transport for all the local and remote media streams).
+* `rtcp-mux` is assumed (not a real problem nowadays).
+* Calling `createOffer()` is not implemented, so P2P mode is not supported (`RTCBrowserType.isP2PSupported()` returns `false`).
+* Calling `setRemoteDescription()` with a SDP answer with mangled SSRC values is currently unsupported (those new SSRC values will not be used for sending media).
+* If the app calls `createAnswer()`, mangles SSRC values, and applies by calling `setLocalDescription()`, those new SSRC values are currently ignored.
+* Simulcast not supported (currently Edge supports `maxFramerate` per encoding but it does not support `maxBitrate`, `resolutionScale` or `framerateScale`, so it's not worth it).
+* `RTCDataChannel` not supported (Edge does not implement it).
+* `addIceCandidate()` not supported (it's never called anyway, at least in non P2P mode). Edge does not support Trickle-ICE which means that, after reading all the remote ICE candidates from the remote SDP and applying them, an "empty" candidate must be immediately applied (otherwise the `RTCIceTransport` never enters the "completed" state) and, after that, new remote candidates cannot be added.
+
+
+### RTCSessionDescription.js
+
+Exports a `RTCSessionDescription` shim.
+
+The interface is the same as in the WebRTC specification (although internally it also handles a Object representation of the SDP generated by the [sdp-transform](https://www.npmjs.com/package/sdp-transform) library).
+
+
+### errors.js
+
+Exports some `Error` based classes needed in WebRTC (such as `InvalidStateError`).
+
+
+### utils.js
+
+Some utilities related to SDP and ORTC.
+
+
+## Issues
+
+
+### ICE error: Wrong MESSAGE-INTEGRITY
+
+Randomly, ICE Binding Requests from Edge are replied with WRONG MESSAGE-INTEGRITY error by the bridge. It seems that Edge, sometimes, adds a extra byte in the `USERNAME` attribute producing such an issue.
+
+* GitHub issue: https://github.com/jitsi/lib-jitsi-meet/issues/498
+* Edge issue: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12332457/
+
+
+### Wrong VP8 video from Edge to Chrome if ENABLE_VP8_PICID_REWRITING=True
+
+When VP8 rewriting is enabled in the bridge, VP8 video produced by Edge is wrongly rendered in Chrome/Firefox.
+
+* GitHub issue: https://github.com/jitsi/lib-jitsi-meet/issues/520
+
+
+### InvalidStateError when calling send() / receive()
+
+Randomly, sending a new track or receiving a new track fails with `InvalidStateError`. The issue reported in Edge tracker includes a way to reproduce it.
+
+As per conversations with Edge developers, it seems that Edge has some kind of limitation in the number of VP8 streams it can encode/decode at the same time. However, in my tests I've been able to send a VP8 stream and receive 5 VP8 streams at the same time.
+
+The problem happens much more often when calling `rtpSender.stop()` or `rtpReceiver.stop()` and then creating a new `RtpSender` or `RtpReceiver` and calling `send()` or `receive()` on it.
+
+* GitHub issue: https://github.com/jitsi/lib-jitsi-meet/issues/519
+* Edge issue: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12459320/
+
+
+### pc.getStats(): no way to get usable and needed stats
+
+WebRTC stats produced by Edge don't provide enough information to determine resolution, framerate or bitrate.
+
+* GitHub issue: https://github.com/jitsi/lib-jitsi-meet/issues/523
+
+
+### Device selection does not work
+
+In Edge, the device selector UI shows grayed drop down lists for mic and webcam.
+
+* GitHub issue: https://github.com/jitsi/lib-jitsi-meet/issues/530
+
+
+### Other issues in Edge
+
+Those issues/bugs in Edge do not affect lib-jitsi-meet because the code avoids them. However, for future changes, it's important to consider them:
+
+* `RtpReceiver.track` returns a different `MediaStreamTrack` every time: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12399497/

modules/RTC/ortc/RTCSessionDescription.js

@@ -6,20 +6,20 @@ import sdpTransform from 'sdp-transform';
 export default class RTCSessionDescription {
     /**
      * RTCSessionDescription constructor.
-     * @param {object} [data]
-     * @param {string} [data.type] "offer" / "answer".
-     * @param {string} [data.sdp] SDP string.
-     * @param {object} [data._sdpObject] SDP object generated by the
+     * @param {Object} [data]
+     * @param {String} [data.type] - 'offer' / 'answer'.
+     * @param {String} [data.sdp] - SDP string.
+     * @param {Object} [data._sdpObject] - SDP object generated by the
      * sdp-transform library.
      */
     constructor(data) {
-        // @type {string}
+        // @type {String}
         this._sdp = null;
 
-        // @type {object}
+        // @type {Object}
         this._sdpObject = null;
 
-        // @type {string}
+        // @type {String}
         this._type = null;
 
         switch (data.type) {
@@ -53,27 +53,53 @@ export default class RTCSessionDescription {
     }
 
     /**
-     * Get type field.
-     * @return {string}
+     * Get sdp field.
+     * @return {String}
      */
-    get type() {
-        return this._type;
+    get sdp() {
+        return this._sdp;
     }
 
     /**
-     * Get sdp field.
-     * @return {string}
+     * Set sdp field.
+     * NOTE: This is not allowed per spec, but lib-jitsi-meet uses it.
+     * @param {String} sdp
      */
-    get sdp() {
-        return this._sdp;
+    set sdp(sdp) {
+        try {
+            this._sdpObject = sdpTransform.parse(sdp);
+        } catch (error) {
+            throw new Error(`invalid sdp: ${error}`);
+        }
+
+        this._sdp = sdp;
     }
 
     /**
      * Gets the internal sdp object.
-     * @return {object}
+     * @return {Object}
      * @private
      */
     get sdpObject() {
         return this._sdpObject;
     }
+
+    /**
+     * Get type field.
+     * @return {String}
+     */
+    get type() {
+        return this._type;
+    }
+
+    /**
+     * Returns an object with type and sdp fields.
+     * @return {Object}
+     */
+    toJSON() {
+        return {
+            sdp: this._sdp,
+            type: this._type
+        };
+    }
 }

modules/RTC/ortc/utils.js

@@ -0,0 +1,458 @@
+/* global RTCRtpReceiver */
+
+import sdpTransform from 'sdp-transform';
+
+/**
+ * Extract RTP capabilities from remote description.
+ * @param {Object} sdpObject - Remote SDP object generated by sdp-transform.
+ * @return {RTCRtpCapabilities}
+ */
+export function extractCapabilities(sdpObject) {
+    // Map of RtpCodecParameters indexed by payload type.
+    const codecsMap = new Map();
+
+    // Array of RtpHeaderExtensions.
+    const headerExtensions = [];
+
+    for (const m of sdpObject.media) {
+        // Media kind.
+        const kind = m.type;
+
+        if (kind !== 'audio' && kind !== 'video') {
+            continue; // eslint-disable-line no-continue
+        }
+
+        // Get codecs.
+        for (const rtp of m.rtp) {
+            const codec = {
+                clockRate: rtp.rate,
+                kind,
+                mimeType: `${kind}/${rtp.codec}`,
+                name: rtp.codec,
+                numChannels: rtp.encoding || 1,
+                parameters: {},
+                preferredPayloadType: rtp.payload,
+                rtcpFeedback: []
+            };
+
+            codecsMap.set(codec.preferredPayloadType, codec);
+        }
+
+        // Get codec parameters.
+        for (const fmtp of m.fmtp || []) {
+            const parameters = sdpTransform.parseFmtpConfig(fmtp.config);
+            const codec = codecsMap.get(fmtp.payload);
+
+            if (!codec) {
+                continue; // eslint-disable-line no-continue
+            }
+
+            codec.parameters = parameters;
+        }
+
+        // Get RTCP feedback for each codec.
+        for (const fb of m.rtcpFb || []) {
+            const codec = codecsMap.get(fb.payload);
+
+            if (!codec) {
+                continue; // eslint-disable-line no-continue
+            }
+
+            codec.rtcpFeedback.push({
+                parameter: fb.subtype || '',
+                type: fb.type
+            });
+        }
+
+        // Get RTP header extensions.
+        for (const ext of m.ext || []) {
+            const preferredId = ext.value;
+            const uri = ext.uri;
+            const headerExtension = {
+                kind,
+                uri,
+                preferredId
+            };
+
+            // Check if already present.
+            const duplicated = headerExtensions.find(savedHeaderExtension =>
+                headerExtension.kind === savedHeaderExtension.kind
+                    && headerExtension.uri === savedHeaderExtension.uri
+            );
+
+            if (!duplicated) {
+                headerExtensions.push(headerExtension);
+            }
+        }
+    }
+
+    return {
+        codecs: Array.from(codecsMap.values()),
+        fecMechanisms: [], // TODO
+        headerExtensions
+    };
+}
+
+/**
+ * Extract DTLS parameters from remote description.
+ * @param {Object} sdpObject - Remote SDP object generated by sdp-transform.
+ * @return {RTCDtlsParameters}
+ */
+export function extractDtlsParameters(sdpObject) {
+    const media = getFirstActiveMediaSection(sdpObject);
+    const fingerprint = media.fingerprint || sdpObject.fingerprint;
+    let role;
+
+    switch (media.setup) {
+    case 'active':
+        role = 'client';
+        break;
+    case 'passive':
+        role = 'server';
+        break;
+    case 'actpass':
+        role = 'auto';
+        break;
+    }
+
+    return {
+        role,
+        fingerprints: [
+            {
+                algorithm: fingerprint.type,
+                value: fingerprint.hash
+            }
+        ]
+    };
+}
+
+/**
+ * Extract ICE candidates from remote description.
+ * NOTE: This implementation assumes a single BUNDLEd transport and rtcp-mux.
+ * @param {Object} sdpObject - Remote SDP object generated by sdp-transform.
+ * @return {sequence<RTCIceCandidate>}
+ */
+export function extractIceCandidates(sdpObject) {
+    const media = getFirstActiveMediaSection(sdpObject);
+    const candidates = [];
+
+    for (const c of media.candidates) {
+        // Ignore RTCP candidates (we assume rtcp-mux).
+        if (c.component !== 1) {
+            continue; // eslint-disable-line no-continue
+        }
+
+        const candidate = {
+            foundation: c.foundation,
+            ip: c.ip,
+            port: c.port,
+            priority: c.priority,
+            protocol: c.transport.toLowerCase(),
+            type: c.type
+        };
+
+        candidates.push(candidate);
+    }
+
+    return candidates;
+}
+
+/**
+ * Extract ICE parameters from remote description.
+ * NOTE: This implementation assumes a single BUNDLEd transport.
+ * @param {Object} sdpObject - Remote SDP object generated by sdp-transform.
+ * @return {RTCIceParameters}
+ */
+export function extractIceParameters(sdpObject) {
+    const media = getFirstActiveMediaSection(sdpObject);
+    const usernameFragment = media.iceUfrag;
+    const password = media.icePwd;
+    const icelite = sdpObject.icelite === 'ice-lite';
+
+    return {
+        icelite,
+        password,
+        usernameFragment
+    };
+}
+
+/**
+ * Extract MID values from remote description.
+ * @param {Object} sdpObject - Remote SDP object generated by sdp-transform.
+ * @return {map<String, String>} Ordered Map with MID as key and kind as value.
+ */
+export function extractMids(sdpObject) {
+    const midToKind = new Map();
+
+    // Ignore disabled media sections.
+    for (const m of sdpObject.media) {
+        midToKind.set(m.mid, m.type);
+    }
+
+    return midToKind;
+}
+
+/**
+ * Extract tracks information.
+ * @param {Object} sdpObject - Remote SDP object generated by sdp-transform.
+ * @return {Map}
+ */
+export function extractTrackInfos(sdpObject) {
+    // Map with info about receiving media.
+    // - index: Media SSRC
+    // - value: Object
+    //   - kind: 'audio' / 'video'
+    //   - ssrc: Media SSRC
+    //   - rtxSsrc: RTX SSRC (may be unset)
+    //   - streamId: MediaStream.jitsiRemoteId
+    //   - trackId: MediaStreamTrack.jitsiRemoteId
+    //   - cname: CNAME
+    // @type {map<Number, Object>}
+    const infos = new Map();
+
+    // Map with stream SSRC as index and associated RTX SSRC as value.
+    // @type {map<Number, Number>}
+    const rtxMap = new Map();
+
+    // Set of RTX SSRC values.
+    const rtxSet = new Set();
+
+    for (const m of sdpObject.media) {
+        const kind = m.type;
+
+        if (kind !== 'audio' && kind !== 'video') {
+            continue; // eslint-disable-line no-continue
+        }
+
+        // Get RTX information.
+        for (const ssrcGroup of m.ssrcGroups || []) {
+            // Just consider FID.
+            if (ssrcGroup.semantics !== 'FID') {
+                continue; // eslint-disable-line no-continue
+            }
+
+            const ssrcs
+                = ssrcGroup.ssrcs.split(' ').map(ssrc => Number(ssrc));
+            const ssrc = ssrcs[0];
+            const rtxSsrc = ssrcs[1];
+
+            rtxMap.set(ssrc, rtxSsrc);
+            rtxSet.add(rtxSsrc);
+        }
+
+        for (const ssrcObject of m.ssrcs || []) {
+            const ssrc = ssrcObject.id;
+
+            // Ignore RTX.
+            if (rtxSet.has(ssrc)) {
+                continue; // eslint-disable-line no-continue
+            }
+
+            let info = infos.get(ssrc);
+
+            if (!info) {
+                info = {
+                    kind,
+                    rtxSsrc: rtxMap.get(ssrc),
+                    ssrc
+                };
+
+                infos.set(ssrc, info);
+            }
+
+            switch (ssrcObject.attribute) {
+            case 'cname': {
+                info.cname = ssrcObject.value;
+                break;
+            }
+            case 'msid': {
+                const values = ssrcObject.value.split(' ');
+                const streamId = values[0];
+                const trackId = values[1];
+
+                info.streamId = streamId;
+                info.trackId = trackId;
+                break;
+            }
+            case 'mslabel': {
+                const streamId = ssrcObject.value;
+
+                info.streamId = streamId;
+                break;
+            }
+            case 'label': {
+                const trackId = ssrcObject.value;
+
+                info.trackId = trackId;
+                break;
+            }
+            }
+        }
+    }
+
+    return infos;
+}
+
+/**
+ * Get local ORTC RTP capabilities filtered and adapted to the given remote RTP
+ * capabilities.
+ * @param {RTCRtpCapabilities} filterWithCapabilities - RTP capabilities to
+ * filter with.
+ * @return {RTCRtpCapabilities}
+ */
+export function getLocalCapabilities(filterWithCapabilities) {
+    const localFullCapabilities = RTCRtpReceiver.getCapabilities();
+    const localCapabilities = {
+        codecs: [],
+        fecMechanisms: [],
+        headerExtensions: []
+    };
+
+    // Map of RTX and codec payloads.
+    // - index: Codec payloadType
+    // - value: Associated RTX payloadType
+    // @type {map<Number, Number>}
+    const remoteRtxMap = new Map();
+
+    // Set codecs.
+    for (const remoteCodec of filterWithCapabilities.codecs) {
+        const remoteCodecName = remoteCodec.name.toLowerCase();
+
+        if (remoteCodecName === 'rtx') {
+            remoteRtxMap.set(
+                remoteCodec.parameters.apt, remoteCodec.preferredPayloadType);
+
+            continue; // eslint-disable-line no-continue
+        }
+
+        const localCodec = localFullCapabilities.codecs.find(codec =>
+            codec.name.toLowerCase() === remoteCodecName
+                && codec.kind === remoteCodec.kind
+                && codec.clockRate === remoteCodec.clockRate
+        );
+
+        if (!localCodec) {
+            continue; // eslint-disable-line no-continue
+        }
+
+        const codec = {
+            clockRate: localCodec.clockRate,
+            kind: localCodec.kind,
+            mimeType: `${localCodec.kind}/${localCodec.name}`,
+            name: localCodec.name,
+            numChannels: localCodec.numChannels || 1,
+            parameters: {},
+            preferredPayloadType: remoteCodec.preferredPayloadType,
+            rtcpFeedback: []
+        };
+
+        for (const remoteParamName of Object.keys(remoteCodec.parameters)) {
+            const remoteParamValue
+                = remoteCodec.parameters[remoteParamName];
+
+            for (const localParamName of Object.keys(localCodec.parameters)) {
+                const localParamValue
+                    = localCodec.parameters[localParamName];
+
+                if (localParamName !== remoteParamName) {
+                    continue; // eslint-disable-line no-continue
+                }
+
+                // TODO: We should consider much more cases here, but Edge
+                // does not support many codec parameters.
+                if (localParamValue === remoteParamValue) {
+                    // Use this RTP parameter.
+                    codec.parameters[localParamName] = localParamValue;
+                    break;
+                }
+            }
+        }
+
+        for (const remoteFb of remoteCodec.rtcpFeedback) {
+            const localFb = localCodec.rtcpFeedback.find(fb =>
+                fb.type === remoteFb.type
+                    && fb.parameter === remoteFb.parameter
+            );
+
+            if (localFb) {
+                // Use this RTCP feedback.
+                codec.rtcpFeedback.push(localFb);
+            }
+        }
+
+        // Use this codec.
+        localCapabilities.codecs.push(codec);
+    }
+
+    // Add RTX for video codecs.
+    for (const codec of localCapabilities.codecs) {
+        const payloadType = codec.preferredPayloadType;
+
+        if (!remoteRtxMap.has(payloadType)) {
+            continue; // eslint-disable-line no-continue
+        }
+
+        const rtxCodec = {
+            clockRate: codec.clockRate,
+            kind: codec.kind,
+            mimeType: `${codec.kind}/rtx`,
+            name: 'rtx',
+            parameters: {
+                apt: payloadType
+            },
+            preferredPayloadType: remoteRtxMap.get(payloadType),
+            rtcpFeedback: []
+        };
+
+        // Add RTX codec.
+        localCapabilities.codecs.push(rtxCodec);
+    }
+
+    // Add RTP header extensions.
+    for (const remoteExtension of filterWithCapabilities.headerExtensions) {
+        const localExtension
+            = localFullCapabilities.headerExtensions.find(extension =>
+                extension.kind === remoteExtension.kind
+                    && extension.uri === remoteExtension.uri
+            );
+
+        if (localExtension) {
+            const extension = {
+                kind: localExtension.kind,
+                preferredEncrypt: Boolean(remoteExtension.preferredEncrypt),
+                preferredId: remoteExtension.preferredId,
+                uri: localExtension.uri
+            };
+
+            // Use this RTP header extension.
+            localCapabilities.headerExtensions.push(extension);
+        }
+    }
+
+    // Add FEC mechanisms.
+    // NOTE: We don't support FEC yet and, in fact, neither does Edge.
+    for (const remoteFecMechanism of filterWithCapabilities.fecMechanisms) {
+        const localFecMechanism
+            = localFullCapabilities.fecMechanisms.find(fec =>
+                fec === remoteFecMechanism
+            );
+
+        if (localFecMechanism) {
+            // Use this FEC mechanism.
+            localCapabilities.fecMechanisms.push(localFecMechanism);
+        }
+    }
+
+    return localCapabilities;
+}
+
+/**
+ * Get the first acive media section.
+ * @param {Object} sdpObject - SDP object generated by sdp-transform.
+ * @return {Object} SDP media section as parsed by sdp-transform.
+ */
+function getFirstActiveMediaSection(sdpObject) {
+    return sdpObject.media.find(m =>
+        m.iceUfrag && m.port !== 0
+    );
+}

modules/statistics/RTPStatsCollector.js

@@ -8,7 +8,7 @@ const logger = require('jitsi-meet-logger').getLogger(__filename);
 const browserSupported = RTCBrowserType.isChrome()
         || RTCBrowserType.isOpera() || RTCBrowserType.isFirefox()
         || RTCBrowserType.isNWJS() || RTCBrowserType.isElectron()
-        || RTCBrowserType.isTemasysPluginUsed();
+        || RTCBrowserType.isTemasysPluginUsed() || RTCBrowserType.isEdge();
 
 /**
  * The lib-jitsi-meet browser-agnostic names of the browser-specific keys
@@ -48,6 +48,28 @@ KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME] = {
     'audioOutputLevel': 'audioOutputLevel',
     'currentRoundTripTime': 'googRtt'
 };
+KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_EDGE] = {
+    'sendBandwidth': 'googAvailableSendBandwidth',
+    'remoteAddress': 'remoteAddress',
+    'transportType': 'protocol',
+    'localAddress': 'localAddress',
+    'activeConnection': 'activeConnection',
+    'ssrc': 'ssrc',
+    'packetsReceived': 'packetsReceived',
+    'packetsSent': 'packetsSent',
+    'packetsLost': 'packetsLost',
+    'bytesReceived': 'bytesReceived',
+    'bytesSent': 'bytesSent',
+    'googFrameHeightReceived': 'frameHeight',
+    'googFrameWidthReceived': 'frameWidth',
+    'googFrameHeightSent': 'frameHeight',
+    'googFrameWidthSent': 'frameWidth',
+    'googFrameRateReceived': 'framesPerSecond',
+    'googFrameRateSent': 'framesPerSecond',
+    'audioInputLevel': 'audioLevel',
+    'audioOutputLevel': 'audioLevel',
+    'currentRoundTripTime': 'roundTripTime'
+};
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_OPERA]
     = KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_CHROME];
 KEYS_BY_BROWSER_TYPE[RTCBrowserType.RTC_BROWSER_NWJS]
@@ -314,6 +336,7 @@ StatsCollector.prototype.start = function(startAudioLevelStats) {
                             // chrome
                             results = report.result();
                         }
+
                         self.currentStatsReport = results;
                         try {
                             self.processStatsReport();
@@ -395,6 +418,9 @@ StatsCollector.prototype._defineGetStatValueMethod = function(keys) {
             return value;
         };
         break;
+    case RTCBrowserType.RTC_BROWSER_EDGE:
+        itemStatByKey = (item, key) => item[key];
+        break;
     default:
         itemStatByKey = (item, key) => item[key];
     }
@@ -513,13 +539,35 @@ StatsCollector.prototype.processStatsReport = function() {
             });
         }
 
+        // NOTE: Edge's proprietary stats via RTCIceTransport.msGetStats().
+        if (now.msType === 'transportdiagnostics') {
+            this.conferenceStats.transport.push({
+                ip: now.remoteAddress,
+                type: now.protocol,
+                localip: now.localAddress,
+                p2p: this.peerconnection.isP2P
+            });
+        }
+
         if (now.type !== 'ssrc' && now.type !== 'outboundrtp'
-            && now.type !== 'inboundrtp') {
+            && now.type !== 'inboundrtp' && now.type !== 'track') {
+            continue;
+        }
+
+        // NOTE: In Edge, stats with type "inboundrtp" and "outboundrtp" are
+        // completely useless, so ignore them.
+        if (RTCBrowserType.isEdge()
+            && (now.type === 'inboundrtp' || now.type === 'outboundrtp')) {
             continue;
         }
 
         const before = this.previousStatsReport[idx];
-        const ssrc = this.getNonNegativeStat(now, 'ssrc');
+        let ssrc = this.getNonNegativeStat(now, 'ssrc');
+
+        // If type="track", take the first SSRC from ssrcIds.
+        if (now.type === 'track' && Array.isArray(now.ssrcIds)) {
+            ssrc = Number(now.ssrcIds[0]);
+        }
 
         if (!before || !ssrc) {
             continue;
@@ -529,10 +577,12 @@ StatsCollector.prototype.processStatsReport = function() {
         // according to the spec
         // https://www.w3.org/TR/webrtc-stats/#dom-rtcrtpstreamstats-isremote
         // when isRemote is true indicates that the measurements were done at
-        // the remote endpoint and reported in an RTCP RR/XR
+        // the remote endpoint and reported in an RTCP RR/XR.
         // Fixes a problem where we are calculating local stats wrong adding
-        // the sent bytes to the local download bitrate
-        if (now.isRemote === true) {
+        // the sent bytes to the local download bitrate.
+        // In new W3 stats spec, type="track" has a remoteSource boolean
+        // property.
+        if (now.isRemote === true || now.remoteSource === true) {
             continue;
         }
 
@@ -615,8 +665,10 @@ StatsCollector.prototype.processStatsReport = function() {
             'upload': bitrateSentKbps
         });
 
-        const resolution = { height: null,
-            width: null };
+        const resolution = {
+            height: null,
+            width: null
+        };
 
         try {
             let height, width;
@@ -763,6 +815,7 @@ StatsCollector.prototype.processStatsReport = function() {
         upload:
             calculatePacketLoss(lostPackets.upload, totalPackets.upload)
     };
+
     this.eventEmitter.emit(
         StatisticsEvents.CONNECTION_STATS,
         this.peerconnection,
@@ -794,12 +847,16 @@ StatsCollector.prototype.processAudioLevelReport = function() {
 
         const now = this.currentAudioLevelsReport[idx];
 
-        if (now.type !== 'ssrc') {
+        if (now.type !== 'ssrc' && now.type !== 'track') {
             continue;
         }
 
         const before = this.baselineAudioLevelsReport[idx];
-        const ssrc = this.getNonNegativeStat(now, 'ssrc');
+        let ssrc = this.getNonNegativeStat(now, 'ssrc');
+
+        if (!ssrc && Array.isArray(now.ssrcIds)) {
+            ssrc = Number(now.ssrcIds[0]);
+        }
 
         if (!before) {
             logger.warn(`${ssrc} not enough data`);
@@ -828,11 +885,33 @@ StatsCollector.prototype.processAudioLevelReport = function() {
         }
 
         if (audioLevel) {
-            const isLocal = !getStatValue(now, 'packetsReceived');
+            let isLocal;
+
+            // If type="ssrc" (legacy) check whether they are received packets.
+            if (now.type === 'ssrc') {
+                isLocal = !getStatValue(now, 'packetsReceived');
+
+            // If type="track", check remoteSource boolean property.
+            } else {
+                isLocal = !now.remoteSource;
+            }
+
+            // According to the W3C WebRTC Stats spec, audioLevel should be in
+            // 0..1 range (0 == silence). However browsers don't behave that
+            // way so we must convert it to 0..1.
+            //
+            // In Edge the range is -100..0 (-100 == silence) measured in dB,
+            // so convert to linear. The levels are set to 0 for remote tracks,
+            // so don't convert those, since 0 means "the maximum" in Edge.
+            if (RTCBrowserType.isEdge()) {
+                audioLevel = audioLevel < 0 ? Math.pow(10, audioLevel / 20) : 0;
 
             // TODO: Can't find specs about what this value really is, but it
             // seems to vary between 0 and around 32k.
-            audioLevel = audioLevel / 32767;
+            } else {
+                audioLevel = audioLevel / 32767;
+            }
+
             this.eventEmitter.emit(
                 StatisticsEvents.AUDIO_LEVEL,
                 this.peerconnection,