Merge pull request #22 from jitsi/fix_torture

Fixes the sources in session-accept jingle packets. Fixes issue with not replacing unmuted SSRCs in the SDP.

modules/RTC/RTC.js

                 }
             }
             this.room.addStream(this.localStreams[i].getOriginalStream(),
-                function () {}, ssrcInfo);
+                function () {}, ssrcInfo, true);
         }
 }
 

modules/xmpp/ChatRoom.js

     this.session.removeStream(stream, callback, ssrcInfo);
 };
 
-ChatRoom.prototype.addStream = function (stream, callback, ssrcInfo) {
+/**
+ * Adds stream.
+ * @param stream new stream that will be added.
+ * @param callback callback executed after successful stream addition.
+ * @param ssrcInfo object with information about the SSRCs associated with the
+ * stream.
+ * @param dontModifySources {boolean} if true _modifySources won't be called.
+ * Used for streams added before the call start.
+ */
+ChatRoom.prototype.addStream = function (stream, callback, ssrcInfo,
+    dontModifySources) {
     if(this.session) {
         // FIXME: will block switchInProgress on true value in case of exception
-        this.session.addStream(stream, callback, ssrcInfo);
+        this.session.addStream(stream, callback, ssrcInfo, dontModifySources);
     } else {
         // We are done immediately
         logger.warn("No conference handler or conference not started yet");

modules/xmpp/JingleSessionPC.js

                     init,
                     self.initiator == self.me ? 'initiator' : 'responder',
                     ssrc);
-
                 self.connection.sendIQ(init,
                     function () {
                         //logger.log('session initiate ack');
                     accept,
                     self.initiator == self.me ? 'initiator' : 'responder',
                     ssrcs);
-
+                self.fixJingle(accept);
                 self.connection.sendIQ(accept,
                     function () {
                         var ack = {};
 };
 
 /**
- * Adds streams.
+ * Adds stream.
  * @param stream new stream that will be added.
  * @param success_callback callback executed after successful stream addition.
+ * @param ssrcInfo object with information about the SSRCs associated with the
+ * stream.
+ * @param dontModifySources {boolean} if true _modifySources won't be called.
+ * Used for streams added before the call start.
  */
-JingleSessionPC.prototype.addStream = function (stream, callback, ssrcInfo) {
+JingleSessionPC.prototype.addStream = function (stream, callback, ssrcInfo,
+    dontModifySources) {
     // Remember SDP to figure out added/removed SSRCs
     var oldSdp = null;
     if(this.peerconnection) {
     }
 
     // Conference is not active
-    if(!oldSdp || !this.peerconnection) {
+    if(!oldSdp || !this.peerconnection || dontModifySources) {
+        if(ssrcInfo) {
+            //available only on video unmute or when adding muted stream
+            this.modifiedSSRCs[ssrcInfo.type] =
+                this.modifiedSSRCs[ssrcInfo.type] || [];
+            this.modifiedSSRCs[ssrcInfo.type].push(ssrcInfo);
+        }
         callback();
         return;
     }
     var self = this;
     this.modifySourcesQueue.push(function() {
         logger.log('modify sources done');
-
-        callback();
         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);
         }
+        callback();
         var newSdp = new SDP(self.peerconnection.localDescription.sdp);
         logger.log("SDPs", oldSdp, newSdp);
         self.notifyMySSRCUpdate(oldSdp, newSdp);
  * Remove streams.
  * @param stream stream that will be removed.
  * @param success_callback callback executed after successful stream addition.
+ * @param ssrcInfo object with information about the SSRCs associated with the
+ * stream.
  */
 JingleSessionPC.prototype.removeStream = function (stream, callback, ssrcInfo) {
     // Remember SDP to figure out added/removed SSRCs
     var removed = this.fixJingle(remove);
 
     if (removed && remove) {
-        logger.info("Sending source-remove", remove);
+        logger.info("Sending source-remove", remove.tree());
         this.connection.sendIQ(remove,
             function (res) {
                 logger.info('got remove result', res);
     var added = this.fixJingle(add);
 
     if (added && add) {
-        logger.info("Sending source-add", add);
+        logger.info("Sending source-add", add.tree());
         this.connection.sendIQ(add,
             function (res) {
                 logger.info('got add result', res);
     var action = $(jingle.nodeTree).find("jingle").attr("action");
     switch (action) {
         case "source-add":
+        case "session-accept":
             this.fixSourceAddJingle(jingle);
             break;
         case "source-remove":

modules/xmpp/TraceablePeerConnection.js

 
         modded = true;
         var SSRCs = this.replaceSSRCs[bLine.type].splice(0,1);
+        // Stores all SSRCs that should be used on other SRD/SDL operations.
+        // For every stream that is unmuted we need to replace it SSRC
+        // otherwise we are going to send jingle packet.
+        var permSSRCs = [];
         //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
                             ssrc.id = ssrcMap[ssrc.id];
                         }
                     });
+                    // Storing the unmuted SSRCs.
+                    permSSRCs.push(ssrcOperation);
                     break;
                 default:
                 break;
             }
             SSRCs = this.replaceSSRCs[bLine.type].splice(0,1);
         }
+        // Restoring the unmuted SSRCs.
+        this.replaceSSRCs[bLine.type] = permSSRCs;
 
         if (!Array.isArray(bLine.ssrcs) || bLine.ssrcs.length === 0)
         {
         // FF doesn't support this yet.
         if (this.peerconnection.removeStream) {
             this.peerconnection.removeStream(stream);
-            if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype])
+            // Removing all cached ssrcs for the streams that are removed or
+            // muted.
+            if(ssrcInfo && this.replaceSSRCs[ssrcInfo.mtype]) {
+                for(i = 0; i < this.replaceSSRCs[ssrcInfo.mtype].length; i++) {
+                    var op = this.replaceSSRCs[ssrcInfo.mtype][i];
+                    if(op.type === "unmute" &&
+                        op.ssrc.ssrcs.join("_") ===
+                        ssrcInfo.ssrc.ssrcs.join("_")) {
+                        this.replaceSSRCs[ssrcInfo.mtype].splice(i, 1);
+                        break;
+                    }
+                }
                 this.replaceSSRCs[ssrcInfo.mtype].push(ssrcInfo);
+            }
         }
     } catch (e) {
         logger.error(e);