Deal with the WebRTC streams on per track basis

JitsiConference.js

     });
 
     conference.room.addListener(XMPPEvents.REMOTE_TRACK_ADDED,
-        function (data, sid, thessrc) {
-            var track = conference.rtc.createRemoteTrack(data, sid, thessrc);
+        function (data) {
+            var track = conference.rtc.createRemoteTrack(data);
             if (track) {
                 conference.onTrackAdded(track);
             }
         }
     );
     conference.room.addListener(XMPPEvents.REMOTE_TRACK_REMOVED,
-        function (streamId) {
+        function (streamId, trackId) {
             conference.getParticipants().forEach(function(participant) {
                 var tracks = participant.getTracks();
                 for(var i = 0; i < tracks.length; i++) {
-                    if(tracks[i] && tracks[i].stream &&
-                        RTC.getStreamID(tracks[i].stream) == streamId){
+                    if(tracks[i]
+                        && tracks[i].getStreamId() == streamId
+                        && tracks[i].getTrackId() == trackId) {
                         var track = participant._tracks.splice(i, 1)[0];
                         conference.eventEmitter.emit(
                             JitsiConferenceEvents.TRACK_REMOVED, track);

modules/DTMF/JitsiDTMFManager.js

 var logger = require("jitsi-meet-logger").getLogger(__filename);
 
 function JitsiDTMFManager (localAudio, peerConnection) {
-    var tracks = localAudio._getTracks();
-    if (!tracks.length) {
+    var audioTrack = localAudio.getTrack();
+    if (!audioTrack) {
         throw new Error("Failed to initialize DTMFSender: no audio track.");
     }
-    this.dtmfSender = peerConnection.peerconnection.createDTMFSender(tracks[0]);
+    this.dtmfSender
+        = peerConnection.peerconnection.createDTMFSender(audioTrack);
     logger.debug("Initialized DTMFSender");
 }
 

modules/RTC/JitsiLocalTrack.js

 var VideoType = require('../../service/RTC/VideoType');
 
 /**
- * Represents a single media track (either audio or video).
+ * Represents a single media track(either audio or video).
+ * One <tt>JitsiLocalTrack</tt> corresponds to one WebRTC MediaStreamTrack.
+ * @param stream WebRTC MediaStream, parent of the track
+ * @param track underlying WebRTC MediaStreamTrack for new JitsiRemoteTrack
+ * @param mediaType the MediaType of the JitsiRemoteTrack
+ * @param videoType the VideoType of the JitsiRemoteTrack
+ * @param resolution the video resoultion if it's a video track
+ * @param deviceId the ID of the local device for this track
  * @constructor
  */
-function JitsiLocalTrack(stream, videoType,
-  resolution, deviceId)
-{
-    this.videoType = videoType;
+function JitsiLocalTrack(stream, track, mediaType, videoType, resolution,
+                         deviceId) {
+    JitsiTrack.call(this,
+        null /* RTC */, stream, track,
+        function () {
+            if(!this.dontFireRemoveEvent)
+                this.eventEmitter.emit(
+                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
+            this.dontFireRemoveEvent = false;
+        }.bind(this) /* inactiveHandler */,
+        mediaType, videoType, null /* ssrc */);
     this.dontFireRemoveEvent = false;
     this.resolution = resolution;
     this.deviceId = deviceId;
     this.startMuted = false;
-    this.ssrc = null;
     this.disposed = false;
     //FIXME: This dependacy is not necessary.
     this.conference = null;
-    JitsiTrack.call(this, null, stream,
-        function () {
-            if(!this.dontFireRemoveEvent)
-                this.eventEmitter.emit(
-                    JitsiTrackEvents.LOCAL_TRACK_STOPPED);
-            this.dontFireRemoveEvent = false;
-        }.bind(this));
     this.initialMSID = this.getMSID();
     this.inMuteOrUnmuteProgress = false;
 }
         // FIXME FF does not support 'removeStream' method used to mute
         RTCBrowserType.isFirefox()) {
 
-        var tracks = this._getTracks();
-        for (var idx = 0; idx < tracks.length; idx++) {
-            tracks[idx].enabled = !mute;
-        }
+        if (this.track)
+            this.track.enabled = !mute;
         if(isAudio)
             this.rtc.room.setAudioMute(mute, callbackFunction);
         else
                 .then(function (streamsInfo) {
                     var streamInfo = null;
                     for(var i = 0; i < streamsInfo.length; i++) {
-                        if(streamsInfo[i].type === self.type) {
+                        if(streamsInfo[i].mediaType === self.getType()) {
                             streamInfo = streamsInfo[i];
                             self.stream = streamInfo.stream;
+                            self.track = streamInfo.track;
                             // This is not good when video type changes after
                             // unmute, but let's not crash here
                             if (self.videoType != streamInfo.videoType) {
     // this.stream will be null when we mute local video on Chrome
     if (!this.stream)
         return true;
-    var tracks = [];
-    var isAudio = this.isAudioTrack();
-    if (isAudio) {
-        tracks = this.stream.getAudioTracks();
+    if (this.isVideoTrack() && !this.isActive()) {
+        return true;
     } else {
-        if (!this.isActive())
-            return true;
-        tracks = this.stream.getVideoTracks();
+        return !this.track || !this.track.enabled;
     }
-    for (var idx = 0; idx < tracks.length; idx++) {
-        if(tracks[idx].enabled)
-            return false;
-    }
-    return true;
 };
 
 /**

modules/RTC/JitsiRemoteTrack.js

 /**
  * Represents a single media track (either audio or video).
  * @param RTC the rtc instance.
- * @param data object with the stream and some details about it(participant id, video type, etc.)
- * @param sid sid for the Media Stream
- * @param ssrc ssrc for the Media Stream
- * @param eventEmitter the event emitter
+ * @param ownerJid the MUC JID of the track owner
+ * @param stream WebRTC MediaStream, parent of the track
+ * @param track underlying WebRTC MediaStreamTrack for new JitsiRemoteTrack
+ * @param mediaType the MediaType of the JitsiRemoteTrack
+ * @param videoType the VideoType of the JitsiRemoteTrack
+ * @param ssrc the SSRC number of the Media Stream
+ * @param muted intial muted state of the JitsiRemoteTrack
  * @constructor
  */
-function JitsiRemoteTrack(RTC, data, sid, ssrc) {
-    JitsiTrack.call(this, RTC, data.stream,
-        function () {}, data.jitsiTrackType);
+function JitsiRemoteTrack(RTC, ownerJid, stream, track, mediaType, videoType,
+                          ssrc, muted) {    
+    JitsiTrack.call(
+        this, RTC, stream, track, function () {}, mediaType, videoType, ssrc);
     this.rtc = RTC;
-    this.sid = sid;
-    this.stream = data.stream;
-    this.peerjid = data.peerjid;
-    this.videoType = data.videoType;
-    this.ssrc = ssrc;
-    this.muted = false;
-    if((this.isAudioTrack() && data.audiomuted)
-      || (this.isVideoTrack() && data.videomuted)) {
-        this.muted = true;
-    }
+    this.peerjid = ownerJid;
+    this.muted = muted;
 }
 
 JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);

modules/RTC/JitsiTrack.js

  * Represents a single media track (either audio or video).
  * @constructor
  * @param rtc the rtc instance
- * @param stream the stream
+ * @param stream the WebRTC MediaStream instance
+ * @param track the WebRTC MediaStreamTrack instance, must be part of
+ * the given <tt>stream</tt>.
  * @param streamInactiveHandler the function that will handle
  *        onended/oninactive events of the stream.
- * @param jitsiTrackType optionally a type can be specified.
- *        This is the case where we are creating a dummy track with no stream
- *        Currently this happens when a remote side is starting with video muted
+ * @param trackMediaType the media type of the JitsiTrack
+ * @param videoType the VideoType for this track if any
+ * @param ssrc the SSRC of this track if known
  */
-function JitsiTrack(rtc, stream, streamInactiveHandler, jitsiTrackType)
+function JitsiTrack(rtc, stream, track, streamInactiveHandler, trackMediaType,
+                    videoType, ssrc)
 {
     /**
      * Array with the HTML elements that are displaying the streams.
     this.containers = [];
     this.rtc = rtc;
     this.stream = stream;
+    this.ssrc = ssrc;
     this.eventEmitter = new EventEmitter();
     this.audioLevel = -1;
-    this.type = jitsiTrackType || ((this.stream.getVideoTracks().length > 0)?
-        MediaType.VIDEO : MediaType.AUDIO);
-    if(this.isAudioTrack()) {
-        this._getTracks = function () {
-            return this.stream? this.stream.getAudioTracks() : [];
-        }.bind(this);
-    } else {
-        this._getTracks = function () {
-            return this.stream? this.stream.getVideoTracks() : [];
-        }.bind(this);
-    }
-
+    this.type = trackMediaType;
+    this.track = track;
+    this.videoType = videoType;
     if(stream) {
         if (RTCBrowserType.isFirefox()) {
             implementOnEndedHandling(this);
     return this.stream;
 };
 
+/**
+ * Returns the ID of the underlying WebRTC Media Stream(if any)
+ * @returns {String|null}
+ */
+JitsiTrack.prototype.getStreamId = function () {
+    return this.stream ? this.stream.id : null;
+};
+
+/**
+ * Return the underlying WebRTC MediaStreamTrack
+ * @returns {MediaStreamTrack}
+ */
+JitsiTrack.prototype.getTrack = function () {
+    return this.track;
+};
+
+/**
+ * Returns the ID of the underlying WebRTC MediaStreamTrack(if any)
+ * @returns {String|null}
+ */
+JitsiTrack.prototype.getTrackId = function () {
+    return this.track ? this.track.id : null;
+};
+
 /**
  * Return meaningful usage label for this track depending on it's media and
  * eventual video type.
 };
 
 /**
+ * FIXME remove hack in SDP.js and this method
  * Returns id of the track.
  * @returns {string|null} id of the track or null if this is fake track.
  */
 JitsiTrack.prototype._getId = function () {
-    var tracks = this.stream.getTracks();
-    if(!tracks || tracks.length === 0)
-        return null;
-    return tracks[0].id;
+    return this.getTrackId();
 };
 
 /**
  * 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;
+    var streamId = this.getStreamId();
+    var trackId = this.getTrackId();
+    return (streamId && trackId) ? (streamId + " " + trackId) : null;
 };
 
 module.exports = JitsiTrack;

modules/RTC/RTC.js

     var newTracks = [];
     var deviceId = null;
     tracksInfo.forEach(function(trackInfo){
-        if (trackInfo.type === MediaType.AUDIO) {
+        if (trackInfo.mediaType === MediaType.AUDIO) {
           deviceId = options.micDeviceId;
         } else if (trackInfo.videoType === VideoType.CAMERA){
           deviceId = options.cameraDeviceId;
         }
-        var localTrack = new JitsiLocalTrack(trackInfo.stream,
-            trackInfo.videoType, trackInfo.resolution, deviceId);
+        var localTrack
+            = new JitsiLocalTrack(
+                trackInfo.stream,
+                trackInfo.track,
+                trackInfo.mediaType,
+                trackInfo.videoType, trackInfo.resolution, deviceId);
         newTracks.push(localTrack);
     });
     return newTracks;
         // we need to create a dummy track which we will mute, so we can
         // notify interested about the muting
         if (!videoTrack) {
-            videoTrack = self.createRemoteTrack(
-                {
-                    peerjid: room.roomjid + "/" + from,
+            videoTrack = self.createRemoteTrack({
+                    owner: room.roomjid + "/" + from,
                     videoType: VideoType.CAMERA,
-                    jitsiTrackType: MediaType.VIDEO
+                    mediaType: MediaType.VIDEO
                 },
                 null, null);
             self.eventEmitter
     }
 };
 
-RTC.prototype.createRemoteTrack = function (data, sid, thessrc) {
-    var remoteTrack = new JitsiRemoteTrack(this, data, sid, thessrc);
-    if(!data.peerjid)
-        return;
-    var resource = Strophe.getResourceFromJid(data.peerjid);
+RTC.prototype.createRemoteTrack = function (event) {
+    var ownerJid = event.owner;
+    var remoteTrack = new JitsiRemoteTrack(
+        this,  ownerJid, event.stream,    event.track,
+        event.mediaType, event.videoType, event.ssrc, event.muted);
+    var resource = Strophe.getResourceFromJid(ownerJid);
     if(!this.remoteTracks[resource]) {
         this.remoteTracks[resource] = {};
     }
 RTC.isDeviceChangeAvailable = function () {
     return RTCUtils.isDeviceChangeAvailable();
 };
+
+/**
+ * Returns <tt>true<tt/> if given WebRTC MediaStream is considered a valid
+ * "user" stream which means that it's not a "receive only" stream nor a "mixed"
+ * JVB stream.
+ * 
+ * Clients that implement Unified Plan, such as Firefox use recvonly
+ * "streams/channels/tracks" for receiving remote stream/tracks, as opposed to
+ * Plan B where there are only 3 channels: audio, video and data.
+ * 
+ * @param stream WebRTC MediaStream instance
+ * @returns {boolean}
+ */
+RTC.isUserStream = function (stream) {
+    var streamId = RTCUtils.getStreamID(stream);
+    return streamId && streamId !== "mixedmslabel" && streamId !== "default";
+};
+
 /**
  * Allows to receive list of available cameras/microphones.
  * @param {function} callback would receive array of devices as an argument

modules/RTC/RTCUIHelper.js

-/* global $ */
+/* global $, __filename */
+var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
 var RTC = require('./RTC');
 
         } else {
             var matching = $(containerElement).find(
                 ' ' + videoElemName + '>param[value="video"]');
-            if (matching.length < 2) {
-                return matching.parent()[0];
-            } else {
-                // there are 2 video objects from FF
-                // object with id which ends with '_default'
-                // (like 'remoteVideo_default')
-                // doesn't contain video, so we ignore it
-                for (var i = 0; i < matching.length; i += 1) {
-                    var el = matching[i].parentNode;
-
-                    // check id suffix
-                    if (el.id.substr(-8) !== '_default') {
-                        return el;
-                    }
+            if (matching.length) {
+                if (matching.length > 1) {
+                    logger.warn(
+                        "Container with more than one video elements: ",
+                        containerElement);
                 }
+                return matching.parent()[0];
             }
         }
         return undefined;

modules/RTC/RTCUtils.js

     if (desktopStream)
         res.push({
             stream: desktopStream,
-            type: MediaType.VIDEO,
+            track: desktopStream.getVideoTracks()[0],
+            mediaType: MediaType.VIDEO,
             videoType: VideoType.DESKTOP
         });
 
     if(audioStream)
         res.push({
             stream: audioStream,
-            type: MediaType.AUDIO,
+            track: audioStream.getAudioTracks()[0],
+            mediaType: MediaType.AUDIO,
             videoType: null
         });
 
     if(videoStream)
         res.push({
             stream: videoStream,
-            type: MediaType.VIDEO,
+            track: videoStream.getVideoTracks()[0],
+            mediaType: MediaType.VIDEO,
             videoType: VideoType.CAMERA,
             resolution: resolution
         });

modules/xmpp/ChatRoom.js

 /* jshint -W101,-W069 */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
+var MediaType = require("../../service/RTC/MediaType");
 var Moderator = require("./moderator");
 var EventEmitter = require("events");
 var Recorder = require("./recording");
     this.eventEmitter.removeListener(type, listener);
 };
 
-ChatRoom.prototype.remoteStreamAdded = function(data, sid, thessrc) {
-    if(this.lastPresences[data.peerjid])
-    {
-        var pres = this.lastPresences[data.peerjid];
-        var audiomuted = filterNodeFromPresenceJSON(pres, "audiomuted");
-        var videomuted = filterNodeFromPresenceJSON(pres, "videomuted");
-        data.videomuted = ((videomuted.length > 0
-            && videomuted[0]
-            && videomuted[0]["value"] === "true")? true : false);
-        data.audiomuted = ((audiomuted.length > 0
-            && audiomuted[0]
-            && audiomuted[0]["value"] === "true")? true : false);
-    }
-
-    this.eventEmitter.emit(XMPPEvents.REMOTE_TRACK_ADDED, data, sid, thessrc);
+ChatRoom.prototype.remoteTrackAdded = function(data) {
+    // Will figure out current muted status by looking up owner's presence
+    var pres = this.lastPresences[data.owner];
+    var mediaType = data.mediaType;
+    if(pres) {
+        var mutedNode = null;
+        if (mediaType === MediaType.AUDIO) {
+            mutedNode = filterNodeFromPresenceJSON(pres, "audiomuted");
+        } else if (mediaType === MediaType.VIDEO) {
+            mutedNode = filterNodeFromPresenceJSON(pres, "videomuted");
+        } else {
+            logger.warn("Unsupported media type: " + mediaType);
+            data.muted= null;
+        }
+
+        if (mutedNode) {
+            data.muted = !!(mutedNode.length > 0 &&
+                            mutedNode[0] && mutedNode[0]["value"] === "true");
+        }
+    }
+
+    this.eventEmitter.emit(XMPPEvents.REMOTE_TRACK_ADDED, data);
 };
 
 /**

modules/xmpp/JingleSessionPC.js

 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var JingleSession = require("./JingleSession");
 var TraceablePeerConnection = require("./TraceablePeerConnection");
+var MediaType = require("../../service/RTC/MediaType");
 var SDPDiffer = require("./SDPDiffer");
 var SDPUtil = require("./SDPUtil");
 var SDP = require("./SDP");
         self.sendIceCandidate(candidate);
     };
     this.peerconnection.onaddstream = function (event) {
-        if (event.stream.id !== 'default') {
-            logger.log("REMOTE STREAM ADDED: ", event.stream , event.stream.id);
-            self.remoteStreamAdded(event);
-        } else {
-            // This is a recvonly stream. Clients that implement Unified Plan,
-            // such as Firefox use recvonly "streams/channels/tracks" for
-            // receiving remote stream/tracks, as opposed to Plan B where there
-            // are only 3 channels: audio, video and data.
-            logger.log("RECVONLY REMOTE STREAM IGNORED: " + event.stream + " - " + event.stream.id);
-        }
+        self.remoteStreamAdded(event.stream);
     };
     this.peerconnection.onremovestream = function (event) {
-        // Remove the stream from remoteStreams
-        if (event.stream.id !== 'default') {
-            logger.log("REMOTE STREAM REMOVED: ", event.stream , event.stream.id);
-            self.remoteStreamRemoved(event);
-        } else {
-            // This is a recvonly stream. Clients that implement Unified Plan,
-            // such as Firefox use recvonly "streams/channels/tracks" for
-            // receiving remote stream/tracks, as opposed to Plan B where there
-            // are only 3 channels: audio, video and data.
-            logger.log("RECVONLY REMOTE STREAM IGNORED: " + event.stream + " - " + event.stream.id);
-        }
+        self.remoteStreamRemoved(event.stream);
     };
     this.peerconnection.onsignalingstatechange = function (event) {
         if (!(self && self.peerconnection)) return;
     this.room.eventEmitter.emit(XMPPEvents.JINGLE_FATAL_ERROR, session, error);
 };
 
-JingleSessionPC.prototype.remoteStreamAdded = function (data, times) {
+/**
+ * Called when new remote MediaStream is added to the PeerConnection.
+ * @param stream the WebRTC MediaStream for remote participant
+ */
+JingleSessionPC.prototype.remoteStreamAdded = function (stream) {
     var self = this;
-    var thessrc;
-    var streamId = RTC.getStreamID(data.stream);
+    if (!RTC.isUserStream(stream)) {
+        logger.info(
+            "Ignored remote 'stream added' event for non-user stream", stream);
+        return;
+    }
+    // Bind 'addtrack'/'removetrack' event handlers
+    if (RTCBrowserType.isChrome()) {
+        stream.onaddtrack = function (event) {
+            self.remoteTrackAdded(event.target, event.track);
+        };
+        stream.onremovetrack = function (event) {
+            self.remoteTrackRemoved(event.target, event.track);
+        };
+    }
+    // Call remoteTrackAdded for each track in the stream
+    stream.getAudioTracks().forEach(function (track) {
+        self.remoteTrackAdded(stream, track);
+    });
+    stream.getVideoTracks().forEach(function (track) {
+        self.remoteTrackAdded(stream, track);
+    });
+};
+
+/**
+ * Called on "track added" and "stream added" PeerConnection events(cause we
+ * handle streams on per track basis). Does find the owner and the SSRC for
+ * the track and passes that to ChatRoom for further processing.
+ * @param stream WebRTC MediaStream instance which is the parent of the track
+ * @param track the WebRTC MediaStreamTrack added for remote participant
+ */
+JingleSessionPC.prototype.remoteTrackAdded = function (stream, track) {
+    logger.info("Remote track added", stream, track);
+    var streamId = RTC.getStreamID(stream);
+    var mediaType = track.kind;
+
+    // This is our event structure which will be passed by the ChatRoom as
+    // XMPPEvents.REMOTE_TRACK_ADDED data
+    var jitsiTrackAddedEvent = {
+        stream: stream,
+        track: track,
+        mediaType: track.kind, /* 'audio' or 'video' */
+        owner: undefined, /* to be determined below */
+        muted: null /* will be set in the ChatRoom */
+    };
 
     // look up an associated JID for a stream id
-    if (!streamId) {
-        logger.error("No stream ID for", data.stream);
-    } else if (streamId && streamId.indexOf('mixedmslabel') === -1) {
-        // look only at a=ssrc: and _not_ at a=ssrc-group: lines
-
-        var ssrclines = this.peerconnection.remoteDescription?
-            SDPUtil.find_lines(this.peerconnection.remoteDescription.sdp, 'a=ssrc:') : [];
-        ssrclines = ssrclines.filter(function (line) {
-            // NOTE(gp) previously we filtered on the mslabel, but that property
-            // is not always present.
-            // return line.indexOf('mslabel:' + data.stream.label) !== -1;
-
-            if (RTCBrowserType.isTemasysPluginUsed()) {
-                return ((line.indexOf('mslabel:' + streamId) !== -1));
-            } else {
-                return ((line.indexOf('msid:' + streamId) !== -1));
-            }
-        });
-        if (ssrclines.length) {
-            thessrc = ssrclines[0].substring(7).split(' ')[0];
+    if (!mediaType) {
+        logger.error("MediaType undefined", track);
+        return;
+    }
 
-            if (!self.ssrcOwners[thessrc]) {
-                logger.error("No SSRC owner known for: " + thessrc);
-                return;
-            }
-            data.peerjid = self.ssrcOwners[thessrc];
-            logger.log('associated jid', self.ssrcOwners[thessrc]);
+    var remoteSDP = new SDP(this.peerconnection.remoteDescription.sdp);
+    var medialines = remoteSDP.media.filter(function (mediaLines){
+        return mediaLines.startsWith("m=" + mediaType);
+    });
+
+    if (!medialines.length) {
+        logger.error("No media for type " + mediaType + " found in remote SDP");
+        return;
+    }
+
+    var ssrclines = SDPUtil.find_lines(medialines[0], 'a=ssrc:');
+    ssrclines = ssrclines.filter(function (line) {
+        if (RTCBrowserType.isTemasysPluginUsed()) {
+            return ((line.indexOf('mslabel:' + streamId) !== -1));
         } else {
-            logger.error("No SSRC lines for ", streamId);
+            return ((line.indexOf('msid:' + streamId) !== -1));
         }
+    });
+
+    var thessrc;
+    if (ssrclines.length) {
+        thessrc = ssrclines[0].substring(7).split(' ')[0];
+        if (!this.ssrcOwners[thessrc]) {
+            logger.error("No SSRC owner known for: " + thessrc);
+            return;
+        }
+        jitsiTrackAddedEvent.owner = this.ssrcOwners[thessrc];
+        logger.log('associated jid', this.ssrcOwners[thessrc], thessrc);
+    } else {
+        logger.error("No SSRC lines for ", streamId);
+        return;
     }
+    jitsiTrackAddedEvent.ssrc = thessrc;
 
-    this.room.remoteStreamAdded(data, this.sid, thessrc);
+    this.room.remoteTrackAdded(jitsiTrackAddedEvent);
 };
 
 /**
  * Handles remote stream removal.
- * @param event The event object associated with the removal.
+ * @param stream the WebRTC MediaStream object which is being removed from the
+ * PeerConnection
  */
-JingleSessionPC.prototype.remoteStreamRemoved = function (event) {
-    var thessrc;
-    var streamId = RTC.getStreamID(event.stream);
+JingleSessionPC.prototype.remoteStreamRemoved = function (stream) {
+    var self = this;
+    if (!RTC.isUserStream(stream)) {
+        logger.info(
+            "Ignored remote 'stream removed' event for non-user stream", stream);
+        return;
+    }
+    // Call remoteTrackRemoved for each track in the stream
+    stream.getVideoTracks().forEach(function(track){
+        self.remoteTrackRemoved(stream, track);
+    });
+    stream.getAudioTracks().forEach(function(track) {
+       self.remoteTrackRemoved(stream, track);
+    });
+};
+
+/**
+ * Handles remote media track removal.
+ * @param stream WebRTC MediaStream instance which is the parent of the track
+ * @param track the WebRTC MediaStreamTrack which has been removed from
+ * the PeerConnection.
+ */
+JingleSessionPC.prototype.remoteTrackRemoved = function (stream, track) {
+    logger.info("Remote track removed", stream, track);
+    var streamId = RTC.getStreamID(stream);
+    var trackId = track && track.id;
     if (!streamId) {
-        logger.error("No stream ID for", event.stream);
-    } else if (streamId && streamId.indexOf('mixedmslabel') === -1) {
-        this.room.eventEmitter.emit(XMPPEvents.REMOTE_STREAM_REMOVED, streamId);
+        logger.error("No stream ID for", stream);
+    } else if (!trackId) {
+        logger.error("No track ID for", track);
+    } else {
+        this.room.eventEmitter.emit(
+            XMPPEvents.REMOTE_TRACK_REMOVED, streamId, trackId);
     }
 };
 

modules/xmpp/SDP.js

                     elem.up();
                     var msid = null;
                     if(mline.media == "audio") {
+                        // FIXME what is this ? global APP.RTC in SDP ?
                         msid = APP.RTC.localAudio._getId();
                     } else {
                         msid = APP.RTC.localVideo._getId();

service/xmpp/XMPPEvents.js

     // Designates an event indicating that we received statistics from a
     // participant in the MUC.
     REMOTE_STATS: "xmpp.remote_stats",
+    /**
+     * Event fired when we remote track is added to the conference.
+     * The following structure is passed as an argument:
+     * {
+     *   stream: the WebRTC MediaStream instance 
+     *   track: the WebRTC MediaStreamTrack
+     *   mediaType: the MediaType instance
+     *   owner: the MUC JID of the stream owner
+     *   muted: a boolean indicating initial 'muted' status of the track or
+      *         'null' if unknown
+     **/
     REMOTE_TRACK_ADDED: "xmpp.remote_track_added",
     /**
      * Indicates that the remote track has been removed from the conference.
+     * 1st event argument is the ID of the parent WebRTC stream to which 
+     * the track being removed belongs to.
+     * 2nd event argument is the ID of the removed track.
      */
     REMOTE_TRACK_REMOVED: "xmpp.remote_track_removed",
     RESERVATION_ERROR: "xmpp.room_reservation_error",