Fixes issue with adding muted video stream to peerconnection.

modules/RTC/JitsiLocalTrack.js

                     JitsiTrackEvents.TRACK_STOPPED);
             this.dontFireRemoveEvent = false;
         }.bind(this));
+    this.initialMSID = this.getMSID();
 }
 
 JitsiLocalTrack.prototype = Object.create(JitsiTrack.prototype);

modules/RTC/RTC.js

 
 RTC.prototype.onIncommingCall = function(event) {
     if(this.options.config.openSctp)
-        this.dataChannels = new DataChannels(event.peerconnection, this.eventEmitter);
+        this.dataChannels = new DataChannels(event.peerconnection,
+            this.eventEmitter);
     for(var i = 0; i < this.localStreams.length; i++)
         if(this.localStreams[i])
         {
-            this.room.addStream(this.localStreams[i].getOriginalStream(), function () {});
+            var ssrcInfo = null;
+            if(this.localStreams[i].isMuted() &&
+                this.localStreams[i].getType() === "video") {
+                /**
+                 * Handles issues when the stream is added before the peerconnection is created.
+                 * The peerconnection is created when second participant enters the call. In
+                 * that use case the track doesn't have information about it's ssrcs and no
+                 * jingle packets are sent. That can cause inconsistant behavior later.
+                 *
+                 * For example:
+                 * If we mute the stream and than second participant enter it's remote SDP won't
+                 * include that track. On unmute we are not sending any jingle packets which
+                 * will brake the unmute.
+                 *
+                 * In order to solve issues like the above one here we have to generate the ssrc
+                 * information for the track .
+                 */
+                this.localStreams[i]._setSSRC(
+                    this.room.generateNewStreamSSRCInfo());
+                ssrcInfo = {
+                    mtype: this.localStreams[i].getType(),
+                    type: "addMuted",
+                    ssrc: this.localStreams[i].ssrc,
+                    msid: this.localStreams[i].initialMSID
+                }
+            }
+            this.room.addStream(this.localStreams[i].getOriginalStream(),
+                function () {}, ssrcInfo);
         }
 }
 

modules/xmpp/ChatRoom.js

     }
 };
 
+/**
+ * Generate ssrc info object for a stream with the following properties:
+ * - ssrcs - Array of the ssrcs associated with the stream.
+ * - groups - Array of the groups associated with the stream.
+ */
+ChatRoom.prototype.generateNewStreamSSRCInfo = function () {
+    if(!this.session) {
+        logger.warn("The call haven't been started. " +
+            "Cannot generate ssrc info at the moment!");
+        return null;
+    }
+    return this.session.generateNewStreamSSRCInfo();
+};
+
 ChatRoom.prototype.setVideoMute = function (mute, callback, options) {
     var self = this;
     this.sendVideoInfoPresence(mute);

modules/xmpp/JingleSessionPC.js

         if(this.peerconnection.localDescription) {
             oldSdp = new SDP(this.peerconnection.localDescription.sdp);
         }
-        if(stream)
+        //when adding muted stream we have to pass the ssrcInfo but we don't
+        //have a stream
+        if(stream || ssrcInfo)
             this.peerconnection.addStream(stream, ssrcInfo);
     }
 
         logger.log('modify sources done');
 
         callback();
-        if(ssrcInfo) { //available only on video unmute
+        if(ssrcInfo) {
+            //available only on video unmute or when adding muted stream
             self.modifiedSSRCs[ssrcInfo.type] =
                 self.modifiedSSRCs[ssrcInfo.type] || [];
             self.modifiedSSRCs[ssrcInfo.type].push(ssrcInfo);
     });
 }
 
