Enable rtx sources for streams (#346)

* re-enable setting for enabling/disabling rtx

* add tests for rtxmodifier.  (and a bugfix found by the tests)

* remove rtx handling from sdp-consistency (it will be handled separately)

* better error printing in JingleSessionPC around renegotiation

* add rtx modifier to handle inserting local rtx ssrcs, keeping local rtx ssrcs consistent, and imploding remote rtx ssrcs

* jsdoc, es6 cleanup, logging tweaks

* fix line that's too long

* add a 'parseGroupSsrcs' helper function

* fix a bug when passing group ssrcs to be parsed

* address pr feedback

* address pr feedback

* fix for loop

* address pr feedback

* better const in SampleSdpStrings

modules/xmpp/JingleSessionPC.js

@@ -346,7 +346,7 @@ JingleSessionPC.prototype.setOfferCycle = function (jingleOfferIq,
             .then(() => {
                 finishedCallback();
             }, (error) => {
-                logger.info("Error renegotiating after setting new remote offer: " + error);
+                logger.error("Error renegotiating after setting new remote offer: " + error);
                 JingleSessionPC.onJingleFatalError(this, error);
                 finishedCallback(error);
             });
@@ -655,7 +655,7 @@ JingleSessionPC.prototype.addRemoteStream = function (elem) {
                 this.notifyMySSRCUpdate(mySdp, newSdp);
                 finishedCallback();
             }, (error) => {
-                logger.info("Error renegotiating after processing remote source-add: " + error);
+                logger.error("Error renegotiating after processing remote source-add: " + error);
                 finishedCallback(error);
             });
     };
@@ -807,12 +807,14 @@ JingleSessionPC.prototype._renegotiate = function(optionalRemoteSdp) {
                     XMPPEvents.REMOTE_UFRAG_CHANGED, remoteUfrag);
         }
 
