Changes video mute/unmute implementation. JitsiLocalTrack objects store information about the SSRCs. On video mute / unmute operation no jingle packets are sent anymore.

JitsiConference.js

@@ -286,6 +286,17 @@ JitsiConference.prototype.addTrack = function (track) {
             }
         });
     }
+
+    track.ssrcHandler = function (conference, ssrcMap) {
+        if(ssrcMap[this.getMSID()]){
+            this._setSSRC(ssrcMap[this.getMSID()]);
+            conference.room.removeListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+                this.ssrcHandler);
+        }
+    }.bind(track, this);
+    this.room.addListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+        track.ssrcHandler);
+
     return new Promise(function (resolve) {
         this.room.addStream(track.getOriginalStream(), function () {
             this.rtc.addLocalStream(track);
@@ -309,6 +320,8 @@ JitsiConference.prototype.addTrack = function (track) {
                                    track.stopHandler);
             track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
                                    track.audioLevelHandler);
+            //FIXME: This dependacy is not necessary. This is quick fix.
+            track._setConference(this);
             this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
             resolve(track);
         }.bind(this));
@@ -354,13 +367,24 @@ JitsiConference.prototype.removeTrack = function (track) {
     }
     return new Promise(function (resolve) {
         this.room.removeStream(track.getOriginalStream(), function(){
+            track._setSSRC(null);
+            //FIXME: This dependacy is not necessary. This is quick fix.
+            track._setConference(this);
             this.rtc.removeLocalStream(track);
-            track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED, track.muteHandler);
-            track.removeEventListener(JitsiTrackEvents.TRACK_STOPPED, track.stopHandler);
-            track.removeEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED, track.audioLevelHandler);
+            track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
+                track.muteHandler);
+            track.removeEventListener(JitsiTrackEvents.TRACK_STOPPED,
+                track.stopHandler);
+            track.removeEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
+                track.audioLevelHandler);
+            this.room.removeListener(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+                track.ssrcHandler);
             this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
             resolve();
-        }.bind(this));
+        }.bind(this), {
+            mtype: track.getType(),
+            type: "remove",
+            ssrc: track.ssrc});
     }.bind(this));
 };
 
@@ -1053,7 +1077,9 @@ function setupListeners(conference) {
         }
 
         if (updated) {
-            conference.eventEmitter.emit(JitsiConferenceEvents.AVAILABLE_DEVICES_CHANGED, from, availableDevices);
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.AVAILABLE_DEVICES_CHANGED,
+                from, availableDevices);
         }
     });
 

modules/RTC/JitsiLocalTrack.js

@@ -15,7 +15,9 @@ function JitsiLocalTrack(stream, videoType,
     this.resolution = resolution;
     this.deviceId = deviceId;
     this.startMuted = false;
-    var self = this;
+    this.ssrc = null;
+    //FIXME: This dependacy is not necessary.
+    this.conference = null;
     JitsiTrack.call(this, null, stream,
         function () {
             if(!this.dontFireRemoveEvent)
@@ -23,7 +25,6 @@ function JitsiLocalTrack(stream, videoType,
                     JitsiTrackEvents.TRACK_STOPPED);
             this.dontFireRemoveEvent = false;
         }.bind(this));
-
 }
 
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);
@@ -61,7 +62,8 @@ JitsiLocalTrack.prototype._setMute = function (mute) {
     } else {
         if (mute) {
             this.dontFireRemoveEvent = true;
-            this.rtc.room.removeStream(this.stream, function () {});
+            this.rtc.room.removeStream(this.stream, function () {},
+                {mtype: this.type, type: "mute", ssrc: this.ssrc});
             RTCUtils.stopMediaStream(this.stream);
             if(isAudio)
                 this.rtc.room.setAudioMute(mute);
@@ -103,7 +105,7 @@ JitsiLocalTrack.prototype._setMute = function (mute) {
                                     self.containers[i], self.stream);
                     }
 
-                    self.rtc.room.addStream(stream.stream,
+                    self.rtc.room.addStream(self.stream,
                         function () {
                             if(isAudio)
                                 self.rtc.room.setAudioMute(mute);
@@ -111,7 +113,11 @@ JitsiLocalTrack.prototype._setMute = function (mute) {
                                 self.rtc.room.setVideoMute(mute);
                             self.eventEmitter.emit(
                                 JitsiTrackEvents.TRACK_MUTE_CHANGED);
-                        });
+                        }, {
+                            mtype: self.type,
+                            type: "unmute",
+                            ssrc: self.ssrc,
+                            msid: self.getMSID()});
                 });
         }
     }
