More p2p analytics (#487)

* feat: multiple, simultaneous RTP stats

Makes it possible to have remote RTP stats running for more than one
peerconnection at a time.

* feat(stats): report RTT all the time

Will report JVB RTT (and end to end) while in P2P mode and vice versa.

* fix(JitsiConferenceEvents): remove CONNECTION_STATS

CONNECTION_STATS event is no longer emitted.

* fix(AvgRTPStatsReported): users with no video

Do not include FPS == 0 in average remote FPS calculation. Report NaN
for local FPS when video muted or no video device. NaN will be reported
for avg remote FPS if no video is received.

* fix(AvgRTPStatsReported): reset total packet loss

* feat(AvgRTPStatsReported): report 'screen' FPS

Will report average FPS for screen videos separately from camera videos,
but only if available (camera video reports NaN FPS when not available).

* fix(AvgRTPStatsReported): end2endRTT

Needs to report JSON with value.

* feat(AVG RTP stats): separate audio and video bitrate

Will report average audio and video bitrates separately.

* doc(JitsiConference): try to improve comment

* fix(AvgRTPStatsReporter): remove confusing reset

There's no a clear reason for doing reset there.

* ref(AvgRTPStatsReporter): rename var

JitsiConference.js

 };
 
 /**
- * Fires TRACK_AUDIO_LEVEL_CHANGED change conference event.
+ * Fires TRACK_AUDIO_LEVEL_CHANGED change conference event (for local tracks).
+ * @param {TraceablePeerConnection|null} tpc
  * @param audioLevel the audio level
  */
-JitsiConference.prototype._fireAudioLevelChangeEvent = function(audioLevel) {
-    this.eventEmitter.emit(
-        JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
-        this.myUserId(), audioLevel);
+JitsiConference.prototype._fireAudioLevelChangeEvent
+= function(tpc, audioLevel) {
+    const activeTpc = this.getActivePeerConnection();
+
+    // There will be no TraceablePeerConnection if audio levels do not come from
+    // a peerconnection. LocalStatsCollector.js measures audio levels using Web
+    // Audio Analyser API and emits local audio levels events through
+    // JitsiTrack.setAudioLevel, but does not provide TPC instance which is
+    // optional.
+    if (tpc === null || activeTpc === tpc) {
+        this.eventEmitter.emit(
+            JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
+            this.myUserId(), audioLevel);
+    }
 };
 
 /**
         () => emitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track));
     track.addEventListener(
         JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-        audioLevel => {
-            emitter.emit(
-                JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
-                id,
-                audioLevel);
+        (tpc, audioLevel) => {
+            const activeTPC = this.getActivePeerConnection();
+
+            if (activeTPC === tpc) {
+                emitter.emit(
+                    JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
+                    id,
+                    audioLevel);
+            }
         }
     );
 
         this.statistics.startCallStats(
             this.jvbJingleSession.peerconnection,
             'jitsi' /* Remote user ID for JVB is 'jitsi' */);
-        this._startRemoteStats();
+        this.statistics.startRemoteStats(this.jvbJingleSession.peerconnection);
     } catch (e) {
         GlobalOnErrorHandler.callErrorHandler(e);
         logger.error(e);
         });
 };
 
-/**
- * Method called to start remote stats for the current peer connection (if
- * available).
- * @private
- */
-JitsiConference.prototype._startRemoteStats = function() {
-    const activePeerConnection = this.getActivePeerConnection();
-
-    if (activePeerConnection) {
-        this.statistics.startRemoteStats(activePeerConnection);
-    }
-};
-
 /**
  * Handles the call ended event.
  * @param {JingleSessionPC} jingleSession the jingle session which has been
 
         // Stop the stats
         if (this.statistics) {
-            this.statistics.stopRemoteStats();
+            this.statistics.stopRemoteStats(
+                this.jvbJingleSession.peerconnection);
             logger.info('Stopping JVB CallStats');
             this.statistics.stopCallStats(
                 this.jvbJingleSession.peerconnection);
  *
  * @return {TraceablePeerConnection|null} null if there isn't any active
  * <tt>TraceablePeerConnection</tt> currently available.
- * @protected
+ * @public (FIXME how to make package local ?)
  */
 JitsiConference.prototype.getActivePeerConnection = function() {
     if (this.isP2PActive()) {
 
     // Start remote stats
     logger.info('Starting remote stats with p2p connection');
-    this._startRemoteStats();
+    this.statistics.startRemoteStats(this.p2pJingleSession.peerconnection);
 
     // Log the P2P established event
     if (this.p2pJingleSession.isInitiator) {
 
     // Stop P2P stats
     logger.info('Stopping remote stats for P2P connection');
-    this.statistics.stopRemoteStats();
+    this.statistics.stopRemoteStats(this.p2pJingleSession.peerconnection);
     logger.info('Stopping CallStats for P2P connection');
     this.statistics.stopCallStats(
         this.p2pJingleSession.peerconnection);
             logger.info('Not adding remote JVB tracks - no session yet');
         }
     }
-
-    // Start remote stats
-    logger.info('Starting remote stats with JVB connection');
-    if (this.jvbJingleSession) {
-        this._startRemoteStats();
-    }
 };
 
 /**

JitsiConferenceEventManager.js

         Statistics.sendEventToAll.bind(Statistics, 'connection.restored'));
 }
 
-/**
- * Groups resolutions by user id, skip incorrect resolutions.
- * @param conference {JitsiConference} the conference
- * @param resolutions map of resolutions by ssrc
- */
-function mapResolutionsByUserId(conference, resolutions) {
-    const id2resolution = {};
-
-    // preprocess resolutions: group by user id, skip incorrect
-    // resolutions etc.
-    for (const [ ssrc, resolution ] of resolutions) {
-        const id = conference.rtc.getResourceBySSRC(ssrc);
-
-        if (id
-            && resolution.width && resolution.height
-            && resolution.width !== -1 && resolution.height !== -1) {
-            // ssrc to resolution map for user id
-            const idResolutions = id2resolution[id] || {};
-
-            idResolutions[ssrc] = resolution;
-
-            id2resolution[id] = idResolutions;
-        }
-    }
-
-    return id2resolution;
-}
-
-/**
- * Groups framerates by user id, skip framerates with value of 0.
- * @param conference {JitsiConference} the conference
- * @param framerates map of framerates by ssrc
- */
-function mapFrameratesByUserId(conference, framerates) {
-    const id2framerate = {};
-
-    // preprocess framerates: group by user id
-    for (const [ ssrc, framerate ] of framerates) {
-        const id = conference.rtc.getResourceBySSRC(ssrc);
-
-        if (framerate !== 0 && id) {
-            // ssrc to framerate map for user id
-            const id2framerates = id2framerate[id] || {};
-
-            id2framerates[ssrc] = framerate;
-
-            id2framerate[id] = id2framerates;
-        }
-    }
-
-    return id2framerate;
-}
-
 /**
  * Setups event listeners related to conference.chatRoom
  */
         return;
     }
 