+/**
+ * Generate ssrc info object for a stream with the following properties:
+ * - ssrcs - Array of the ssrcs associated with the stream.
+ * - groups - Array of the groups associated with the stream.
+ */
+JingleSessionPC.prototype.generateNewStreamSSRCInfo = function () {
+    return this.peerconnection.generateNewStreamSSRCInfo();
+};
+
 /**
  * Remove streams.
  * @param stream stream that will be removed.
             });
         });
     }
+
+    ssrcs = this.modifiedSSRCs["addMuted"];
+    this.modifiedSSRCs["addMuted"] = [];
+    if(ssrcs && ssrcs.length) {
+        ssrcs.forEach(function (ssrcObj) {
+            var desc = createDescriptionNode(jingle, ssrcObj.mtype);
+            var cname = Math.random().toString(36).substring(2);
+            ssrcObj.ssrc.ssrcs.forEach(function (ssrc) {
+                var sourceNode = desc.find(">source[ssrc=\"" +ssrc + "\"]");
+                sourceNode.remove();
+                var sourceXML = "<source " +
+                    "xmlns=\"urn:xmpp:jingle:apps:rtp:ssma:0\" ssrc=\"" +
+                    ssrc + "\">" +
+                    "<parameter xmlns=\"urn:xmpp:jingle:apps:rtp:ssma:0\"" +
+                    " value=\"" + ssrcObj.msid + "\" name=\"msid\"/>" +
+                    "<parameter xmlns=\"urn:xmpp:jingle:apps:rtp:ssma:0\"" +
+                    " value=\"" + cname + "\" name=\"cname\" />" + "</source>";
+                desc.append(sourceXML);
+            });
+            ssrcObj.ssrc.groups.forEach(function (group) {
+                var groupNode = desc.find(">ssrc-group[semantics=\"" +
+                    group.group.semantics + "\"]:has(source[ssrc=\"" + group.primarySSRC +
+                    "\"])");
+                groupNode.remove();
+                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>");
+            });
+        });
+    }
 }
 
 /**
     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");
-            }
-
+            var desc = createDescriptionNode(jingle, ssrcObj.mtype);
             ssrcObj.ssrc.ssrcs.forEach(function (ssrc) {
                 var sourceNode = desc.find(">source[ssrc=\"" +ssrc + "\"]");
                 if(!sourceNode || !sourceNode.length) {
         });
 }
 
+/**
+ * Returns the description node related to the passed content type. If the node
+ * doesn't exists it will be created.
+ * @param jingle - the jingle packet
+ * @param mtype - the content type(audio, video, etc.)
+ */
+function createDescriptionNode(jingle, mtype) {
+    var content = $(jingle.tree()).find(">jingle>content[name=\"" +
+        mtype + "\"]");
+
+    if(!content || !content.length) {
+        $(jingle.tree()).find(">jingle").append(
+            "<content name=\"" + mtype + "\"></content>");
+        content = $(jingle.tree()).find(">jingle>content[name=\"" +
+            mtype + "\"]");
+    }
+
+    var desc = content.find(">description");
+    if(!desc || !desc.length) {
+        content.append("<description " +
+            "xmlns=\"urn:xmpp:jingle:apps:rtp:1\" media=\"" +
+            mtype + "\"></description>");
+        desc = content.find(">description");
+    }
+    return desc;
+}
+
 module.exports = JingleSessionPC;

modules/xmpp/TraceablePeerConnection.js

 var RTCBrowserType = require("../RTC/RTCBrowserType.js");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var transform = require('sdp-transform');
+var RandomUtil = require('../util/RandomUtil');
+
+var SIMULCAST_LAYERS = 3;
 
 function TraceablePeerConnection(ice_config, constraints, session) {
     var self = this;
     var Interop = require('sdp-interop').Interop;
     this.interop = new Interop();
     var Simulcast = require('sdp-simulcast');
-    this.simulcast = new Simulcast({numOfLayers: 3,
+    this.simulcast = new Simulcast({numOfLayers: SIMULCAST_LAYERS,
         explodeRemoteSimulcast: false});
     this.eventEmitter = this.session.room.eventEmitter;
 
         return desc;
     }
 
-    var RandomUtil = require('../util/RandomUtil');
-
     var session = transform.parse(desc.sdp);
     if (!Array.isArray(session.media))
     {
             var ssrcOperation = SSRCs[0];
             switch(ssrcOperation.type) {
                 case "mute":
+                case "addMuted":
                 //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
                         id: ssrc,
                         attribute: 'cname',
                         value: ['recvonly-', ssrc].join('')
-                    })
+                    });
+                    // If this is executed for another reason we are going to
+                    // include that ssrc as receive only again instead of
+                    // generating new one. Here we are assuming that we have
+                    // only 1 video stream that is muted.
+                    this.recvOnlySSRCs[bLine.type] = ssrc;
                     break;
                 case "unmute":
                     if(!ssrcOperation.ssrc || !ssrcOperation.ssrc.ssrcs ||
 });
 
 TraceablePeerConnection.prototype.addStream = function (stream, ssrcInfo) {
-    this.trace('addStream', stream.id);
+    this.trace('addStream', stream? stream.id : "null");
     try
     {
-        this.peerconnection.addStream(stream);
+        if(stream)
+            this.peerconnection.addStream(stream);
         if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype])
             this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
     }
     }
 };
 
+/**
+ * Generate ssrc info object for a stream with the following properties:
+ * - ssrcs - Array of the ssrcs associated with the stream.
+ * - groups - Array of the groups associated with the stream.
+ */
+TraceablePeerConnection.prototype.generateNewStreamSSRCInfo = function () {
+    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));
+        ssrcInfo.groups.push({
+            primarySSRC: ssrcInfo.ssrcs[0],
+            group: {ssrcs: ssrcInfo.ssrcs.join(" "), semantics: "SIM"}});
+        return ssrcInfo;
+    } else {
+        return {ssrcs: [RandomUtil.randomInt(1, 0xffffffff)], groups: []};
+    }
+};
+
 module.exports = TraceablePeerConnection;