@@ -122,10 +128,11 @@ JitsiLocalTrack.prototype._setMute = function (mute) {
  * NOTE: Works for local tracks only.
  */
 JitsiLocalTrack.prototype.stop = function () {
+    if(this.conference){
+        this.conference.removeTrack(this);
+    }
     if(!this.stream)
         return;
-    if(this.rtc)
-        this.rtc.room.removeStream(this.stream, function () {});
     RTCUtils.stopMediaStream(this.stream);
     this.detach();
 }
@@ -163,6 +170,25 @@ JitsiLocalTrack.prototype._setRTC = function (rtc) {
     this.rtc = rtc;
 };
 
+/**
+ * Updates the SSRC associated with the MediaStream in JitsiLocalTrack object.
+ * @ssrc the new ssrc
+ */
+JitsiLocalTrack.prototype._setSSRC = function (ssrc) {
+    this.ssrc = ssrc;
+}
+
+
+//FIXME: This dependacy is not necessary. This is quick fix.
+/**
+ * Sets the JitsiConference object associated with the track. This is temp
+ * solution.
+ * @param conference the JitsiConference object
+ */
+JitsiLocalTrack.prototype._setConference = function(conference) {
+    this.conference = conference;
+}
+
 /**
  * Gets the SSRC of this local track if it's available already or <tt>null</tt>
  * otherwise. That's because we don't know the SSRC until local description is

modules/RTC/JitsiTrack.js

@@ -77,23 +77,24 @@ function JitsiTrack(rtc, stream, streamInactiveHandler, jitsiTrackType)
     this.stream = stream;
     this.eventEmitter = new EventEmitter();
     this.audioLevel = -1;
-    this.type = jitsiTrackType || (this.stream.getVideoTracks().length > 0)?
-        JitsiTrack.VIDEO : JitsiTrack.AUDIO;
+    this.type = jitsiTrackType || ((this.stream.getVideoTracks().length > 0)?
+        JitsiTrack.VIDEO : JitsiTrack.AUDIO);
     if(this.type == JitsiTrack.AUDIO) {
         this._getTracks = function () {
-            return this.stream.getAudioTracks();
+            return this.stream? this.stream.getAudioTracks() : [];
         }.bind(this);
     } else {
         this._getTracks = function () {
-            return this.stream.getVideoTracks();
+            return this.stream? this.stream.getVideoTracks() : [];
         }.bind(this);
     }
-    if (RTCBrowserType.isFirefox() && this.stream) {
-        implementOnEndedHandling(this);
-    }
 
-    if(stream)
+    if(stream) {
+        if (RTCBrowserType.isFirefox()) {
+            implementOnEndedHandling(this);
+        }
         addMediaStreamInactiveHandler(stream, streamInactiveHandler);
+    }
 }
 
 /**
@@ -310,4 +311,15 @@ JitsiTrack.prototype.setAudioLevel = function (audioLevel) {
     }
  }
 
+/**
+ * Returns the msid of the stream attached to the JitsiTrack object or null if
+ * no stream is attached.
+ */
+JitsiTrack.prototype.getMSID = function () {
+    var tracks, track;
+    return (!this.stream || !this.stream.id || !(tracks = this._getTracks()) ||
+        !tracks.length || !(track = tracks[0]) || !track.id)?
+            null : this.stream.id + " " + track.id;
+}
+
 module.exports = JitsiTrack;

modules/xmpp/ChatRoom.js

@@ -562,29 +562,18 @@ ChatRoom.prototype.setJingleSession = function(session){
 };
 
 
-ChatRoom.prototype.removeStream = function (stream, callback) {
+ChatRoom.prototype.removeStream = function (stream, callback, ssrcInfo) {
     if(!this.session) {
         callback();
         return;
     }
-    this.session.removeStream(stream, callback);
+    this.session.removeStream(stream, callback, ssrcInfo);
 };
 
-ChatRoom.prototype.switchStreams = function (stream, oldStream, callback, isAudio) {
+ChatRoom.prototype.addStream = function (stream, callback, ssrcInfo) {
     if(this.session) {
         // FIXME: will block switchInProgress on true value in case of exception
-        this.session.switchStreams(stream, oldStream, callback, isAudio);
-    } else {
-        // We are done immediately
-        logger.warn("No conference handler or conference not started yet");
-        callback();
-    }
-};
-
-ChatRoom.prototype.addStream = function (stream, callback) {
-    if(this.session) {
-        // FIXME: will block switchInProgress on true value in case of exception
-        this.session.addStream(stream, callback);
+        this.session.addStream(stream, callback, ssrcInfo);
     } else {
         // We are done immediately
         logger.warn("No conference handler or conference not started yet");

modules/xmpp/JingleSessionPC.js

@@ -21,7 +21,6 @@ function JingleSessionPC(me, sid, connection, service) {
     this.state = null;
     this.localSDP = null;
     this.remoteSDP = null;
-    this.relayedStreams = [];
 
     this.usetrickle = true;
     this.usepranswer = false; // early transport warmup -- mind you, this might fail. depends on webrtc issue 1718
@@ -37,8 +36,8 @@ function JingleSessionPC(me, sid, connection, service) {
     this.addssrc = [];
     this.removessrc = [];
     this.pendingop = null;
-    this.switchstreams = false;
-    this.addingStreams = false;
+    this.modifyingLocalStreams = false;
+    this.modifiedSSRCs = {};
 
     /**
      * A map that stores SSRCs of local streams
@@ -182,10 +181,6 @@ JingleSessionPC.prototype.doInitialize = function () {
     this.peerconnection.onnegotiationneeded = function (event) {
         self.room.eventEmitter.emit(XMPPEvents.PEERCONNECTION_READY, self);
     };
-
-    this.relayedStreams.forEach(function(stream) {
-        self.peerconnection.addStream(stream);
-    });
 };
 
 function onIceConnectionStateChange(sid, session) {
@@ -461,81 +456,6 @@ JingleSessionPC.prototype.sendIceCandidates = function (candidates) {
         10000);
 };
 
-
-JingleSessionPC.prototype.sendOffer = function () {
-    //logger.log('sendOffer...');
-    var self = this;
-    this.peerconnection.createOffer(function (sdp) {
-            self.createdOffer(sdp);
-        },
-        function (e) {
-            logger.error('createOffer failed', e);
-        },
-        this.media_constraints
-    );
-};
-
-// FIXME createdOffer is never used in jitsi-meet
-JingleSessionPC.prototype.createdOffer = function (sdp) {
-    //logger.log('createdOffer', sdp);
-    var self = this;
-    this.localSDP = new SDP(sdp.sdp);
-    //this.localSDP.mangle();
-    var sendJingle = function () {
-        var init = $iq({to: this.peerjid,
-            type: 'set'})
-            .c('jingle', {xmlns: 'urn:xmpp:jingle:1',
-                action: 'session-initiate',
-                initiator: this.initiator,
-                sid: this.sid});
-        self.localSDP.toJingle(
-            init,
-            this.initiator == this.me ? 'initiator' : 'responder');
-
-        self.connection.sendIQ(init,
-            function () {
-                var ack = {};
-                ack.source = 'offer';
-                $(document).trigger('ack.jingle', [self.sid, ack]);
-            },
-            function (stanza) {
-                self.state = 'error';
-                self.peerconnection.close();
-                var error = ($(stanza).find('error').length) ? {
-                    code: $(stanza).find('error').attr('code'),
-                    reason: $(stanza).find('error :first')[0].tagName,
-                }:{};
-                error.source = 'offer';
-                JingleSessionPC.onJingleError(self.sid, error);
-            },
-            10000);
-    }
-    sdp.sdp = this.localSDP.raw;
-    this.peerconnection.setLocalDescription(sdp,
-        function () {
-            if(self.usetrickle)
-            {
-                sendJingle();
-            }
-            self.setLocalDescription();
-            //logger.log('setLocalDescription success');
-        },
-        function (e) {
-            logger.error('setLocalDescription failed', e);
-            self.room.eventEmitter.emit(XMPPEvents.CONFERENCE_SETUP_FAILED);
-        }
-    );
-    var cands = SDPUtil.find_lines(this.localSDP.raw, 'a=candidate:');
-    for (var i = 0; i < cands.length; i++) {
-        var cand = SDPUtil.parse_icecandidate(cands[i]);
-        if (cand.type == 'srflx') {
-            this.hadstuncandidate = true;
-        } else if (cand.type == 'relay') {
-            this.hadturncandidate = true;
-        }
-    }
-};
-
 JingleSessionPC.prototype.readSsrcInfo = function (contents) {
     var self = this;
     $(contents).each(function (idx, content) {
@@ -1032,7 +952,7 @@ JingleSessionPC.prototype._modifySources = function (successCallback, queueCallb
 
     if (this.peerconnection.signalingState == 'closed') return;
     if (!(this.addssrc.length || this.removessrc.length || this.pendingop !== null
-        || this.switchstreams || this.addingStreams)){
+        || this.modifyingLocalStreams)){
         // There is nothing to do since scheduled job might have been executed by another succeeding call
         this.setLocalDescription();
         if(successCallback){
@@ -1043,8 +963,7 @@ JingleSessionPC.prototype._modifySources = function (successCallback, queueCallb
     }
 
     // Reset switch streams flags
-    this.switchstreams = false;
-    this.addingStreams = false;
+    this.modifyingLocalStreams = false;
 
     var sdp = new SDP(this.peerconnection.remoteDescription.sdp);
 
@@ -1128,91 +1047,12 @@ JingleSessionPC.prototype._modifySources = function (successCallback, queueCallb
     );
 };
 
-
-/**
- * Switches video streams.
- * @param newStream new stream that will be used as video of this session.
- * @param oldStream old video stream of this session.
- * @param successCallback callback executed after successful stream switch.
- * @param isAudio whether the streams are audio (if true) or video (if false).
- */
-JingleSessionPC.prototype.switchStreams =
-    function (newStream, oldStream, successCallback, isAudio) {
-    var self = this;
-    var sender, newTrack;
-    var senderKind = isAudio ? 'audio' : 'video';
-    // Remember SDP to figure out added/removed SSRCs
-    var oldSdp = null;
-
-    if (self.peerconnection) {
-        if (self.peerconnection.localDescription) {
-            oldSdp = new SDP(self.peerconnection.localDescription.sdp);
-        }
-        if (RTCBrowserType.getBrowserType() ===
-                RTCBrowserType.RTC_BROWSER_FIREFOX) {
-            // On Firefox we don't replace MediaStreams as this messes up the
-            // m-lines (which can't be removed in Plan Unified) and brings a lot
-            // of complications. Instead, we use the RTPSender and replace just
-            // the track.
-
-            // Find the right sender (for audio or video)
-            self.peerconnection.peerconnection.getSenders().some(function (s) {
-                if (s.track && s.track.kind === senderKind) {
-                    sender = s;
-                    return true;
-                }
-            });
-
-            if (sender) {
-                // We assume that our streams have a single track, either audio
-                // or video.
-                newTrack = isAudio ? newStream.getAudioTracks()[0] :
-                    newStream.getVideoTracks()[0];
-                sender.replaceTrack(newTrack)
-                    .then(function() {
-                        console.log("Replaced a track, isAudio=" + isAudio);
-                    })
-                    .catch(function(err) {
-                        console.log("Failed to replace a track: " + err);
-                    });
-            } else {
-                console.log("Cannot switch tracks: no RTPSender.");
-            }
-        } else {
-            self.peerconnection.removeStream(oldStream, true);
-            if (newStream) {
-                self.peerconnection.addStream(newStream);
-            }
-        }
-    }
-
-    // Conference is not active
-    if (!oldSdp) {
-        successCallback();
-        return;
-    }
-
-    self.switchstreams = true;
-    self.modifySourcesQueue.push(function() {
-        logger.log('modify sources done');
-
-        successCallback();
-
-        var newSdp = new SDP(self.peerconnection.localDescription.sdp);
-        logger.log("SDPs", oldSdp, newSdp);
-        self.notifyMySSRCUpdate(oldSdp, newSdp);
-    });
-};
-
 /**
  * Adds streams.
  * @param stream new stream that will be added.
  * @param success_callback callback executed after successful stream addition.
  */
-JingleSessionPC.prototype.addStream = function (stream, callback) {
-
-    var self = this;
-
+JingleSessionPC.prototype.addStream = function (stream, callback, ssrcInfo) {
     // Remember SDP to figure out added/removed SSRCs
     var oldSdp = null;
     if(this.peerconnection) {
@@ -1220,7 +1060,7 @@ JingleSessionPC.prototype.addStream = function (stream, callback) {
             oldSdp = new SDP(this.peerconnection.localDescription.sdp);
         }
         if(stream)
-            this.peerconnection.addStream(stream);
+            this.peerconnection.addStream(stream, ssrcInfo);
     }
 
     // Conference is not active
@@ -1229,12 +1069,17 @@ JingleSessionPC.prototype.addStream = function (stream, callback) {
         return;
     }
 
-    this.addingStreams = true;
+    this.modifyingLocalStreams = true;
+    var self = this;
     this.modifySourcesQueue.push(function() {
         logger.log('modify sources done');
 
         callback();
-
+        if(ssrcInfo) { //available only on video unmute
+            self.modifiedSSRCs[ssrcInfo.type] =
+                self.modifiedSSRCs[ssrcInfo.type] || [];
+            self.modifiedSSRCs[ssrcInfo.type].push(ssrcInfo);
+        }
         var newSdp = new SDP(self.peerconnection.localDescription.sdp);
         logger.log("SDPs", oldSdp, newSdp);
         self.notifyMySSRCUpdate(oldSdp, newSdp);
@@ -1246,10 +1091,7 @@ JingleSessionPC.prototype.addStream = function (stream, callback) {
  * @param stream stream that will be removed.
  * @param success_callback callback executed after successful stream addition.
  */
-JingleSessionPC.prototype.removeStream = function (stream, callback) {
-
-    var self = this;
-
+JingleSessionPC.prototype.removeStream = function (stream, callback, ssrcInfo) {
     // Remember SDP to figure out added/removed SSRCs
     var oldSdp = null;
     if(this.peerconnection) {
@@ -1258,10 +1100,12 @@ JingleSessionPC.prototype.removeStream = function (stream, callback) {
         }
         if (RTCBrowserType.getBrowserType() ===
                 RTCBrowserType.RTC_BROWSER_FIREFOX) {
+            if(!stream)//There is nothing to be changed
+                return;
             var sender = null;
             // On Firefox we don't replace MediaStreams as this messes up the
             // m-lines (which can't be removed in Plan Unified) and brings a lot
-            // of complications. Instead, we use the RTPSender and replace just
+            // of complications. Instead, we use the RTPSender and remove just
             // the track.
             var track = null;
             if(stream.getAudioTracks() && stream.getAudioTracks().length) {
@@ -1272,7 +1116,7 @@ JingleSessionPC.prototype.removeStream = function (stream, callback) {
             }
 
             if(!track) {
-                console.log("Cannot switch tracks: no tracks.");
+                logger.log("Cannot remove tracks: no tracks.");
                 return;
             }
 
@@ -1286,17 +1130,15 @@ JingleSessionPC.prototype.removeStream = function (stream, callback) {
 
             if (sender) {
                 self.peerconnection.peerconnection.removeTrack(sender);
-                    // .then(function() {
-                    //     console.log("Replaced a track, isAudio=" + isAudio);
-                    // })
-                    // .catch(function(err) {
-                    //     console.log("Failed to replace a track: " + err);
-                    // });
             } else {
-                console.log("Cannot switch tracks: no RTPSender.");
+                logger.log("Cannot remove tracks: no RTPSender.");
             }
         } else if(stream)
-            this.peerconnection.removeStream(stream);
+            this.peerconnection.removeStream(stream, false, ssrcInfo);
+        // else
+        // NOTE: If there is no stream and the browser is not FF we still need to do
+        // some transformation in order to send remove-source for the muted
+        // streams. That's why we aren't calling return here.
     }
 
     // Conference is not active
@@ -1305,13 +1147,19 @@ JingleSessionPC.prototype.removeStream = function (stream, callback) {
         return;
     }
 
-    this.addingStreams = true;
+    this.modifyingLocalStreams = true;
+    var self = this;
     this.modifySourcesQueue.push(function() {
         logger.log('modify sources done');
 
         callback();
 
         var newSdp = new SDP(self.peerconnection.localDescription.sdp);
+        if(ssrcInfo) {
+            self.modifiedSSRCs[ssrcInfo.type] =
+                self.modifiedSSRCs[ssrcInfo.type] || [];
+            self.modifiedSSRCs[ssrcInfo.type].push(ssrcInfo);
+        }
         logger.log("SDPs", oldSdp, newSdp);
         self.notifyMySSRCUpdate(oldSdp, newSdp);
     });
@@ -1340,7 +1188,8 @@ JingleSessionPC.prototype.notifyMySSRCUpdate = function (old_sdp, new_sdp) {
             sid: this.sid
         }
     );
-    var removed = sdpDiffer.toJingle(remove);
+    sdpDiffer.toJingle(remove);
+    var removed = this.fixJingle(remove);
 
     if (removed && remove) {
         logger.info("Sending source-remove", remove);
@@ -1366,7 +1215,9 @@ JingleSessionPC.prototype.notifyMySSRCUpdate = function (old_sdp, new_sdp) {
             sid: this.sid
         }
     );
-    var added = sdpDiffer.toJingle(add);
+
+    sdpDiffer.toJingle(add);
+    var added = this.fixJingle(add);
 
     if (added && add) {
         logger.info("Sending source-add", add);
@@ -1563,4 +1414,132 @@ JingleSessionPC.prototype.getIceConnectionState = function () {
     return this.peerconnection.iceConnectionState;
 }
 
+
+/**
+ * Fixes the outgoing jingle packets by removing the nodes related to the
+ * muted/unmuted streams, handles removing of muted stream, etc.
+ * @param jingle the jingle packet that is going to be sent
+ * @returns {boolean} true if the jingle has to be sent and false otherwise.
+ */
+JingleSessionPC.prototype.fixJingle = function(jingle) {
+    var action = $(jingle.nodeTree).find("jingle").attr("action");
+    switch (action) {
+        case "source-add":
+            this.fixSourceAddJingle(jingle);
+            break;
+        case "source-remove":
+            this.fixSourceRemoveJingle(jingle);
+            break;
+        default:
+            logger.error("Unknown jingle action!");
+            return false;
+    }
+
+    var sources = $(jingle.tree()).find(">jingle>content>description>source");
+    return sources && sources.length > 0;
+}
+
+/**
+ * Fixes the outgoing jingle packets with action source-add by removing the
+ * nodes related to the unmuted streams
+ * @param jingle the jingle packet that is going to be sent
+ * @returns {boolean} true if the jingle has to be sent and false otherwise.
+ */
+JingleSessionPC.prototype.fixSourceAddJingle = function (jingle) {
+    var ssrcs = this.modifiedSSRCs["unmute"];
+    this.modifiedSSRCs["unmute"] = [];
+    if(ssrcs && ssrcs.length) {
+        ssrcs.forEach(function (ssrcObj) {
+            var desc = $(jingle.tree()).find(">jingle>content[name=\"" +
+                ssrcObj.mtype + "\"]>description");
+            if(!desc || !desc.length)
+                return;
+            ssrcObj.ssrc.ssrcs.forEach(function (ssrc) {
+                var sourceNode = desc.find(">source[ssrc=\"" +
+                    ssrc + "\"]");
+                sourceNode.remove();
+            });
+            ssrcObj.ssrc.groups.forEach(function (group) {
+                var groupNode = desc.find(">ssrc-group[semantics=\"" +
+                    group.group.semantics + "\"]:has(source[ssrc=\"" +
+                    group.primarySSRC +
+                     "\"])");
+                groupNode.remove();
+            });
+        });
+    }
+}
+
+/**
+ * Fixes the outgoing jingle packets with action source-remove by removing the
+ * nodes related to the muted streams, handles removing of muted stream
+ * @param jingle the jingle packet that is going to be sent
+ * @returns {boolean} true if the jingle has to be sent and false otherwise.
+ */
+JingleSessionPC.prototype.fixSourceRemoveJingle = function(jingle) {
+    var ssrcs = this.modifiedSSRCs["mute"];
+    this.modifiedSSRCs["mute"] = [];
+    if(ssrcs && ssrcs.length)
+        ssrcs.forEach(function (ssrcObj) {
+            ssrcObj.ssrc.ssrcs.forEach(function (ssrc) {
+                var sourceNode = $(jingle.tree()).find(">jingle>content[name=\"" +
+                    ssrcObj.mtype + "\"]>description>source[ssrc=\"" +
+                    ssrc + "\"]");
+                sourceNode.remove();
+            });
+            ssrcObj.ssrc.groups.forEach(function (group) {
+                var groupNode = $(jingle.tree()).find(">jingle>content[name=\"" +
+                    ssrcObj.mtype + "\"]>description>ssrc-group[semantics=\"" +
+                    group.group.semantics + "\"]:has(source[ssrc=\"" + group.primarySSRC +
+                     "\"])");
+                groupNode.remove();
+            });
+        });
+
+    ssrcs = this.modifiedSSRCs["remove"];
+    this.modifiedSSRCs["remove"] = [];
+    if(ssrcs && ssrcs.length)
+        ssrcs.forEach(function (ssrcObj) {
+            var content = $(jingle.tree()).find(">jingle>content[name=\"" +
+                ssrcObj.mtype + "\"]");
+
+            if(!content || !content.length) {
+                $(jingle.tree()).find(">jingle").append(
+                    "<content name=\"" + ssrcObj.mtype + "\"></content>");
+                content = $(jingle.tree()).find(">jingle>content[name=\"" +
+                    ssrcObj.mtype + "\"]");
+            }
+
+            var desc = content.find(">description");
+            if(!desc || !desc.length) {
+                content.append("<description " +
+                    "xmlns=\"urn:xmpp:jingle:apps:rtp:1\" media=\"" +
+                    ssrcObj.mtype + "\"></description>");
+                desc = content.find(">description");
+            }
+
+            ssrcObj.ssrc.ssrcs.forEach(function (ssrc) {
+                var sourceNode = desc.find(">source[ssrc=\"" +ssrc + "\"]");
+                if(!sourceNode || !sourceNode.length) {
+                    //Maybe we have to include cname, msid, etc here?
+                    desc.append("<source " +
+                        "xmlns=\"urn:xmpp:jingle:apps:rtp:ssma:0\" ssrc=\"" +
+                        ssrc + "\"></source>");
+                }
+            });
+            ssrcObj.ssrc.groups.forEach(function (group) {
+                var groupNode = desc.find(">ssrc-group[semantics=\"" +
+                    group.group.semantics + "\"]:has(source[ssrc=\"" + group.primarySSRC +
+                     "\"])");
+                if(!groupNode || !groupNode.length) {
+                    desc.append("<ssrc-group semantics=\"" +
+                        group.group.semantics +
+                        "\" xmlns=\"urn:xmpp:jingle:apps:rtp:ssma:0\"><source ssrc=\"" +
+                        group.group.ssrcs.split(" ").join("\"/><source ssrc=\"") + "\"/>" +
+                        "</ssrc-group>");
+                }
+            });
+        });
+}
+
 module.exports = JingleSessionPC;

modules/xmpp/TraceablePeerConnection.js

@@ -3,10 +3,15 @@ var RTC = require('../RTC/RTC');
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType.js");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
+var transform = require('sdp-transform');
 
 function TraceablePeerConnection(ice_config, constraints, session) {
     var self = this;
     this.session = session;
+    this.replaceSSRCs = {
+        "audio": [],
+        "video": []
+    };
     this.recvOnlySSRCs = {};
     var RTCPeerConnectionType = null;
     if (RTCBrowserType.isFirefox()) {
@@ -144,14 +149,13 @@ var dumpSDP = function(description) {
  * @param desc the SDP that will be modified.
  * @returns the modified SDP.
  */
-TraceablePeerConnection.prototype.insertRecvOnlySSRC = function (desc) {
+TraceablePeerConnection.prototype.ssrcReplacement = function (desc) {
     if (typeof desc !== 'object' || desc === null ||
         typeof desc.sdp !== 'string') {
         console.warn('An empty description was passed as an argument.');
         return desc;
     }
 
-    var transform = require('sdp-transform');
     var RandomUtil = require('../util/RandomUtil');
 
     var session = transform.parse(desc.sdp);
@@ -162,12 +166,107 @@ TraceablePeerConnection.prototype.insertRecvOnlySSRC = function (desc) {
 
     var modded = false;
     session.media.forEach(function (bLine) {
-        if (bLine.direction != 'recvonly')
-        {
+        if(!this.replaceSSRCs[bLine.type])
             return;
-        }
 
         modded = true;
+        var SSRCs = this.replaceSSRCs[bLine.type].splice(0,1);
+        //FIXME: The code expects that we have only SIM group or we
+        // don't have any groups and we have only one SSRC per
+        // stream. If we add another groups (FID, etc) this code
+        // must be changed.
+        while(SSRCs &&
+            SSRCs.length){
+            var ssrcOperation = SSRCs[0];
+            switch(ssrcOperation.type) {
+                case "mute":
+                //FIXME: If we want to support multiple streams we have to add
+                // recv-only ssrcs for the
+                // muted streams on every change until the stream is unmuted
+                // or removed. Otherwise the recv-only streams won't be included
+                // in the SDP
+                    if(!bLine.ssrcs)
+                        bLine.ssrcs = [];
+                    var groups = ssrcOperation.ssrc.groups;
+                    var ssrc = null;
+                    if(groups && groups.length) {
+                        ssrc = groups[0].primarySSRC;
+                    } else if(ssrcOperation.ssrc.ssrcs &&
+                        ssrcOperation.ssrc.ssrcs.length) {
+                        ssrc = ssrcOperation.ssrc.ssrcs[0];
+                    } else {
+                        logger.error("SSRC replacement error!");
+                        break;
+                    }
+                    bLine.ssrcs.push({
+                        id: ssrc,
+                        attribute: 'cname',
+                        value: ['recvonly-', ssrc].join('')
+                    })
+                    break;
+                case "unmute":
+                    if(!ssrcOperation.ssrc || !ssrcOperation.ssrc.ssrcs ||
+                        !ssrcOperation.ssrc.ssrcs.length)
+                        break;
+                    var ssrcMap = {};
+                    var ssrcLastIdx = ssrcOperation.ssrc.ssrcs.length - 1;
+                    for(var i = 0; i < bLine.ssrcs.length; i++) {
+                        var ssrc = bLine.ssrcs[i];
+                        if (ssrc.attribute !== 'msid' &&
+                            ssrc.value !== ssrcOperation.msid) {
+                            continue;
+                        }
+                        ssrcMap[ssrc.id] =
+                            ssrcOperation.ssrc.ssrcs[ssrcLastIdx];
+                        ssrcLastIdx--;
+                        if(ssrcLastIdx < 0)
+                            break;
+                    }
+                    var groups = ssrcOperation.ssrc.groups;
+                    if (typeof bLine.ssrcGroups !== 'undefined' &&
+                        Array.isArray(bLine.ssrcGroups) && groups &&
+                        groups.length) {
+                        bLine.ssrcGroups.forEach(function (group) {
+                            if(!group.ssrcs)
+                                return;
+                            var currentSSRCs = group.ssrcs.split(" ");
+                            var newGroup = null;
+                            for(var i = 0; i < groups.length; i++) {
+                                newGroup = groups[i].group;
+                                var newSSRCs = newGroup.ssrcs.split(" ");
+                                if(newGroup.semantics !== group.semantics)
+                                    continue;
+                                var wrongGroup = false;
+                                for(var j = 0; j < currentSSRCs.length; j++) {
+                                    if(newGroup.ssrcs.indexOf(
+                                        ssrcMap[currentSSRCs[j]]) === -1){
+                                        wrongGroup = true;
+                                        break;
+                                    }
+                                }
+                                if(!wrongGroup) {
+                                    for(j = 0; j < newSSRCs.length; j++) {
+                                        ssrcMap[currentSSRCs[j]] = newSSRCs[j];
+                                    }
+                                    break;
+                                }
+                            }
+
+                            group.ssrcs = newGroup.ssrcs;
+                        });
+                    }
+                    bLine.ssrcs.forEach(function (ssrc) {
+                        if(ssrcMap[ssrc.id]) {
+                            ssrc.id = ssrcMap[ssrc.id];
+                        }
+                    });
+                    break;
+                default:
+                break;
+            }
+            SSRCs = this.replaceSSRCs[bLine.type].splice(0,1);
+        }
+
         if (!Array.isArray(bLine.ssrcs) || bLine.ssrcs.length === 0)
         {
             var ssrc = this.recvOnlySSRCs[bLine.type]
@@ -187,6 +286,60 @@ TraceablePeerConnection.prototype.insertRecvOnlySSRC = function (desc) {
     });
 };
 
+/**
+ * Returns map with keys msid and values ssrc.
+ * @param desc the SDP that will be modified.
+ */
+function extractSSRCMap(desc) {
+    if (typeof desc !== 'object' || desc === null ||
+        typeof desc.sdp !== 'string') {
+        console.warn('An empty description was passed as an argument.');
+        return desc;
+    }
+
+    var ssrcList = {};
+    var ssrcGroups = {};
+    var session = transform.parse(desc.sdp);
+    if (!Array.isArray(session.media))
+    {
+        return;
+    }
+
+    session.media.forEach(function (bLine) {
+        if (!Array.isArray(bLine.ssrcs))
+        {
+            return;
+        }
+
+        if (typeof bLine.ssrcGroups !== 'undefined' &&
+            Array.isArray(bLine.ssrcGroups)) {
+            bLine.ssrcGroups.forEach(function (group) {
+                if (typeof group.semantics !== 'undefined' &&
+                    typeof group.ssrcs !== 'undefined') {
+                    var primarySSRC = Number(group.ssrcs.split(' ')[0]);
+                    ssrcGroups[primarySSRC] = ssrcGroups[primarySSRC] || [];
+                    ssrcGroups[primarySSRC].push(group);
+                }
+            });
+        }
+        bLine.ssrcs.forEach(function (ssrc) {
+            if(ssrc.attribute !== 'msid')
+                return;
+            ssrcList[ssrc.value] = ssrcList[ssrc.value] ||
+                {groups: [], ssrcs: []};
+            ssrcList[ssrc.value].ssrcs.push(ssrc.id);
+            if(ssrcGroups[ssrc.id]){
+                ssrcGroups[ssrc.id].forEach(function (group) {
+                    ssrcList[ssrc.value].groups.push(
+                        {primarySSRC: ssrc.id, group: group});
+                });
+            }
+        });
+    });
+
+    return ssrcList;
+}
+
 /**
  * Takes a SessionDescription object and returns a "normalized" version.
  * Currently it only takes care of ordering the a=ssrc lines.
@@ -201,8 +354,8 @@ var normalizePlanB = function(desc) {
     var transform = require('sdp-transform');
     var session = transform.parse(desc.sdp);
 
-    if (typeof session !== 'undefined' && typeof session.media !== 'undefined' &&
-        Array.isArray(session.media)) {
+    if (typeof session !== 'undefined' &&
+        typeof session.media !== 'undefined' && Array.isArray(session.media)) {
         session.media.forEach(function (mLine) {
 
             // Chrome appears to be picky about the order in which a=ssrc lines
@@ -215,7 +368,8 @@ var normalizePlanB = function(desc) {
             var firstSsrcs = [];
             var newSsrcLines = [];
 
-            if (typeof mLine.ssrcGroups !== 'undefined' && Array.isArray(mLine.ssrcGroups)) {
+            if (typeof mLine.ssrcGroups !== 'undefined' &&
+                Array.isArray(mLine.ssrcGroups)) {
                 mLine.ssrcGroups.forEach(function (group) {
                     if (typeof group.semantics !== 'undefined' &&
                         group.semantics === 'FID') {
@@ -296,11 +450,13 @@ Object.keys(getters).forEach(function (prop) {
     );
 });
 
-TraceablePeerConnection.prototype.addStream = function (stream) {
+TraceablePeerConnection.prototype.addStream = function (stream, ssrcInfo) {
     this.trace('addStream', stream.id);
     try
     {
         this.peerconnection.addStream(stream);
+        if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype])
+            this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
     }
     catch (e)
     {
@@ -308,7 +464,8 @@ TraceablePeerConnection.prototype.addStream = function (stream) {
     }
 };
 
-TraceablePeerConnection.prototype.removeStream = function (stream, stopStreams) {
+TraceablePeerConnection.prototype.removeStream = function (stream, stopStreams,
+ssrcInfo) {
     this.trace('removeStream', stream.id);
     if(stopStreams) {
         RTC.stopMediaStream(stream);
@@ -316,8 +473,11 @@ TraceablePeerConnection.prototype.removeStream = function (stream, stopStreams)
 
     try {
         // FF doesn't support this yet.
-        if (this.peerconnection.removeStream)
+        if (this.peerconnection.removeStream) {
             this.peerconnection.removeStream(stream);
+            if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype])
+                this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
+        }
     } catch (e) {
         logger.error(e);
     }
@@ -399,47 +559,6 @@ TraceablePeerConnection.prototype.close = function () {
     this.peerconnection.close();
 };
 
-TraceablePeerConnection.prototype.createOffer
-        = function (successCallback, failureCallback, constraints) {
-    var self = this;
-    this.trace('createOffer', JSON.stringify(constraints, null, ' '));
-    this.peerconnection.createOffer(
-        function (offer) {
-            self.trace('createOfferOnSuccess::preTransform', dumpSDP(offer));
-            // NOTE this is not tested because in meet the focus generates the
-            // offer.
-
-            // if we're running on FF, transform to Plan B first.
-            if (RTCBrowserType.usesUnifiedPlan()) {
-                offer = self.interop.toPlanB(offer);
-                self.trace('createOfferOnSuccess::postTransform (Plan B)', dumpSDP(offer));
-            }
-
-            if (RTCBrowserType.isChrome())
-            {
-                offer = self.insertRecvOnlySSRC(offer);
-                self.trace('createAnswerOnSuccess::mungeLocalVideoSSRC',
-                    dumpSDP(offer));
-            }
-
-            if (!self.session.room.options.disableSimulcast
-                 && self.simulcast.isSupported()) {
-                offer = self.simulcast.mungeLocalDescription(offer);
-                self.trace('createOfferOnSuccess::postTransform (simulcast)',
-                    dumpSDP(offer));
-            }
-            successCallback(offer);
-        },
-        function(err) {
-            self.trace('createOfferOnFailure', err);
-            self.eventEmitter.emit(XMPPEvents.CREATE_OFFER_FAILED, err,
-                self.peerconnection);
-            failureCallback(err);
-        },
-        constraints
-    );
-};
-
 TraceablePeerConnection.prototype.createAnswer
         = function (successCallback, failureCallback, constraints) {
     var self = this;
@@ -454,19 +573,23 @@ TraceablePeerConnection.prototype.createAnswer
                     dumpSDP(answer));
             }
 
-            if (RTCBrowserType.isChrome())
-            {
-                answer = self.insertRecvOnlySSRC(answer);
-                self.trace('createAnswerOnSuccess::mungeLocalVideoSSRC',
-                    dumpSDP(answer));
-            }
-
             if (!self.session.room.options.disableSimulcast
                 && self.simulcast.isSupported()) {
                 answer = self.simulcast.mungeLocalDescription(answer);
                 self.trace('createAnswerOnSuccess::postTransform (simulcast)',
                     dumpSDP(answer));
             }
+
+            if (!RTCBrowserType.isFirefox())
+            {
+                answer = self.ssrcReplacement(answer);
+                self.trace('createAnswerOnSuccess::mungeLocalVideoSSRC',
+                    dumpSDP(answer));
+            }
+
+            self.eventEmitter.emit(XMPPEvents.SENDRECV_STREAMS_CHANGED,
+                extractSSRCMap(answer));
+
             successCallback(answer);
         },
         function(err) {

modules/xmpp/xmpp.js

@@ -33,24 +33,6 @@ function initStrophePlugins(XMPP) {
     require("./strophe.logger")();
 }
 
-//!!!!!!!!!! FIXME: ...
-///**
-// * If given <tt>localStream</tt> is video one this method will advertise it's
-// * video type in MUC presence.
-// * @param localStream new or modified <tt>LocalStream</tt>.
-// */
-//function broadcastLocalVideoType(localStream) {
-//    if (localStream.videoType)
-//        XMPP.addToPresence('videoType', localStream.videoType);
-//}
-//
-//function registerListeners() {
-//    RTC.addStreamListener(
-//        broadcastLocalVideoType,
-//        StreamEventTypes.EVENT_TYPE_LOCAL_CHANGED
-//    );
-//}
-
 function XMPP(options) {
     this.eventEmitter = new EventEmitter();
     this.connection = null;
@@ -59,7 +41,6 @@ function XMPP(options) {
     this.forceMuted = false;
     this.options = options;
     initStrophePlugins(this);
-//    registerListeners();
 
     this.connection = createConnection(options.bosh);
 

package.json

@@ -19,7 +19,7 @@
     "pako": "*",
     "sdp-interop": "0.1.11",
     "sdp-transform": "1.5.*",
-    "sdp-simulcast": "0.1.4",
+    "sdp-simulcast": "0.1.5",
     "async": "0.9.0",
     "retry": "0.6.1",
     "jssha": "1.5.0",

service/xmpp/XMPPEvents.js

@@ -112,6 +112,10 @@ var XMPPEvents = {
     /**
      * Indicates error while adding ice candidate.
      */
-    ADD_ICE_CANDIDATE_FAILED: "xmpp.add_ice_candidate_failed"
+    ADD_ICE_CANDIDATE_FAILED: "xmpp.add_ice_candidate_failed",
+    /**
+     * Indicates that the local sendrecv streams in local SDP are changed.
+     */
+    SENDRECV_STREAMS_CHANGED: "xmpp.sendrecv_streams_changed"
 };
 module.exports = XMPPEvents;