-    conference.statistics.addAudioLevelListener((ssrc, level) => {
-        conference.rtc.setAudioLevel(ssrc, level);
+    /* eslint-disable max-params */
+    conference.statistics.addAudioLevelListener((tpc, ssrc, level, isLocal) => {
+        conference.rtc.setAudioLevel(tpc, ssrc, level, isLocal);
     });
 
+    /* eslint-enable max-params */
+
     // Forward the "before stats disposed" event
     conference.statistics.addBeforeDisposedListener(() => {
         conference.eventEmitter.emit(
             JitsiConferenceEvents.BEFORE_STATISTICS_DISPOSED);
     });
-    conference.statistics.addConnectionStatsListener(stats => {
-
-        stats.resolution = mapResolutionsByUserId(conference, stats.resolution);
-        stats.framerate = mapFrameratesByUserId(conference, stats.framerate);
-
-        conference.eventEmitter.emit(
-            JitsiConferenceEvents.CONNECTION_STATS, stats);
-    });
-
     conference.statistics.addByteSentStatsListener((tpc, stats) => {
         conference.getLocalTracks(MediaType.AUDIO).forEach(track => {
             const ssrc = tpc.getLocalSSRC(track);

JitsiConferenceEvents.js

  */
 export const CONNECTION_RESTORED = 'conference.connectionRestored';
 
-/**
- * New local connection statistics are received.
- * @deprecated Use ConnectionQualityEvents.LOCAL_STATS_UPDATED instead.
- */
-export const CONNECTION_STATS = 'conference.connectionStats';
-
 /**
  * A user has changed it display name
  */

JitsiMeetJS.js

 
                         if (track.getType() === MediaType.AUDIO) {
                             Statistics.startLocalStats(mStream,
-                                track.setAudioLevel.bind(track));
+                                track.setAudioLevel.bind(
+                                    track, null /* no TPC */));
                             track.addEventListener(
                                 JitsiTrackEvents.LOCAL_TRACK_STOPPED,
                                 () => {

JitsiParticipant.js

         return this._tracks.slice();
     }
 
+    /**
+     * @param {MediaType} mediaType
+     * @returns {Array.<JitsiTrack>} an array of media tracks for this
+     * participant, for given media type.
+     */
+    getTracksByMediaType(mediaType) {
+        return this.getTracks().filter(track => track.getType() === mediaType);
+    }
+
     /**
      * @returns {String} The ID of this participant.
      */

modules/RTC/JitsiTrack.js

 
 /**
  * Sets the audio level for the stream
- * @param audioLevel the new audio level
+ * @param {TraceablePeerConnection|null} tpc the peerconnection instance which
+ * is source for the audio level. It can be <tt>null</tt> for a local track if
+ * the audio level was measured outside of the peerconnection
+ * (see /modules/statistics/LocalStatsCollector.js).
+ * @param {number} audioLevel value between 0 and 1
  */
-JitsiTrack.prototype.setAudioLevel = function(audioLevel) {
+JitsiTrack.prototype.setAudioLevel = function(tpc, audioLevel) {
     if (this.audioLevel !== audioLevel) {
-        this.eventEmitter.emit(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-            audioLevel);
         this.audioLevel = audioLevel;
+        this.eventEmitter.emit(
+            JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
+            tpc,
+            audioLevel);
     }
 };
 

modules/RTC/RTC.js

         }
     }
 
+    /* eslint-disable max-params */
     /**
      *
-     * @param resource
-     * @param audioLevel
+     * @param {TraceablePeerConnection} tpc
+     * @param {number} ssrc
+     * @param {number} audioLevel
+     * @param {boolean} isLocal
      */
-    setAudioLevel(ssrc, audioLevel) {
-        const track = this._getTrackBySSRC(ssrc);
+    setAudioLevel(tpc, ssrc, audioLevel, isLocal) {
+        const track = tpc.getTrackBySSRC(ssrc);
 
         if (!track) {
             return;
-        }
-        if (!track.isAudioTrack()) {
+        } else if (!track.isAudioTrack()) {
             logger.warn(`Received audio level for non-audio track: ${ssrc}`);
 
             return;
+        } else if (track.isLocal() !== isLocal) {
+            logger.error(
+                `${track} was expected to ${isLocal ? 'be' : 'not be'} local`);
         }
 
-        track.setAudioLevel(audioLevel);
-    }
-
-    /**
-     * Searches in localTracks(session stores ssrc for audio and video) and
-     * remoteTracks for the ssrc and returns the corresponding resource.
-     * @param {number} ssrc the ssrc to check.
-     */
-    getResourceBySSRC(ssrc) {
-        const track = this._getTrackBySSRC(ssrc);
-
-        return track ? track.getParticipantId() : null;
+        track.setAudioLevel(tpc, audioLevel);
     }
 
-    /**
-     * Finds a track (either local or remote) which runs on the given SSRC.
-     * @param {number} ssrc
-     * @return {JitsiTrack|undefined}
-     * @private
-     */
-    _getTrackBySSRC(ssrc) {
-        let track
-            = this.getLocalTracks().find(
-                localTrack =>
-                    Array.from(this.peerConnections.values())
-                         .find(pc => pc.getLocalSSRC(localTrack) === ssrc)
-                );
-
-        if (!track) {
-            track = this._getRemoteTrackBySSRC(ssrc);
-        }
-
-        return track;
-    }
-
-    /**
-     * Searches in remoteTracks for the ssrc and returns the corresponding
-     * track.
-     * @param {number} ssrc the ssrc to check.
-     * @return {JitsiRemoteTrack|undefined} return the first remote track that
-     * matches given SSRC or <tt>undefined</tt> if no such track was found.
-     * @private
-     */
-    _getRemoteTrackBySSRC(ssrc) {
-        return this.getRemoteTracks().find(
-            remoteTrack => ssrc === remoteTrack.getSSRC());
-    }
+    /* eslint-enable max-params */
 
     /**
      * Sends message via the datachannels.

modules/RTC/TraceablePeerConnection.js

     return remoteTracks;
 };
 
+/**
+ * Tries to find {@link JitsiTrack} for given SSRC number. It will search both
+ * local and remote tracks bound to this instance.
+ * @param {number} ssrc
+ * @return {JitsiTrack|null}
+ */
+TraceablePeerConnection.prototype.getTrackBySSRC = function(ssrc) {
+    if (typeof ssrc !== 'number') {
+        throw new Error(`SSRC ${ssrc} is not a number`);
+    }
+    for (const localTrack of this.localTracks.values()) {
+        if (this.getLocalSSRC(localTrack) === ssrc) {
+            return localTrack;
+        }
+    }
+    for (const remoteTrack of this.getRemoteTracks()) {
+        if (remoteTrack.getSSRC() === ssrc) {
+            return remoteTrack;
+        }
+    }
+
+    return null;
+};
+
 /**
  * Called when new remote MediaStream is added to the PeerConnection.
  * @param {MediaStream} stream the WebRTC MediaStream for remote participant

modules/connectivity/ConnectionQuality.js

         /**
          * Holds statistics about the local connection quality.
          */
-        this._localStats = { connectionQuality: 100 };
+        this._localStats = {
+            connectionQuality: 100,
+            jvbRTT: undefined
+        };
 
         /**
          * The time this._localStats.connectionQuality was last updated.
         // jitsi-meet
         // TODO: We should keep track of the remote resolution in _remoteStats,
         // and notify about changes via separate events.
-        conference.on(
-            ConferenceEvents.CONNECTION_STATS,
+        conference.statistics.addConnectionStatsListener(
             this._updateLocalStats.bind(this));
 
         // Save the last time we were unmuted.
             bitrate: this._localStats.bitrate,
             packetLoss: this._localStats.packetLoss,
             connectionQuality: this._localStats.connectionQuality,
-            jvbRTT: this._localStats.transport
-                    && this._localStats.transport.length
-                    && !this._localStats.transport[0].p2p
-                        ? this._localStats.transport[0].rtt : undefined
+            jvbRTT: this._localStats.jvbRTT
         };
 
         // TODO: It looks like the remote participants don't really "care"
 
     /**
      * Updates the local statistics
+     * @param {TraceablePeerConnection} tpc the peerconnection which emitted
+     * the stats
      * @param data new statistics
      */
-    _updateLocalStats(data) {
+    _updateLocalStats(tpc, data) {
+        // Update jvbRTT
+        if (!tpc.isP2P) {
+            const jvbRTT
+                = data.transport
+                    && data.transport.length && data.transport[0].rtt;
+
+            this._localStats.jvbRTT = jvbRTT ? jvbRTT : undefined;
+        }
+
+        // Do not continue with processing of other stats if they do not
+        // originate from the active peerconnection
+        if (tpc !== this._conference.getActivePeerConnection()) {
+            return;
+        }
+
         let key;
         const updateLocalConnectionQuality
             = !this._conference.isConnectionInterrupted();

modules/statistics/AvgRTPStatsReporter.js

 import * as ConnectionQualityEvents
     from '../../service/connectivity/ConnectionQualityEvents';
 import * as ConferenceEvents from '../../JitsiConferenceEvents';
+import * as MediaType from '../../service/RTC/MediaType';
 import RTCBrowserType from '../RTC/RTCBrowserType';
 import Statistics from './statistics';
+import * as VideoType from '../../service/RTC/VideoType';
 
 const logger = getLogger(__filename);
 
             logger.error(
                 `${this.name} - invalid value for idx: ${this.count}`,
                 nextValue);
-
-            return;
+        } else if (!isNaN(nextValue)) {
+            this.sum += nextValue;
+            this.count += 1;
         }
-        this.sum += nextValue;
-        this.count += 1;
     }
 
     /**
     }
 }
 
+/**
+ * Class gathers the stats that are calculated and reported for a
+ * {@link TraceablePeerConnection} even if it's not currently active. For
+ * example we want to monitor RTT for the JVB connection while in P2P mode.
+ */
+class ConnectionAvgStats {
+    /**
+     * Creates new <tt>ConnectionAvgStats</tt>
+     * @param {JitsiConference} conference
+     * @param {boolean} isP2P
+     * @param {number} n the number of samples, before arithmetic mean is to be
+     * calculated and values submitted to the analytics module.
+     */
+    constructor(conference, isP2P, n) {
+        /**
+         * Is this instance for JVB or P2P connection ?
+         * @type {boolean}
+         */
+        this.isP2P = isP2P;
+
+        /**
+         * How many samples are to be included in arithmetic mean calculation.
+         * @type {number}
+         * @private
+         */
+        this._n = n;
+
+        /**
+         * The current sample index. Starts from 0 and goes up to {@link _n})
+         * when analytics report will be submitted.
+         * @type {number}
+         * @private
+         */
+        this._sampleIdx = 0;
+
+        /**
+         * Average round trip time reported by the ICE candidate pair.
+         * @type {AverageStatReport}
+         */
+        this._avgRTT = new AverageStatReport('stat.avg.rtt');
+
+        /**
+         * Map stores average RTT to the JVB reported by remote participants.
+         * Mapped per participant id {@link JitsiParticipant.getId}.
+         *
+         * This is used only when {@link ConnectionAvgStats.isP2P} equals to
+         * <tt>false</tt>.
+         *
+         * @type {Map<string,AverageStatReport>}
+         * @private
+         */
+        this._avgRemoteRTTMap = new Map();
+
+        /**
+         * The conference for which stats will be collected and reported.
+         * @type {JitsiConference}
+         * @private
+         */
+        this._conference = conference;
+
+        this._onConnectionStats = (tpc, stats) => {
+            if (this.isP2P === tpc.isP2P) {
+                this._calculateAvgStats(stats);
+            }
+        };
+        conference.statistics.addConnectionStatsListener(
+            this._onConnectionStats);
+
+        if (!this.isP2P) {
+            this._onUserLeft = id => this._avgRemoteRTTMap.delete(id);
+            conference.on(ConferenceEvents.USER_LEFT, this._onUserLeft);
+
+            this._onRemoteStatsUpdated
+                = (id, data) => this._processRemoteStats(id, data);
+            conference.on(
+                ConnectionQualityEvents.REMOTE_STATS_UPDATED,
+                this._onRemoteStatsUpdated);
+        }
+    }
+
+    /**
+     * Processes next batch of stats.
+     * @param {go figure} data
+     * @private
+     */
+    _calculateAvgStats(data) {
+        if (!data) {
+            logger.error('No stats');
+
+            return;
+        }
+
+        if (RTCBrowserType.supportsRTTStatistics()) {
+            if (data.transport && data.transport.length) {
+                this._avgRTT.addNext(data.transport[0].rtt);
+            }
+        }
+
+        this._sampleIdx += 1;
+
+        if (this._sampleIdx >= this._n) {
+            if (RTCBrowserType.supportsRTTStatistics()) {
+                this._avgRTT.report(this.isP2P);
+
+                // Report end to end RTT only for JVB
+                if (!this.isP2P) {
+                    const avgRemoteRTT = this._calculateAvgRemoteRTT();
+                    const avgLocalRTT = this._avgRTT.calculate();
+
+                    if (!isNaN(avgLocalRTT) && !isNaN(avgRemoteRTT)) {
+                        Statistics.analytics.sendEvent(
+                            'stat.avg.end2endrtt',
+                            { value: avgLocalRTT + avgRemoteRTT });
+                    }
+                }
+            }
+
+            this._resetAvgStats();
+        }
+    }
+
+    /**
+     * Calculates arithmetic mean of all RTTs towards the JVB reported by
+     * participants.
+     * @return {number|NaN} NaN if not available (not enough data)
+     * @private
+     */
+    _calculateAvgRemoteRTT() {
+        let count = 0, sum = 0;
+
+        // FIXME should we ignore RTT for participant
+        // who "is having connectivity issues" ?
+        for (const remoteAvg of this._avgRemoteRTTMap.values()) {
+            const avg = remoteAvg.calculate();
+
+            if (!isNaN(avg)) {
+                sum += avg;
+                count += 1;
+                remoteAvg.reset();
+            }
+        }
+
+        return sum / count;
+    }
+
+    /**
+     * Processes {@link ConnectionQualityEvents.REMOTE_STATS_UPDATED} to analyse
+     * RTT towards the JVB reported by each participant.
+     * @param {string} id {@link JitsiParticipant.getId}
+     * @param {go figure in ConnectionQuality.js} data
+     * @private
+     */
+    _processRemoteStats(id, data) {
+        const validData = typeof data.jvbRTT === 'number';
+        let rttAvg = this._avgRemoteRTTMap.get(id);
+
+        if (!rttAvg && validData) {
+            rttAvg = new AverageStatReport(`${id}.stat.rtt`);
+            this._avgRemoteRTTMap.set(id, rttAvg);
+        }
+
+        if (validData) {
+            rttAvg.addNext(data.jvbRTT);
+        } else if (rttAvg) {
+            this._avgRemoteRTTMap.delete(id);
+        }
+    }
+
+    /**
+     * Reset cache of all averages and {@link _sampleIdx}.
+     * @private
+     */
+    _resetAvgStats() {
+        this._avgRTT.reset();
+        if (this._avgRemoteRTTMap) {
+            this._avgRemoteRTTMap.clear();
+        }
+        this._sampleIdx = 0;
+    }
+
+    /**
+     *
+     */
+    dispose() {
+        this._conference.statistics.removeConnectionStatsListener(
+            this._onConnectionStats);
+        if (!this.isP2P) {
+            this._conference.off(
+                ConnectionQualityEvents.REMOTE_STATS_UPDATED,
+                this._onRemoteStatsUpdated);
+            this._conference.off(
+                ConferenceEvents.USER_LEFT,
+                this._onUserLeft);
+        }
+    }
+}
+
 /**
  * Reports average RTP statistics values (arithmetic mean) to the analytics
  * module for things like bit rate, bandwidth, packet loss etc. It keeps track
         this._conference = conference;
 
         /**
-         * Average upload bitrate
+         * Average audio upload bitrate
+         * @type {AverageStatReport}
+         * @private
+         */
+        this._avgAudioBitrateUp
+            = new AverageStatReport('stat.avg.bitrate.audio.upload');
+
+        /**
+         * Average audio download bitrate
+         * @type {AverageStatReport}
+         * @private
+         */
+        this._avgAudioBitrateDown
+            = new AverageStatReport('stat.avg.bitrate.audio.download');
+
+        /**
+         * Average video upload bitrate
          * @type {AverageStatReport}
          * @private
          */
-        this._avgBitrateUp = new AverageStatReport('stat.avg.bitrate.upload');
+        this._avgVideoBitrateUp
+            = new AverageStatReport('stat.avg.bitrate.video.upload');
 
         /**
-         * Average download bitrate
+         * Average video download bitrate
          * @type {AverageStatReport}
          * @private
          */
-        this._avgBitrateDown
-            = new AverageStatReport('stat.avg.bitrate.download');
+        this._avgVideoBitrateDown
+            = new AverageStatReport('stat.avg.bitrate.video.download');
 
         /**
          * Average upload bandwidth
         this._avgRemoteFPS = new AverageStatReport('stat.avg.framerate.remote');
 
         /**
-         * Map stores average RTT to the JVB reported by remote participants.
-         * Mapped per participant id {@link JitsiParticipant.getId}.
-         * @type {Map<string,AverageStatReport>}
+         * Average FPS for remote screen streaming videos (reported only if not
+         * a <tt>NaN</tt>).
+         * @type {AverageStatReport}
          * @private
          */
-        this._avgRemoteRTTMap = new Map();
+        this._avgRemoteScreenFPS
+            = new AverageStatReport('stat.avg.framerate.screen.remote');
 
         /**
-         * Average round trip time reported by the ICE candidate pair.
-         * FIXME currently reported only for P2P
+         * Average FPS for local video (camera)
          * @type {AverageStatReport}
          * @private
          */
-        this._avgRTT = new AverageStatReport('stat.avg.rtt');
+        this._avgLocalFPS = new AverageStatReport('stat.avg.framerate.local');
 
         /**
-         * Average FPS for local video
+         * Average FPS for local screen streaming video (reported only if not
+         * a <tt>NaN</tt>).
          * @type {AverageStatReport}
          * @private
          */
-        this._avgLocalFPS = new AverageStatReport('stat.avg.framerate.local');
+        this._avgLocalScreenFPS
+            = new AverageStatReport('stat.avg.framerate.screen.local');
 
         /**
          * Average connection quality as defined by
             ConnectionQualityEvents.LOCAL_STATS_UPDATED,
             this._onLocalStatsUpdated);
 
-        this._onRemoteStatsUpdated
-            = (id, data) => this._processRemoteStats(id, data);
-        conference.on(
-            ConnectionQualityEvents.REMOTE_STATS_UPDATED,
-            this._onRemoteStatsUpdated);
-
         this._onP2PStatusChanged = () => {
             logger.debug('Resetting average stats calculation');
             this._resetAvgStats();
+            this.jvbStatsMonitor._resetAvgStats();
+            this.p2pStatsMonitor._resetAvgStats();
         };
         conference.on(
             ConferenceEvents.P2P_STATUS,
             this._onP2PStatusChanged);
 
-        this._onUserLeft = id => this._avgRemoteRTTMap.delete(id);
-        conference.on(ConferenceEvents.USER_LEFT, this._onUserLeft);
-    }
-
-    /**
-     * Calculates arithmetic mean of all RTTs towards the JVB reported by
-     * participants.
-     * @return {number|NaN} NaN if not available (not enough data)
-     * @private
-     */
-    _calculateAvgRemoteRTT() {
-        let count = 0, sum = 0;
-
-        // FIXME should we ignore RTT for participant
-        // who "is having connectivity issues" ?
-        for (const remoteAvg of this._avgRemoteRTTMap.values()) {
-            const avg = remoteAvg.calculate();
-
-            if (!isNaN(avg)) {
-                sum += avg;
-                count += 1;
-                remoteAvg.reset();
-            }
-        }
+        this.jvbStatsMonitor
+            = new ConnectionAvgStats(conference, false /* JVB */, n);
 
-        return sum / count;
+        this.p2pStatsMonitor
+            = new ConnectionAvgStats(conference, true /* P2P */, n);
     }
 
     /**
             return;
         }
 
-        this._avgBitrateUp.addNext(bitrate.upload);
-        this._avgBitrateDown.addNext(bitrate.download);
+        this._avgAudioBitrateUp.addNext(bitrate.audio.upload);
+        this._avgAudioBitrateDown.addNext(bitrate.audio.download);
+
+        this._avgVideoBitrateUp.addNext(bitrate.video.upload);
+        this._avgVideoBitrateDown.addNext(bitrate.video.download);
 
         if (RTCBrowserType.supportsBandwidthStatistics()) {
             this._avgBandwidthUp.addNext(bandwidth.upload);
         this._avgPacketLossUp.addNext(packetLoss.upload);
         this._avgPacketLossDown.addNext(packetLoss.download);
         this._avgPacketLossTotal.addNext(packetLoss.total);
-        this._avgCQ.addNext(data.connectionQuality);
 
-        if (RTCBrowserType.supportsRTTStatistics()) {
-            if (data.transport && data.transport.length) {
-                this._avgRTT.addNext(data.transport[0].rtt);
-            } else {
-                this._avgRTT.reset();
-            }
-        }
+        this._avgCQ.addNext(data.connectionQuality);
 
         if (frameRate) {
             this._avgRemoteFPS.addNext(
-                this._calculateAvgVideoFps(frameRate, false /* remote */));
+                this._calculateAvgVideoFps(
+                    frameRate, false /* remote */, VideoType.CAMERA));
+            this._avgRemoteScreenFPS.addNext(
+                this._calculateAvgVideoFps(
+                    frameRate, false /* remote */, VideoType.DESKTOP));
+
             this._avgLocalFPS.addNext(
-                this._calculateAvgVideoFps(frameRate, true /* local */));
+                this._calculateAvgVideoFps(
+                    frameRate, true /* local */, VideoType.CAMERA));
+            this._avgLocalScreenFPS.addNext(
+                this._calculateAvgVideoFps(
+                    frameRate, true /* local */, VideoType.DESKTOP));
         }
 
         this._sampleIdx += 1;
 
         if (this._sampleIdx >= this._n) {
-            this._avgBitrateUp.report(isP2P);
-            this._avgBitrateDown.report(isP2P);
+            this._avgAudioBitrateUp.report(isP2P);
+            this._avgAudioBitrateDown.report(isP2P);
+
+            this._avgVideoBitrateUp.report(isP2P);
+            this._avgVideoBitrateDown.report(isP2P);
+
             if (RTCBrowserType.supportsBandwidthStatistics()) {
                 this._avgBandwidthUp.report(isP2P);
                 this._avgBandwidthDown.report(isP2P);
             this._avgPacketLossUp.report(isP2P);
             this._avgPacketLossDown.report(isP2P);
             this._avgPacketLossTotal.report(isP2P);
+
             this._avgRemoteFPS.report(isP2P);
+            if (!isNaN(this._avgRemoteScreenFPS.calculate())) {
+                this._avgRemoteScreenFPS.report(isP2P);
+            }
             this._avgLocalFPS.report(isP2P);
-            this._avgCQ.report(isP2P);
-
-            if (RTCBrowserType.supportsRTTStatistics()) {
-                this._avgRTT.report(isP2P);
-                if (!isP2P) {
-                    const avgRemoteRTT = this._calculateAvgRemoteRTT();
-                    const avgLocalRTT = this._avgRTT.calculate();
-
-                    if (!isNaN(avgLocalRTT) && !isNaN(avgRemoteRTT)) {
-                        Statistics.analytics.sendEvent(
-                            'stat.avg.end2endrtt',
-                            avgLocalRTT + avgRemoteRTT);
-                    }
-                }
+            if (!isNaN(this._avgLocalScreenFPS.calculate())) {
+                this._avgLocalScreenFPS.report(isP2P);
             }
 
+            this._avgCQ.report(isP2P);
+
             this._resetAvgStats();
         }
     }
      * @param {go figure} frameRate
      * @param {boolean} isLocal if the average is to be calculated for the local
      * video or <tt>false</tt> if for remote videos.
+     * @param {VideoType} videoType
      * @return {number|NaN} average FPS or <tt>NaN</tt> if there are no samples.
      * @private
      */
-    _calculateAvgVideoFps(frameRate, isLocal) {
+    _calculateAvgVideoFps(frameRate, isLocal, videoType) {
+        let peerFpsSum = 0;
         let peerCount = 0;
-        let subFrameAvg = 0;
         const myID = this._conference.myUserId();
 
         for (const peerID of Object.keys(frameRate)) {
             if (isLocal ? peerID === myID : peerID !== myID) {
-                const videos = frameRate[peerID];
-                const ssrcs = Object.keys(videos);
-
-                if (ssrcs.length) {
-                    let peerAvg = 0;
-
-                    for (const ssrc of ssrcs) {
-                        peerAvg += parseInt(videos[ssrc], 10);
+                const participant
+                    = isLocal
+                        ? null : this._conference.getParticipantById(peerID);
+                const videosFps = frameRate[peerID];
+
+                // Do not continue without participant for non local peerID
+                if ((isLocal || participant) && videosFps) {
+                    const peerAvgFPS
+                        = this._calculatePeerAvgVideoFps(
+                            videosFps, participant, videoType);
+
+                    if (!isNaN(peerAvgFPS)) {
+                        peerFpsSum += peerAvgFPS;
+                        peerCount += 1;
                     }
-
-                    peerAvg /= ssrcs.length;
-
-                    subFrameAvg += peerAvg;
-                    peerCount += 1;
                 }
             }
         }
 
-        return subFrameAvg / peerCount;
+        return peerFpsSum / peerCount;
     }
 
     /**
-     * Processes {@link ConnectionQualityEvents.REMOTE_STATS_UPDATED} to analyse
-     * RTT towards the JVB reported by each participant.
-     * @param {string} id {@link JitsiParticipant.getId}
-     * @param {go figure in ConnectionQuality.js} data
+     * Calculate average FPS for either remote or local participant
+     * @param {object} videos maps FPS per video SSRC
+     * @param {JitsiParticipant|null} participant remote participant or
+     * <tt>null</tt> for local FPS calculation.
+     * @param {VideoType} videoType the type of the video for which an average
+     * will be calculated.
+     * @return {number|NaN} average FPS of all participant's videos or
+     * <tt>NaN</tt> if currently not available
      * @private
      */
-    _processRemoteStats(id, data) {
-        const validData = typeof data.jvbRTT === 'number';
-        let rttAvg = this._avgRemoteRTTMap.get(id);
-
-        if (!rttAvg && validData) {
-            rttAvg = new AverageStatReport(`${id}.stat.rtt`);
-            this._avgRemoteRTTMap.set(id, rttAvg);
+    _calculatePeerAvgVideoFps(videos, participant, videoType) {
+        let ssrcs = Object.keys(videos).map(ssrc => Number(ssrc));
+        let videoTracks = null;
+
+        // NOTE that this method is supposed to be called for the stats
+        // received from the current peerconnection.
+        const tpc = this._conference.getActivePeerConnection();
+
+        if (participant) {
+            videoTracks = participant.getTracksByMediaType(MediaType.VIDEO);
+            if (videoTracks) {
+                ssrcs
+                    = ssrcs.filter(
+                        ssrc => videoTracks.find(
+                            track => !track.isMuted()
+                                && track.getSSRC() === ssrc
+                                && track.videoType === videoType));
+            }
+        } else {
+            videoTracks = this._conference.getLocalTracks(MediaType.VIDEO);
+            ssrcs
+                = ssrcs.filter(
+                    ssrc => videoTracks.find(
+                        track => !track.isMuted()
+                            && tpc.getLocalSSRC(track) === ssrc
+                            && track.videoType === videoType));
         }
 
-        if (validData) {
-            rttAvg.addNext(data.jvbRTT);
-        } else if (rttAvg) {
-            this._avgRemoteRTTMap.delete(id);
+        let peerFpsSum = 0;
+        let peerSsrcCount = 0;
+
+        for (const ssrc of ssrcs) {
+            const peerSsrcFps = Number(videos[ssrc]);
+
+            // FPS is reported as 0 for users with no video
+            if (!isNaN(peerSsrcFps) && peerSsrcFps > 0) {
+                peerFpsSum += peerSsrcFps;
+                peerSsrcCount += 1;
+            }
         }
+
+        return peerFpsSum / peerSsrcCount;
     }
 
     /**
      * @private
      */
     _resetAvgStats() {
-        this._avgBitrateUp.reset();
-        this._avgBitrateDown.reset();
+        this._avgAudioBitrateUp.reset();
+        this._avgAudioBitrateDown.reset();
+
+        this._avgVideoBitrateUp.reset();
+        this._avgVideoBitrateDown.reset();
+
         this._avgBandwidthUp.reset();
         this._avgBandwidthDown.reset();
+
         this._avgPacketLossUp.reset();
         this._avgPacketLossDown.reset();
+        this._avgPacketLossTotal.reset();
+
         this._avgRemoteFPS.reset();
+        this._avgRemoteScreenFPS.reset();
         this._avgLocalFPS.reset();
+        this._avgLocalScreenFPS.reset();
+
         this._avgCQ.reset();
-        this._avgRTT.reset();
-        this._avgRemoteRTTMap.clear();
+
         this._sampleIdx = 0;
     }
 
         this._conference.off(
             ConnectionQualityEvents.LOCAL_STATS_UPDATED,
             this._onLocalStatsUpdated);
-        this._conference.off(
-            ConnectionQualityEvents.REMOTE_STATS_UPDATED,
-            this._onRemoteStatsUpdated);
-        this._conference.off(
-            ConferenceEvents.USER_LEFT,
-            this._onUserLeft);
+        this.jvbStatsMonitor.dispose();
+        this.p2pStatsMonitor.dispose();
     }
 }

modules/statistics/RTPStatsCollector.js

     };
     let bitrateDownload = 0;
     let bitrateUpload = 0;
-    const resolutions = new Map();
-    const framerates = new Map();
+    const resolutions = {};
+    const framerates = {};
+    let audioBitrateDownload = 0;
+    let audioBitrateUpload = 0;
+    let videoBitrateDownload = 0;
+    let videoBitrateUpload = 0;
 
     for (const [ ssrc, ssrcStats ] of this.ssrc2stats) {
         // process packet loss stats
         bitrateDownload += ssrcStats.bitrate.download;
         bitrateUpload += ssrcStats.bitrate.upload;
 
-        ssrcStats.resetBitrate();
+        // collect resolutions and framerates
+        const track = this.peerconnection.getTrackBySSRC(ssrc);
+
+        if (track) {
+            if (track.isAudioTrack()) {
+                audioBitrateDownload += ssrcStats.bitrate.download;
+                audioBitrateUpload += ssrcStats.bitrate.upload;
+            } else {
+                videoBitrateDownload += ssrcStats.bitrate.download;
+                videoBitrateUpload += ssrcStats.bitrate.upload;
+            }
+
+            const participantId = track.getParticipantId();
+
+            if (participantId) {
+                const resolution = ssrcStats.resolution;
 
-        // collect resolutions
-        resolutions.set(ssrc, ssrcStats.resolution);
+                if (resolution.width
+                        && resolution.height
+                        && resolution.width !== -1
+                        && resolution.height !== -1) {
+                    const userResolutions = resolutions[participantId] || {};
 
-        // collect framerates
-        framerates.set(ssrc, ssrcStats.framerate);
+                    userResolutions[ssrc] = resolution;
+                    resolutions[participantId] = userResolutions;
+                }
+                if (ssrcStats.framerate !== 0) {
+                    const userFramerates = framerates[participantId] || {};
+
+                    userFramerates[ssrc] = ssrcStats.framerate;
+                    framerates[participantId] = userFramerates;
+                }
+            } else {
+                logger.error(`No participant ID returned by ${track}`);
+            }
+        } else if (this.peerconnection.isP2P) {
+            // NOTE For JVB connection there are JVB tracks reported in
+            // the stats, but they do not have corresponding JitsiRemoteTrack
+            // instances stored in TPC. It is not trivial to figure out that
+            // a SSRC belongs to JVB, so we print this error ony for the P2P
+            // connection for the time being.
+            //
+            // Also there will be reports for tracks removed from the session,
+            // for the users who have left the conference.
+            logger.error(
+                `JitsiTrack not found for SSRC ${ssrc}`
+                    + ` in ${this.peerconnection}`);
+        }
+
+        ssrcStats.resetBitrate();
     }
 
     this.eventEmitter.emit(
         StatisticsEvents.BYTE_SENT_STATS, this.peerconnection, byteSentStats);
 
-    this.conferenceStats.bitrate
-      = { 'upload': bitrateUpload,
-          'download': bitrateDownload };
+    this.conferenceStats.bitrate = {
+        'upload': bitrateUpload,
+        'download': bitrateDownload
+    };
+
+    this.conferenceStats.bitrate.audio = {
+        'upload': audioBitrateUpload,
+        'download': audioBitrateDownload
+    };
+
+    this.conferenceStats.bitrate.video = {
+        'upload': videoBitrateUpload,
+        'download': videoBitrateDownload
+    };
 
     this.conferenceStats.packetLoss = {
         total:
         upload:
             calculatePacketLoss(lostPackets.upload, totalPackets.upload)
     };
-    this.eventEmitter.emit(StatisticsEvents.CONNECTION_STATS, {
-        'bandwidth': this.conferenceStats.bandwidth,
-        'bitrate': this.conferenceStats.bitrate,
-        'packetLoss': this.conferenceStats.packetLoss,
-        'resolution': resolutions,
-        'framerate': framerates,
-        'transport': this.conferenceStats.transport
-    });
+    this.eventEmitter.emit(
+        StatisticsEvents.CONNECTION_STATS,
+        this.peerconnection,
+        {
+            'bandwidth': this.conferenceStats.bandwidth,
+            'bitrate': this.conferenceStats.bitrate,
+            'packetLoss': this.conferenceStats.packetLoss,
+            'resolution': resolutions,
+            'framerate': framerates,
+            'transport': this.conferenceStats.transport
+        });
     this.conferenceStats.transport = [];
 };
 
             // seems to vary between 0 and around 32k.
             audioLevel = audioLevel / 32767;
             this.eventEmitter.emit(
-                StatisticsEvents.AUDIO_LEVEL, ssrc, audioLevel, isLocal);
+                StatisticsEvents.AUDIO_LEVEL,
+                this.peerconnection,
+                ssrc,
+                audioLevel,
+                isLocal);
         }
     }
 };

modules/statistics/statistics.js

  * @param options
  */
 export default function Statistics(xmpp, options) {
-    this.rtpStats = null;
+    /**
+     * {@link RTPStats} mapped by {@link TraceablePeerConnection.id} which
+     * collect RTP statistics for each peerconnection.
+     * @type {Map<string, RTPStats}
+     */
+    this.rtpStatsMap = new Map();
     this.eventEmitter = new EventEmitter();
     this.xmpp = xmpp;
     this.options = options || {};
     }
 });
 