+        logger.debug("Renegotiate: setting remote description");
         this.peerconnection.setRemoteDescription(
             remoteDescription,
             () => {
                 if (this.signalingState === 'closed') {
                     reject("Attemped to setRemoteDescription in state closed");
                 }
+                logger.debug("Renegotiate: creating answer");
                 this.peerconnection.createAnswer(
                     (answer) => {
                         let localUfrag = getUfrag(answer.sdp);
@@ -821,6 +823,7 @@ JingleSessionPC.prototype._renegotiate = function(optionalRemoteSdp) {
                             this.room.eventEmitter.emit(
                                     XMPPEvents.LOCAL_UFRAG_CHANGED, localUfrag);
                         }
+                        logger.debug("Renegotiate: setting local description");
                         this.peerconnection.setLocalDescription(
                             answer,
                             () => { resolve(); },

modules/xmpp/RtxModifier.js

@@ -0,0 +1,276 @@
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
+import * as transform from 'sdp-transform';
+import * as SDPUtil from "./SDPUtil";
+
+/**
+ * Begin helper functions
+ */
+/**
+ * Given a videoMLine, returns a list of the video
+ *  ssrcs (those used to actually send video, not
+ *  any associated secondary streams)
+ * @param {object} videoMLine media line object from transform.parse
+ * @returns {list<string>} list of primary video ssrcs
+ */
+function getPrimaryVideoSsrcs (videoMLine) {
+    let videoSsrcs = videoMLine.ssrcs
+        .map(ssrcInfo => ssrcInfo.id)
+        .filter((ssrc, index, array) => array.indexOf(ssrc) === index);
+
+    if (videoMLine.ssrcGroups) {
+        videoMLine.ssrcGroups.forEach((ssrcGroupInfo) => {
+            // Right now, FID groups are the only ones we parse to 
+            //  disqualify streams.  If/when others arise we'll
+            //  need to add support for them here
+            if (ssrcGroupInfo.semantics === "FID") {
+                // secondary FID streams should be filtered out
+                let secondarySsrc = ssrcGroupInfo.ssrcs.split(" ")[1];
+                videoSsrcs.splice(
+                  videoSsrcs.indexOf(parseInt(secondarySsrc)), 1);
+            }
+        });
+    }
+    return videoSsrcs;
+}
+
+/**
+ * Given a video mline (as parsed from transform.parse),
+ *  and a primary ssrc, return the corresponding rtx ssrc
+ *  (if there is one) for that video ssrc
+ * @param {object} videoMLine the video MLine from which to extract the
+ *  rtx video ssrc
+ * @param {number} primarySsrc the video ssrc for which to find the
+ *  corresponding rtx ssrc
+ * @returns {number} the rtx ssrc (or undefined if there isn't one)
+ */
+function getRtxSsrc (videoMLine, primarySsrc) {
+    if (videoMLine.ssrcGroups) {
+        let fidGroup = videoMLine.ssrcGroups.find(group => {
+            if (group.semantics === "FID") {
+                let groupPrimarySsrc = SDPUtil.parseGroupSsrcs(group)[0];
+                return groupPrimarySsrc === primarySsrc;
+            }
+        });
+        if (fidGroup) {
+          return SDPUtil.parseGroupSsrcs(fidGroup)[1];
+        }
+    }
+}
+
+/**
+ * Updates or inserts the appropriate rtx information for primarySsrc with
+ *  the given rtxSsrc.  If no rtx ssrc for primarySsrc currently exists, it will
+ *  add the appropriate ssrc and ssrc group lines.  If primarySsrc already has
+ *  an rtx ssrc, the appropriate ssrc and group lines will be updated
+ * @param {object} videoMLine video mline object that will be updated (in place)
+ * @param {object} primarySsrcInfo the info (ssrc, msid & cname) for the 
+ *  primary ssrc
+ * @param {number} rtxSsrc the rtx ssrc to associate with the primary ssrc
+ */
+function updateAssociatedRtxStream (videoMLine, primarySsrcInfo, rtxSsrc) {
+    logger.info("Updating mline to associate " + rtxSsrc + 
+        " rtx ssrc with primary stream ", primarySsrcInfo.id);
+    let primarySsrc = primarySsrcInfo.id;
+    let primarySsrcMsid = primarySsrcInfo.msid;
+    let primarySsrcCname = primarySsrcInfo.cname;
+
+    let previousAssociatedRtxStream = 
+        getRtxSsrc (videoMLine, primarySsrc);
+    if (previousAssociatedRtxStream === rtxSsrc) {
+        logger.info(rtxSsrc + " was already associated with " +
+            primarySsrc);
+        return;
+    }
+    if (previousAssociatedRtxStream) {
+        logger.info(primarySsrc + " was previously assocaited with rtx " +
+            previousAssociatedRtxStream + ", removing all references to it");
+        // Stream already had an rtx ssrc that is different than the one given,
+        //  remove all trace of the old one
+        videoMLine.ssrcs = videoMLine.ssrcs
+            .filter(ssrcInfo => ssrcInfo.id !== previousAssociatedRtxStream);
+        logger.info("groups before filtering for " + 
+            previousAssociatedRtxStream);
+        logger.info(JSON.stringify(videoMLine.ssrcGroups));
+        videoMLine.ssrcGroups = videoMLine.ssrcGroups
+            .filter(groupInfo => {
+                return groupInfo
+                    .ssrcs
+                    .indexOf(previousAssociatedRtxStream + "") === -1;
+            });
+    }
+    videoMLine.ssrcs.push({
+        id: rtxSsrc,
+        attribute: "cname",
+        value: primarySsrcCname
+    });
+    videoMLine.ssrcs.push({
+        id: rtxSsrc,
+        attribute: "msid",
+        value: primarySsrcMsid
+    });
+    videoMLine.ssrcGroups = videoMLine.ssrcGroups || [];
+    videoMLine.ssrcGroups.push({
+        semantics: "FID",
+        ssrcs: primarySsrc + " " + rtxSsrc
+    });
+}
+/**
+ * End helper functions
+ */
+
+/**
+ * Adds any missing RTX streams for video streams
+ *  and makes sure that they remain consistent
+ */
+export default class RtxModifier {
+    /**
+     * Constructor
+     */
+    constructor () {
+        /**
+         * Map of video ssrc to corresponding RTX
+         *  ssrc
+         */
+        this.correspondingRtxSsrcs = new Map();
+    }
+
+    /**
+     * Clear the cached map of primary video ssrcs to
+     *  their corresponding rtx ssrcs so that they will
+     *  not be used for the next call to modifyRtxSsrcs
+     */
+    clearSsrcCache () {
+        this.correspondingRtxSsrcs.clear();
+    }
+
+    /**
+     * Explicitly set the primary video ssrc -> rtx ssrc
+     *  mapping to be used in modifyRtxSsrcs
+     * @param {Map} ssrcMapping a mapping of primary video
+     *  ssrcs to their corresponding rtx ssrcs
+     */
+    setSsrcCache (ssrcMapping) {
+        logger.info("Setting ssrc cache to ", ssrcMapping);
+        this.correspondingRtxSsrcs = ssrcMapping;
+    }
+
+    /**
+     * Adds RTX ssrcs for any video ssrcs that don't
+     *  already have them.  If the video ssrc has been
+     *  seen before, and already had an RTX ssrc generated,
+     *  the same RTX ssrc will be used again.
+     * @param {string} sdpStr sdp in raw string format
+     */
+    modifyRtxSsrcs (sdpStr) {
+        let parsedSdp = transform.parse(sdpStr);
+        let videoMLine = 
+            parsedSdp.media.find(mLine => mLine.type === "video");
+        if (videoMLine.direction === "inactive" ||
+                videoMLine.direction === "recvonly") {
+            logger.info("RtxModifier doing nothing, video " +
+                "m line is inactive or recvonly");
+            return sdpStr;
+        }
+        if (!videoMLine.ssrcs) {
+          logger.info("RtxModifier doing nothing, no video ssrcs present");
+          return sdpStr;
+        }
+        logger.info("Current ssrc mapping: ", this.correspondingRtxSsrcs);
+        let primaryVideoSsrcs = getPrimaryVideoSsrcs(videoMLine);
+        logger.info("Parsed primary video ssrcs ", primaryVideoSsrcs, " " +
+            "making sure all have rtx streams");
+        primaryVideoSsrcs.forEach(ssrc => {
+            let msid = SDPUtil.getSsrcAttribute(videoMLine, ssrc, "msid");
+            let cname = SDPUtil.getSsrcAttribute(videoMLine, ssrc, "cname");
+            let correspondingRtxSsrc = this.correspondingRtxSsrcs.get(ssrc);
+            if (correspondingRtxSsrc) {
+                logger.info("Already have an associated rtx ssrc for " +
+                    " video ssrc " + ssrc + ": " + 
+                    correspondingRtxSsrc);
+            } else {
+                logger.info("No previously associated rtx ssrc for " +
+                    " video ssrc " + ssrc);
+                // If there's one in the sdp already for it, we'll just set
+                //  that as the corresponding one
+                let previousAssociatedRtxStream = 
+                    getRtxSsrc (videoMLine, ssrc);
+                if (previousAssociatedRtxStream) {
+                    logger.info("Rtx stream " + previousAssociatedRtxStream + 
+                        " already existed in the sdp as an rtx stream for " +
+                        ssrc);
+                    correspondingRtxSsrc = previousAssociatedRtxStream;
+                } else {
+                    correspondingRtxSsrc = SDPUtil.generateSsrc();
+                    logger.info("Generated rtx ssrc " + correspondingRtxSsrc + 
+                        " for ssrc " + ssrc);
+                }
+                logger.info("Caching rtx ssrc " + correspondingRtxSsrc + 
+                    " for video ssrc " + ssrc);
+                this.correspondingRtxSsrcs.set(ssrc, correspondingRtxSsrc);
+            }
+            updateAssociatedRtxStream(
+                videoMLine, 
+                {
+                    id: ssrc,
+                    cname: cname,
+                    msid: msid
+                },
+                correspondingRtxSsrc);
+        });
+        return transform.write(parsedSdp);
+    }
+
+    /**
+     * Remove all reference to any rtx ssrcs that 
+     *  don't correspond to the primary stream.
+     * Must be called *after* any simulcast streams
+     *  have been imploded
+     * @param {string} sdpStr sdp in raw string format
+     */
+    implodeRemoteRtxSsrcs (sdpStr) {
+        let parsedSdp = transform.parse(sdpStr);
+        let videoMLine = 
+            parsedSdp.media.find(mLine => mLine.type === "video");
+        if (videoMLine.direction === "inactive" ||
+                videoMLine.direction === "recvonly") {
+            logger.info("RtxModifier doing nothing, video " +
+                "m line is inactive or recvonly");
+            return sdpStr;
+        }
+        if (!videoMLine.ssrcGroups) {
+            // Nothing to do
+            return sdpStr;
+        }
+
+        // Returns true if the given ssrc is present
+        //  in the mLine's ssrc list
+        let ssrcExists = (ssrcToFind) => {
+            return videoMLine.ssrcs.
+              find((ssrc) => ssrc.id + "" === ssrcToFind);
+        };
+        let ssrcsToRemove = [];
+        videoMLine.ssrcGroups.forEach(group => {
+            if (group.semantics === "FID") {
+                let primarySsrc = group.ssrcs.split(" ")[0];
+                let rtxSsrc = group.ssrcs.split(" ")[1];
+                if (!ssrcExists(primarySsrc)) {
+                    ssrcsToRemove.push(rtxSsrc);
+                }
+            }
+        });
+        videoMLine.ssrcs = videoMLine.ssrcs
+            .filter(ssrc => ssrcsToRemove.indexOf(ssrc.id + "") === -1);
+        videoMLine.ssrcGroups = videoMLine.ssrcGroups
+            .filter(group => {
+                let ssrcs = group.ssrcs.split(" ");
+                for (let i = 0; i < ssrcs.length; ++i) {
+                    if (ssrcsToRemove.indexOf(ssrcs[i]) !== -1) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+        return transform.write(parsedSdp);
+    }
+}

modules/xmpp/RtxModifier.spec.js

@@ -0,0 +1,292 @@
+/*eslint-disable max-len*/
+/*jshint maxlen:false*/
+import RtxModifier from "./RtxModifier.js";
+import * as SampleSdpStrings from "./SampleSdpStrings.js";
+import * as transform from 'sdp-transform';
+import * as SDPUtil from "./SDPUtil";
+
+/**
+ * Returns the number of video ssrcs in the given sdp
+ * @param {object} parsedSdp the sdp as parsed by transform.parse
+ * @returns {number} the number of video ssrcs in the given sdp
+ */
+function numVideoSsrcs (parsedSdp) {
+  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  return videoMLine.ssrcs
+    .map(ssrcInfo => ssrcInfo.id)
+    .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
+    .length;
+}
+
+/**
+ * Return the (single) primary video ssrc in the given sdp
+ * @param {object} parsedSdp the sdp as parsed by transform.parse
+ * @returns {number} the primary video ssrc in the given sdp
+ */
+function getPrimaryVideoSsrc (parsedSdp) {
+  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  return parseInt(SDPUtil.parsePrimaryVideoSsrc(videoMLine));
+}
+
+/**
+ * Get the primary video ssrc(s) in the given sdp.
+ * Only handles parsing 2 scenarios right now:
+ * 1) Single video ssrc
+ * 2) Multiple video ssrcs in a single simulcast group
+ * @param {object} parsedSdp the sdp as parsed by transform.parse
+ * @returns {list<number>} the primary video ssrcs in the given sdp
+ */
+function getPrimaryVideoSsrcs (parsedSdp) {
+  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  if (numVideoSsrcs(parsedSdp) === 1) {
+    return [videoMLine.ssrcs[0].id];
+  } else {
+    let simGroups = getVideoGroups(parsedSdp, "SIM");
+    if (simGroups.length > 1) {
+      return;
+    }
+    let simGroup = simGroups[0];
+    return SDPUtil.parseGroupSsrcs(simGroup);
+  }
+}
+
+/**
+ * Get the video groups that match the passed semantics from the
+ *  given sdp
+ * @param {object} parsedSDp the sdp as parsed by transform.parse
+ * @param {string} groupSemantics the semantics string of the groups
+ *  the caller is interested in
+ * @returns {list<object>} a list of the groups from the given sdp
+ *  that matched the passed semantics
+ */
+function getVideoGroups (parsedSdp, groupSemantics) {
+  let videoMLine = parsedSdp.media.find(m => m.type === "video");
+  videoMLine.ssrcGroups = videoMLine.ssrcGroups || [];
+  return videoMLine.ssrcGroups
+    .filter(g => g.semantics === groupSemantics);
+}
+
+describe ("RtxModifier", function() {
+    beforeEach(function() {
+      this.rtxModifier = new RtxModifier();
+      this.transform = transform;
+      this.SDPUtil = SDPUtil;
+    });
+
+    describe ("modifyRtxSsrcs", function() {
+      describe ("when given an sdp with a single video ssrc", function() {
+        beforeEach(function() {
+          this.singleVideoSdp = SampleSdpStrings.plainVideoSdp;
+          this.primaryVideoSsrc = getPrimaryVideoSsrc(this.singleVideoSdp);
+        });
+        it ("should add a single rtx ssrc", function() {
+          // Call rtxModifier.modifyRtxSsrcs with an sdp that contains a single video
+          //  ssrc.  The returned sdp should have an rtx ssrc and an fid group.
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+          let newPrimaryVideoSsrc = getPrimaryVideoSsrc(newSdp);
+          expect(newPrimaryVideoSsrc).toEqual(this.primaryVideoSsrc);
+          // Should now have an rtx ssrc as well
+          expect(numVideoSsrcs(newSdp)).toEqual(2);
+          // Should now have an FID group
+          let fidGroups = getVideoGroups(newSdp, "FID");
+          expect(fidGroups.length).toEqual(1);
+
+          let fidGroup = fidGroups[0];
+          let fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
+          expect(fidGroupPrimarySsrc).toEqual(this.primaryVideoSsrc);
+        });
+
+        it ("should re-use the same rtx ssrc for a primary ssrc it's seen before", function() {
+          // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
+          //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
+          //  the same rtx ssrc as before.
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+
+          let fidGroup = getVideoGroups(newSdp, "FID")[0];
+          let fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+
+          // Now pass the original sdp through again 
+          newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          newSdp = transform.parse(newSdpStr);
+          fidGroup = getVideoGroups(newSdp, "FID")[0];
+          let newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          expect(newFidGroupRtxSsrc).toEqual(fidGroupRtxSsrc);
+        });
+
+        it ("should NOT re-use the same rtx ssrc for a primary ssrc it's seen before if the cache has been cleared", function() {
+          // Call modifyRtxSsrcs to generate an rtx ssrc
+          // Clear the rtxModifier cache
+          // Call modifyRtxSsrcs to generate an rtx ssrc again with the same primary ssrc
+          // --> We should get a different rtx ssrc
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+
+          let fidGroup = getVideoGroups(newSdp, "FID")[0];
+          let fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          this.rtxModifier.clearSsrcCache();
+
+          // Now pass the original sdp through again
+          newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          newSdp = transform.parse(newSdpStr);
+          fidGroup = getVideoGroups(newSdp, "FID")[0];
+          let newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          expect(newFidGroupRtxSsrc).not.toEqual(fidGroupRtxSsrc);
+        });
+
+        it ("should use the rtx ssrc from the cache when the cache has been manually set", function() {
+          // Manually set an rtx ssrc mapping in the cache
+          // Call modifyRtxSsrcs
+          // -->The rtx ssrc used should be the one we set
+          let forcedRtxSsrc = 123456;
+          let ssrcCache = new Map();
+          ssrcCache.set(this.primaryVideoSsrc, forcedRtxSsrc);
+          this.rtxModifier.setSsrcCache(ssrcCache);
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+
+          let fidGroup = getVideoGroups(newSdp, "FID")[0];
+          let fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
+          expect(fidGroupRtxSsrc).toEqual(forcedRtxSsrc);
+        });
+      });
+
+      describe ("when given an sdp with multiple video ssrcs", function() {
+        beforeEach(function() {
+          this.multipleVideoSdp = SampleSdpStrings.simulcastSdp;
+          this.primaryVideoSsrcs = getPrimaryVideoSsrcs(this.multipleVideoSdp);
+        });
+
+        it ("should add rtx ssrcs for all of them", function() {
+          // Call rtxModifier.modifyRtxSsrcs with an sdp that contains multiple video
+          //  ssrcs.  The returned sdp should have an rtx ssrc and an fid group for all of them.
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+          let newPrimaryVideoSsrcs = getPrimaryVideoSsrcs(newSdp);
+          expect(newPrimaryVideoSsrcs).toEqual(this.primaryVideoSsrcs);
+          // Should now have rtx ssrcs as well
+          expect(numVideoSsrcs(newSdp)).toEqual(this.primaryVideoSsrcs.length * 2);
+          // Should now have FID groups
+          let fidGroups = getVideoGroups(newSdp, "FID");
+          expect(fidGroups.length).toEqual(this.primaryVideoSsrcs.length);
+          fidGroups.forEach(fidGroup => {
+            let fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
+            expect(this.primaryVideoSsrcs.indexOf(fidGroupPrimarySsrc)).not.toEqual(-1);
+          });
+        });
+
+        it ("should re-use the same rtx ssrcs for any primary ssrc it's seen before", function() {
+          // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
+          //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
+          //  the same rtx ssrc as before.
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+
+          let rtxMapping = new Map();
+          let fidGroups = getVideoGroups(newSdp, "FID");
+          // Save the first mapping that is made
+          fidGroups.forEach(fidGroup => {
+            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            let fidGroupPrimarySsrc = fidSsrcs[0];
+            let fidGroupRtxSsrc = fidSsrcs[1];
+            rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
+          });
+          // Now pass the original sdp through again and make sure we get the same mapping
+          newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          newSdp = transform.parse(newSdpStr);
+          fidGroups = getVideoGroups(newSdp, "FID");
+          fidGroups.forEach(fidGroup => {
+            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            let fidGroupPrimarySsrc = fidSsrcs[0];
+            let fidGroupRtxSsrc = fidSsrcs[1];
+            expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
+            expect(rtxMapping.get(fidGroupPrimarySsrc)).toEqual(fidGroupRtxSsrc);
+          });
+        });
+
+        it ("should NOT re-use the same rtx ssrcs for any primary ssrc it's seen before if the cache has been cleared", function() {
+          // Call modifyRtxSsrcs to generate an rtx ssrc
+          // Clear the rtxModifier cache
+          // Call modifyRtxSsrcs to generate rtx ssrcs again with the same primary ssrcs
+          // --> We should get different rtx ssrcs
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+
+          let rtxMapping = new Map();
+          let fidGroups = getVideoGroups(newSdp, "FID");
+          // Save the first mapping that is made
+          fidGroups.forEach(fidGroup => {
+            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            let fidGroupPrimarySsrc = fidSsrcs[0];
+            let fidGroupRtxSsrc = fidSsrcs[1];
+            rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
+          });
+
+          this.rtxModifier.clearSsrcCache();
+          // Now pass the original sdp through again and make sure we get the same mapping
+          newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          newSdp = transform.parse(newSdpStr);
+          fidGroups = getVideoGroups(newSdp, "FID");
+          fidGroups.forEach(fidGroup => {
+            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            let fidGroupPrimarySsrc = fidSsrcs[0];
+            let fidGroupRtxSsrc = fidSsrcs[1];
+            expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
+            expect(rtxMapping.get(fidGroupPrimarySsrc)).not.toEqual(fidGroupRtxSsrc);
+          });
+        });
+
+        it ("should use the rtx ssrcs from the cache when the cache has been manually set", function() {
+          // Manually set an rtx ssrc mapping in the cache
+          // Call modifyRtxSsrcs
+          // -->The rtx ssrc used should be the one we set
+          let rtxMapping = new Map();
+          this.primaryVideoSsrcs.forEach(ssrc => {
+            rtxMapping.set(ssrc, SDPUtil.generateSsrc());
+          });
+          this.rtxModifier.setSsrcCache(rtxMapping);
+
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+          let newSdp = transform.parse(newSdpStr);
+
+          let fidGroups = getVideoGroups(newSdp, "FID");
+          fidGroups.forEach(fidGroup => {
+            let fidSsrcs = SDPUtil.parseGroupSsrcs(fidGroup);
+            let fidGroupPrimarySsrc = fidSsrcs[0];
+            let fidGroupRtxSsrc = fidSsrcs[1];
+            expect(rtxMapping.has(fidGroupPrimarySsrc)).toBe(true);
+            expect(rtxMapping.get(fidGroupPrimarySsrc)).toEqual(fidGroupRtxSsrc);
+          });
+        });
+      });
+
+      describe ("(corner cases)", function() {
+        it ("should handle a recvonly video mline", function() {
+          let sdp = SampleSdpStrings.plainVideoSdp;
+          let videoMLine = sdp.media.find(m => m.type === "video");
+          videoMLine.direction = "recvonly";
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+          expect(newSdpStr).toEqual(this.transform.write(sdp));
+        });
+
+        it ("should handle an inactive video mline", function() {
+          let sdp = SampleSdpStrings.plainVideoSdp;
+          let videoMLine = sdp.media.find(m => m.type === "video");
+          videoMLine.direction = "inactive";
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+          expect(newSdpStr).toEqual(this.transform.write(sdp));
+        });
+
+        it ("should handle a video mline with no video ssrcs", function() {
+          let sdp = SampleSdpStrings.plainVideoSdp;
+          let videoMLine = sdp.media.find(m => m.type === "video");
+          videoMLine.ssrcs = [];
+          let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+          expect(newSdpStr).toEqual(this.transform.write(sdp));
+        });
+      });
+    });
+});
+
+/*eslint-enable max-len*/

modules/xmpp/SDPUtil.js

@@ -1,8 +1,8 @@
 import {getLogger} from "jitsi-meet-logger";
 const logger = getLogger(__filename);
+import RandomUtil from "../util/RandomUtil";
 var RTCBrowserType = require("../RTC/RTCBrowserType");
 
-
 var SDPUtil = {
     filter_special_chars: function (text) {
         // XXX Neither one of the falsy values (e.g. null, undefined, false,
@@ -362,7 +362,87 @@ var SDPUtil = {
         line += ' ';
         line += cand.getAttribute('generation') || '0';
         return line + '\r\n';
-    }
+    },
+
+    /**
+     * Parse the 'most' primary video ssrc from the given m line
+     * @param {object} mLine object as parsed from transform.parse
+     * @return {number} the primary video ssrc from the given m line
+     */
+    parsePrimaryVideoSsrc: function(videoMLine) {
+        let numSsrcs = videoMLine.ssrcs
+            .map(ssrcInfo => ssrcInfo.id)
+            .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
+            .length;
+        let numGroups = (videoMLine.ssrcGroups && videoMLine.ssrcGroups.length) || 0;
+        if (numSsrcs > 1 && numGroups === 0) {
+            // Ambiguous, can't figure out the primary
+            return;
+        }
+        let primarySsrc = null;
+        if (numSsrcs === 1) {
+            primarySsrc = videoMLine.ssrcs[0].id;
+        } else {
+            if (numSsrcs === 2) {
+                // Can figure it out if there's an FID group
+                let fidGroup = videoMLine.ssrcGroups
+                    .find(group => group.semantics === "FID");
+                if (fidGroup) {
+                    primarySsrc = fidGroup.ssrcs.split(" ")[0];
+                }
+            } else if (numSsrcs >= 3) {
+                // Can figure it out if there's a sim group
+                let simGroup = videoMLine.ssrcGroups
+                    .find(group => group.semantics === "SIM");
+                if (simGroup) {
+                    primarySsrc = simGroup.ssrcs.split(" ")[0];
+                }
+            }
+        }
+        return primarySsrc;
+    },
+
+    /**
+     * Generate an ssrc
+     * @returns {number} an ssrc
+     */
+    generateSsrc: function() {
+        return RandomUtil.randomInt(1, 0xffffffff);
+    },
+
+    /**
+     * Get an attribute for the given ssrc with the given attributeName
+     *  from the given mline
+     * @param {object} mLine an mLine object as parsed from transform.parse
+     * @param {number} ssrc the ssrc for which an attribtue is desired
+     * @param {string} attributeName the name of the desired attribute
+     * @returns {string} the value corresponding to the given ssrc
+     *  and attributeName
+     */
+    getSsrcAttribute: function (mLine, ssrc, attributeName) {
+        for (let i = 0; i < mLine.ssrcs.length; ++i) {
+            let ssrcLine = mLine.ssrcs[i];
+            if (ssrcLine.id === ssrc &&
+                ssrcLine.attribute === attributeName) {
+                return ssrcLine.value;
+            }
+        }
+    },
+
+    /**
+     * Parses the ssrcs from the group sdp line and
+     *  returns them as a list of numbers
+     * @param {object} the ssrcGroup object as parsed from
+     *  sdp-transform
+     * @returns {list<number>} a list of the ssrcs in the group
+     *  parsed as numbers
+     */
+    parseGroupSsrcs: function (ssrcGroup) {
+        return ssrcGroup
+            .ssrcs
+            .split(" ")
+            .map(ssrcStr => parseInt(ssrcStr));
+    },
 };
 
 module.exports = SDPUtil;

modules/xmpp/SampleSdpStrings.js

@@ -0,0 +1,174 @@
+/*eslint-disable max-len*/
+/*jshint maxlen:false*/
+import * as transform from 'sdp-transform';
+
+// A generic sdp session block
+const baseSessionSdp = "" +
+"v=0\r\n" +
+"o=- 814997227879783433 5 IN IP4 127.0.0.1\r\n" +
+"s=-\r\n" +
+"t=0 0\r\n" +
+"a=msid-semantic: WMS 0836cc8e-a7bb-47e9-affb-0599414bc56d\r\n" +
+"a=group:BUNDLE audio video data\r\n";
+
+// A basic sdp audio mline with a single stream
+const baseAudioMLineSdp = "" +
+"m=audio 54405 RTP/SAVPF 111 103 104 126\r\n" +
+"c=IN IP4 172.29.32.39\r\n" +
+"a=rtpmap:111 opus/48000/2\r\n" +
+"a=rtpmap:103 ISAC/16000\r\n" +
+"a=rtpmap:104 ISAC/32000\r\n" +
+"a=rtpmap:126 telephone-event/8000\r\n" +
+"a=fmtp:111 minptime=10;useinbandfec=1\r\n" +
+"a=rtcp:9 IN IP4 0.0.0.0\r\n" +
+"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n" +
+"a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
+"a=setup:passive\r\n" +
+"a=mid:audio\r\n" +
+"a=sendrecv\r\n" +
+"a=ice-ufrag:adPg\r\n" +
+"a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n" +
+"a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n" +
+"a=candidate:1581043602 1 udp 2122260223 172.29.32.39 54405 typ host generation 0\r\n" +
+"a=ssrc:124723944 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:124723944 msid:dcbb0236-cea5-402e-9e9a-595c65ffcc2a 40abf2d3-a415-4c68-8c17-2a038e8bebcf\r\n" +
+"a=ssrc:124723944 mslabel:dcbb0236-cea5-402e-9e9a-595c65ffcc2a\r\n" +
+"a=ssrc:124723944 label:40abf2d3-a415-4c68-8c17-2a038e8bebcf\r\n" +
+"a=rtcp-mux\r\n";
+
+// A basic sdp application mline
+const baseDataMLineSdp = "" +
+"m=application 9 DTLS/SCTP 5000\r\n" +
+"c=IN IP4 0.0.0.0\r\n" +
+"b=AS:30\r\n" +
+"a=setup:passive\r\n" +
+"a=mid:data\r\n" +
+"a=ice-ufrag:adPg\r\n" +
+"a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n" +
+"a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n" +
+"a=sctpmap:5000 webrtc-datachannel 1024\r\n";
+
+// A basic sdp video mline with a single stream
+const plainVideoMLineSdp = "" +
+"m=video 9 RTP/SAVPF 100\r\n" +
+"c=IN IP4 0.0.0.0\r\n" +
+"a=rtpmap:100 VP8/90000\r\n" +
+"a=rtcp:9 IN IP4 0.0.0.0\r\n" +
+"a=rtcp-fb:100 ccm fir\r\n" +
+"a=rtcp-fb:100 nack\r\n" +
+"a=rtcp-fb:100 nack pli\r\n" +
+"a=rtcp-fb:100 goog-remb\r\n" +
+"a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
+"a=setup:passive\r\n" +
+"a=mid:video\r\n" +
+"a=sendrecv\r\n" +
+"a=ice-ufrag:adPg\r\n" +
+"a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n" +
+"a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n" +
+"a=ssrc:1757014965 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1757014965 cname:peDGrDD6WsxUOki/\r\n" +
+"a=rtcp-mux\r\n";
+
+// An sdp video mline with 3 simulcast streams
+const simulcastVideoMLineSdp = "" +
+"m=video 9 RTP/SAVPF 100\r\n" +
+"c=IN IP4 0.0.0.0\r\n" +
+"a=rtpmap:100 VP8/90000\r\n" +
+"a=rtcp:9 IN IP4 0.0.0.0\r\n" +
+"a=rtcp-fb:100 ccm fir\r\n" +
+"a=rtcp-fb:100 nack\r\n" +
+"a=rtcp-fb:100 nack pli\r\n" +
+"a=rtcp-fb:100 goog-remb\r\n" +
+"a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
+"a=setup:passive\r\n" +
+"a=mid:video\r\n" +
+"a=sendrecv\r\n" +
+"a=ice-ufrag:adPg\r\n" +
+"a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n" +
+"a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n" +
+"a=ssrc:1757014965 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1757014965 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:1479742055 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1479742055 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:1089111804 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1089111804 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc-group:SIM 1757014965 1479742055 1089111804\r\n" +
+"a=rtcp-mux\r\n";
+
+// An sdp video mline with a single video stream and a
+//  corresponding rtx stream
+const rtxVideoMLineSdp = "" +
+"m=video 9 RTP/SAVPF 100 96\r\n" +
+"c=IN IP4 0.0.0.0\r\n" +
+"a=rtpmap:100 VP8/90000\r\n" +
+"a=fmtp:96 apt=100\r\n" +
+"a=rtcp:9 IN IP4 0.0.0.0\r\n" +
+"a=rtcp-fb:100 ccm fir\r\n" +
+"a=rtcp-fb:100 nack\r\n" +
+"a=rtcp-fb:100 nack pli\r\n" +
+"a=rtcp-fb:100 goog-remb\r\n" +
+"a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
+"a=setup:passive\r\n" +
+"a=mid:video\r\n" +
+"a=sendrecv\r\n" +
+"a=ice-ufrag:adPg\r\n" +
+"a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n" +
+"a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n" +
+"a=ssrc:1757014965 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1757014965 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:984899560 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:984899560 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc-group:FID 1757014965 984899560\r\n" +
+"a=rtcp-mux\r\n";
+
+// An sdp video mline with 3 simulcast streams and 3 rtx streams
+const simulcastRtxVideoMLineSdp = "" +
+"m=video 9 RTP/SAVPF 100 96\r\n" +
+"c=IN IP4 0.0.0.0\r\n" +
+"a=rtpmap:100 VP8/90000\r\n" +
+"a=fmtp:96 apt=100\r\n" +
+"a=rtcp:9 IN IP4 0.0.0.0\r\n" +
+"a=rtcp-fb:100 ccm fir\r\n" +
+"a=rtcp-fb:100 nack\r\n" +
+"a=rtcp-fb:100 nack pli\r\n" +
+"a=rtcp-fb:100 goog-remb\r\n" +
+"a=extmap:3 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n" +
+"a=setup:passive\r\n" +
+"a=mid:video\r\n" +
+"a=sendrecv\r\n" +
+"a=ice-ufrag:adPg\r\n" +
+"a=ice-pwd:Xsr05Mq8S7CR44DAnusZE26F\r\n" +
+"a=fingerprint:sha-256 6A:39:DE:11:24:AD:2E:4E:63:D6:69:D3:85:05:53:C7:3C:38:A4:B7:91:74:C0:91:44:FC:94:63:7F:01:AB:A9\r\n" +
+"a=ssrc:1757014965 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1757014965 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:1479742055 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1479742055 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:1089111804 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:1089111804 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:855213044 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:855213044 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:984899560 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:984899560 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc:2963867077 msid:0836cc8e-a7bb-47e9-affb-0599414bc56d bdbd2c0a-7959-4578-8db5-9a6a1aec4ecf\r\n" +
+"a=ssrc:2963867077 cname:peDGrDD6WsxUOki/\r\n" +
+"a=ssrc-group:FID 1757014965 984899560\r\n" +
+"a=ssrc-group:FID 1479742055 855213044\r\n" +
+"a=ssrc-group:FID 1089111804 2963867077\r\n" +
+"a=ssrc-group:SIM 1757014965 1479742055 1089111804\r\n" +
+"a=rtcp-mux\r\n";
+
+// A full sdp string representing a client doing simulcast
+const simulcastSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastVideoMLineSdp + baseDataMLineSdp;
+// A full sdp string representing a client doing simulcast and rtx
+const simulcastRtxSdpStr = baseSessionSdp + baseAudioMLineSdp + simulcastRtxVideoMLineSdp + baseDataMLineSdp;
+// A full sdp string representing a client doing a single video stream
+const plainVideoSdpStr = baseSessionSdp + baseAudioMLineSdp + plainVideoMLineSdp + baseDataMLineSdp;
+// A full sdp string representing a client doing a single video stream with rtx
+const rtxVideoSdpStr = baseSessionSdp + baseAudioMLineSdp + rtxVideoMLineSdp + baseDataMLineSdp;
+
+export const simulcastSdp = transform.parse(simulcastSdpStr);
+export const simulcastRtxSdp = transform.parse(simulcastRtxSdpStr);
+export const plainVideoSdp = transform.parse(plainVideoSdpStr);
+export const rtxVideoSdp = transform.parse(rtxVideoSdpStr);
+
+/*eslint-enable max-len*/

modules/xmpp/SdpConsistency.js

@@ -1,4 +1,7 @@
+import { getLogger } from "jitsi-meet-logger";
+const logger = getLogger(__filename);
 import * as transform from 'sdp-transform';
+import * as SDPUtil from "./SDPUtil";
 
 /**
  * Begin helper functions
@@ -30,39 +33,16 @@ function getPrimarySsrc (videoMLine) {
         if (videoMLine.ssrcGroups) {
             let simGroup = findGroup(videoMLine, "SIM");
             if (simGroup) {
-                return parseInt(simGroup.ssrcs.split(" ")[0]);
+                return SDPUtil.parseGroupSsrcs(simGroup)[0];
             }
             let fidGroup = findGroup(videoMLine, "FID");
             if (fidGroup) {
-                return parseInt(fidGroup.ssrcs.split(" ")[0]);
+                return SDPUtil.parseGroupSsrcs(fidGroup)[0];
             }
         }
     }
 }
 
-/**
- * Given a video mline (as parsed from transform.parse),
- *  and a primary ssrc, return the corresponding rtx ssrc
- *  (if there is one) for that video ssrc
- * @param {object} videoMLine the video MLine from which to extract the
- *  rtx video ssrc
- * @param {number} primarySsrc the video ssrc for which to find the
- *  corresponding rtx ssrc
- * @returns {number} the rtx ssrc (or undefined if there isn't one)
- */
-function getRtxSsrc (videoMLine, primarySsrc) {
-    if (videoMLine.ssrcGroups) {
-        let fidGroup = videoMLine.ssrcGroups.find(group => {
-            if (group.semantics === "FID") {
-                let groupPrimarySsrc = parseInt(group.ssrcs.split(" ")[0]);
-                return groupPrimarySsrc === primarySsrc;
-            }
-        });
-        if (fidGroup) {
-          return parseInt(fidGroup.ssrcs.split(" ")[1]);
-        }
-    }
-}
 /**
  * End helper functions
  */
@@ -71,8 +51,8 @@ function getRtxSsrc (videoMLine, primarySsrc) {
  * Handles the work of keeping video ssrcs consistent across multiple
  * o/a cycles, making it such that all stream operations can be
  * kept local and do not need to be signaled.
- * NOTE: This only keeps the 'primary' video ssrcs consistent: meaning
- * the primary video stream and an associated RTX stream, if it exists
+ * NOTE: This only keeps the 'primary' video ssrc consistent: meaning
+ * the primary video stream
  */
 export default class SdpConsistency {
     /**
@@ -89,7 +69,6 @@ export default class SdpConsistency {
      */
     clearSsrcCache () {
         this.cachedPrimarySsrc = null;
-        this.cachedPrimaryRtxSsrc = null;
     }
 
     /**
@@ -118,7 +97,7 @@ export default class SdpConsistency {
         let videoMLine =
             parsedSdp.media.find(mLine => mLine.type === "video");
         if (videoMLine.direction === "inactive") {
-            console.log("Sdp-consistency doing nothing, " +
+            logger.info("Sdp-consistency doing nothing, " +
                 "video mline is inactive");
             return sdpStr;
         }
@@ -133,44 +112,36 @@ export default class SdpConsistency {
                     value: "recvonly-" + this.cachedPrimarySsrc
                 });
             } else {
-                console.error("No SSRC found for the recvonly video stream!");
+                logger.error("No SSRC found for the recvonly video stream!");
             }
         } else {
             let newPrimarySsrc = getPrimarySsrc(videoMLine);
             if (!newPrimarySsrc) {
-                console.log("Sdp-consistency couldn't parse new primary ssrc");
+                logger.info("Sdp-consistency couldn't parse new primary ssrc");
                 return sdpStr;
             }
-            let newPrimaryRtxSsrc =
-                getRtxSsrc(videoMLine, newPrimarySsrc);
             if (!this.cachedPrimarySsrc) {
                 this.cachedPrimarySsrc = newPrimarySsrc;
-                this.cachedPrimaryRtxSsrc = newPrimaryRtxSsrc;
-                console.log("Sdp-consistency caching primary ssrc " +
-                    this.cachedPrimarySsrc + " and rtx " +
-                    this.cachedPrimaryRtxSsrc);
+                logger.info("Sdp-consistency caching primary ssrc " + 
+                    this.cachedPrimarySsrc);
             } else {
-                console.log("Sdp-consistency replacing new ssrc " +
-                    newPrimarySsrc + " with cached " + this.cachedPrimarySsrc +
-                    " and new rtx " + newPrimaryRtxSsrc + " with cached " +
-                    this.cachedPrimaryRtxSsrc);
-                let self = this;
+                logger.info("Sdp-consistency replacing new ssrc " + 
+                    newPrimarySsrc + " with cached " + this.cachedPrimarySsrc);
                 videoMLine.ssrcs.forEach(ssrcInfo => {
                     if (ssrcInfo.id === newPrimarySsrc) {
-                        ssrcInfo.id = self.cachedPrimarySsrc;
-                    } else if (ssrcInfo.id === newPrimaryRtxSsrc) {
-                        ssrcInfo.id = self.cachedPrimaryRtxSsrc;
+                        ssrcInfo.id = this.cachedPrimarySsrc;
                     }
                 });
                 if (videoMLine.ssrcGroups) {
                     videoMLine.ssrcGroups.forEach(group => {
                         if (group.semantics === "FID") {
-                            let primarySsrc =
-                                parseInt(group.ssrcs.split(" ")[0]);
-                            if (primarySsrc == self.cachedPrimarySsrc) {
-                                group.ssrcs =
-                                    self.cachedPrimarySsrc + " " +
-                                        self.cachedPrimaryRtxSsrc;
+                            let fidGroupSsrcs = SDPUtil.parseGroupSsrcs(group);
+                            let primarySsrc = fidGroupSsrcs[0];
+                            let rtxSsrc = fidGroupSsrcs[1];
+                            if (primarySsrc === newPrimarySsrc) {
+                                group.ssrcs = 
+                                    this.cachedPrimarySsrc + " " + 
+                                        rtxSsrc;
                             }
                         }
                     });

modules/xmpp/TraceablePeerConnection.js

@@ -3,10 +3,10 @@
 import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
 import SdpConsistency from "./SdpConsistency.js";
+import RtxModifier from "./RtxModifier.js";
 var RTCBrowserType = require("../RTC/RTCBrowserType.js");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var transform = require('sdp-transform');
-var RandomUtil = require('../util/RandomUtil');
 var SDP = require("./SDP");
 var SDPUtil = require("./SDPUtil");
 
@@ -34,6 +34,7 @@ function TraceablePeerConnection(ice_config, constraints, session) {
     this.simulcast = new Simulcast({numOfLayers: SIMULCAST_LAYERS,
         explodeRemoteSimulcast: false});
     this.sdpConsistency = new SdpConsistency();
+    this.rtxModifier = new RtxModifier();
     this.eventEmitter = this.session.room.eventEmitter;
 
     // override as desired
@@ -317,7 +318,29 @@ TraceablePeerConnection.prototype.addStream = function (stream, ssrcInfo) {
         this.peerconnection.addStream(stream);
     if (ssrcInfo && ssrcInfo.type === "addMuted") {
         this.sdpConsistency.setPrimarySsrc(ssrcInfo.ssrc.ssrcs[0]);
-        this.simulcast.setSsrcCache(ssrcInfo.ssrc.ssrcs);
+        const simGroup = 
+            ssrcInfo.ssrc.groups.find(groupInfo => {
+                return groupInfo.group.semantics === "SIM";
+            });
+        if (simGroup) {
+            const simSsrcs = SDPUtil.parseGroupSsrcs(simGroup.group);
+            this.simulcast.setSsrcCache(simSsrcs);
+        }
+        const fidGroups =
+            ssrcInfo.ssrc.groups.filter(groupInfo => {
+                return groupInfo.group.semantics === "FID";
+            });
+        if (fidGroups) {
+            const rtxSsrcMapping = new Map();
+            fidGroups.forEach(fidGroup => {
+                const fidGroupSsrcs = 
+                    SDPUtil.parseGroupSsrcs(fidGroup.group);
+                const primarySsrc = fidGroupSsrcs[0];
+                const rtxSsrc = fidGroupSsrcs[1];
+                rtxSsrcMapping.set(primarySsrc, rtxSsrc);
+            });
+            this.rtxModifier.setSsrcCache(rtxSsrcMapping);
+        }
     }
 };
 
@@ -366,6 +389,9 @@ TraceablePeerConnection.prototype.setRemoteDescription
     description = this.simulcast.mungeRemoteDescription(description);
     this.trace('setRemoteDescription::postTransform (simulcast)', dumpSDP(description));
 
+    description.sdp = this.rtxModifier.implodeRemoteRtxSsrcs(description.sdp);
+    this.trace('setRemoteDescription::postTransform (implodeRemoteRtxSsrcs)', dumpSDP(description));
+
     // if we're running on FF, transform to Plan A first.
     if (RTCBrowserType.usesUnifiedPlan()) {
         description = this.interop.toUnifiedPlan(description);
@@ -515,6 +541,13 @@ TraceablePeerConnection.prototype.createAnswer
                         dumpSDP(answer));
                 }
 
+                if (!this.session.room.options.disableRtx) {
+                    answer.sdp = this.rtxModifier.modifyRtxSsrcs(answer.sdp);
+                    this.trace(
+                        'createAnswerOnSuccess::postTransform (rtx modifier)',
+                        dumpSDP(answer));
+                }
+
                 // Fix the setup attribute (see _fixAnswerRFC4145Setup for
                 //  details)
                 let remoteDescription = new SDP(this.remoteDescription.sdp);
@@ -583,18 +616,39 @@ TraceablePeerConnection.prototype.getStats = function(callback, errback) {
  * - groups - Array of the groups associated with the stream.
  */
 TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function () {
+    let ssrcInfo = {ssrcs: [], groups: []};
     if (!this.session.room.options.disableSimulcast
         && this.simulcast.isSupported()) {
-        var ssrcInfo = {ssrcs: [], groups: []};
-        for(var i = 0; i < SIMULCAST_LAYERS; i++)
-            ssrcInfo.ssrcs.push(RandomUtil.randomInt(1, 0xffffffff));
+        for (let i = 0; i < SIMULCAST_LAYERS; i++) {
+            ssrcInfo.ssrcs.push(SDPUtil.generateSsrc());
+        }
         ssrcInfo.groups.push({
             primarySSRC: ssrcInfo.ssrcs[0],
             group: {ssrcs: ssrcInfo.ssrcs.join(" "), semantics: "SIM"}});
-        return ssrcInfo;
+        ssrcInfo;
     } else {
-        return {ssrcs: [RandomUtil.randomInt(1, 0xffffffff)], groups: []};
+        ssrcInfo = {ssrcs: [SDPUtil.generateSsrc()], groups: []};
+    }
+    if (!this.session.room.options.disableRtx) {
+        // Specifically use a for loop here because we'll
+        //  be adding to the list we're iterating over, so we
+        //  only want to iterate through the items originally
+        //  on the list
+        const currNumSsrcs = ssrcInfo.ssrcs.length;
+        for (let i = 0; i < currNumSsrcs; ++i) {
+            const primarySsrc = ssrcInfo.ssrcs[i];
+            const rtxSsrc = SDPUtil.generateSsrc();
+            ssrcInfo.ssrcs.push(rtxSsrc);
+            ssrcInfo.groups.push({
+                primarySSRC: primarySsrc,
+                group: { 
+                    ssrcs: primarySsrc + " " + rtxSsrc,
+                    semantics: "FID"
+                }
+            });
+        }
     }
+    return ssrcInfo;
 };
 
 module.exports = TraceablePeerConnection;

modules/xmpp/moderator.js

@@ -165,15 +165,13 @@ Moderator.prototype.createConferenceIq =  function () {
                 value: value
             }).up();
     }
-    // TODO: re-enable once rtx is stable
-    //if (this.options.conference.disableRtx !== undefined) {
+    if (this.options.conference.disableRtx !== undefined) {
         elem.c(
             'property', {
                 name: 'disableRtx',
-                //value: this.options.conference.disableRtx
-                value: true
+                value: this.options.conference.disableRtx
             }).up();
-    //}
+    }
     elem.c(
         'property', {
             name: 'enableLipSync',