+/**
+ * Starts collecting RTP stats for given peerconnection.
+ * @param {TraceablePeerConnection} peerconnection
+ */
 Statistics.prototype.startRemoteStats = function(peerconnection) {
-    this.stopRemoteStats();
+    this.stopRemoteStats(peerconnection);
 
     try {
-        this.rtpStats
+        const rtpStats
             = new RTPStats(peerconnection,
                     Statistics.audioLevelsInterval, 2000, this.eventEmitter);
-        this.rtpStats.start(Statistics.audioLevelsEnabled);
+
+        rtpStats.start(Statistics.audioLevelsEnabled);
+        this.rtpStatsMap.set(peerconnection.id, rtpStats);
     } catch (e) {
-        this.rtpStats = null;
         logger.error(`Failed to start collecting remote statistics: ${e}`);
     }
 };
         for (const callStats of this.callsStatsInstances.values()) {
             this.stopCallStats(callStats.tpc);
         }
-        this.stopRemoteStats();
+        for (const tpcId of this.rtpStatsMap.keys()) {
+            this._stopRemoteStats(tpcId);
+        }
         if (this.eventEmitter) {
             this.eventEmitter.removeAllListeners();
         }
     }
 };
 
-Statistics.prototype.stopRemoteStats = function() {
-    if (!this.rtpStats) {
-        return;
+/**
+ * Stops remote RTP stats for given peerconnection ID.
+ * @param {string} tpcId {@link TraceablePeerConnection.id}
+ * @private
+ */
+Statistics.prototype._stopRemoteStats = function(tpcId) {
+    const rtpStats = this.rtpStatsMap.get(tpcId);
+
+    if (rtpStats) {
+        rtpStats.stop();
+        this.rtpStatsMap.delete(tpcId);
     }
+};
 
-    this.rtpStats.stop();
-    this.rtpStats = null;
+/**
+ * Stops collecting RTP stats for given peerconnection
+ * @param {TraceablePeerConnection} tpc
+ */
+Statistics.prototype.stopRemoteStats = function(tpc) {
+    this._stopRemoteStats(tpc.id);
 };
 
 // CALSTATS METHODS