@webex/plugin-meetings 2.60.0-next.9 → 2.60.1

package/src/statsAnalyzer/index.ts

@@ -1,24 +1,18 @@
 /* eslint-disable prefer-destructuring */
 
 import {cloneDeep} from 'lodash';
-import {ConnectionState} from '@webex/internal-media-core';
 
 import EventsScope from '../common/events/events-scope';
 import {
   DEFAULT_GET_STATS_FILTER,
+  CONNECTION_STATE,
   STATS,
   MQA_INTEVAL,
   NETWORK_TYPE,
   MEDIA_DEVICES,
   _UNKNOWN_,
 } from '../constants';
-import {
-  emptyAudioReceive,
-  emptyAudioTransmit,
-  emptyMqaInterval,
-  emptyVideoReceive,
-  emptyVideoTransmit,
-} from '../mediaQualityMetrics/config';
+import mqaData from '../mediaQualityMetrics/config';
 import LoggerProxy from '../common/logs/logger-proxy';
 
 import defaultStats from './global';
@@ -28,34 +22,17 @@ import {
   getVideoSenderMqa,
   getVideoReceiverMqa,
 } from './mqaUtil';
-import {ReceiveSlot} from '../multistream/receiveSlot';
 
 export const EVENTS = {
   MEDIA_QUALITY: 'MEDIA_QUALITY',
+  NO_FRAMES_SENT: 'NO_FRAMES_SENT',
+  NO_VIDEO_ENCODED: 'NO_VIDEO_ENCODED',
   LOCAL_MEDIA_STARTED: 'LOCAL_MEDIA_STARTED',
   LOCAL_MEDIA_STOPPED: 'LOCAL_MEDIA_STOPPED',
   REMOTE_MEDIA_STARTED: 'REMOTE_MEDIA_STARTED',
   REMOTE_MEDIA_STOPPED: 'REMOTE_MEDIA_STOPPED',
 };
 
-const emptySender = {
-  trackLabel: '',
-  maxPacketLossRatio: 0,
-  availableBandwidth: 0,
-  bytesSent: 0,
-  meanRemoteJitter: [],
-  meanRoundTripTime: [],
-};
-
-const emptyReceiver = {
-  availableBandwidth: 0,
-  bytesReceived: 0,
-  meanRtpJitter: [],
-  meanRoundTripTime: [],
-};
-
-type ReceiveSlotCallback = (csi: number) => ReceiveSlot | undefined;
-
 /**
  * Stats Analyzer class that will emit events based on detected quality
  *
@@ -69,29 +46,26 @@ export class StatsAnalyzer extends EventsScope {
   lastEmittedStartStopEvent: any;
   lastMqaDataSent: any;
   lastStatsResults: any;
+  localMQEStats: any;
   meetingMediaStatus: any;
   mqaInterval: NodeJS.Timeout;
   mqaSentCount: any;
   networkQualityMonitor: any;
-  mediaConnection: any;
+  peerConnection: any;
   statsInterval: NodeJS.Timeout;
   statsResults: any;
   statsStarted: any;
-  successfulCandidatePair: any;
-  receiveSlotCallback: ReceiveSlotCallback;
 
   /**
    * Creates a new instance of StatsAnalyzer
    * @constructor
    * @public
    * @param {Object} config SDK Configuration Object
-   * @param {Function} receiveSlotCallback Callback used to access receive slots.
    * @param {Object} networkQualityMonitor class for assessing network characteristics (jitter, packetLoss, latency)
    * @param {Object} statsResults Default properties for stats
    */
   constructor(
     config: any,
-    receiveSlotCallback: ReceiveSlotCallback = () => undefined,
     networkQualityMonitor: object = {},
     statsResults: object = defaultStats
   ) {
@@ -103,30 +77,147 @@ export class StatsAnalyzer extends EventsScope {
     this.networkQualityMonitor = networkQualityMonitor;
     this.correlationId = config.correlationId;
     this.mqaSentCount = -1;
-    this.lastMqaDataSent = {};
-    this.lastEmittedStartStopEvent = {};
-    this.receiveSlotCallback = receiveSlotCallback;
-    this.successfulCandidatePair = {};
+    this.lastMqaDataSent = {
+      resolutions: {
+        video: {send: {}, recv: {}},
+        audio: {send: {}, recv: {}},
+        share: {send: {}, recv: {}},
+      },
+      video: {send: {}, recv: {}},
+      audio: {send: {}, recv: {}},
+      share: {send: {}, recv: {}},
+    };
+    this.localMQEStats = {
+      audio: {
+        RX: {
+          packetsLost: [],
+          jitter: [],
+          latency: [],
+          bitRate: [],
+        },
+        TX: {
+          packetsLost: [],
+          jitter: [],
+          latency: [],
+          bitRate: [],
+        },
+      },
+      video: {
+        RX: {
+          packetsLost: [],
+          jitter: [],
+          latency: [],
+          bitRate: [],
+          frameRate: [],
+          resolutionWidth: [],
+          resolutionHeight: [],
+          requestedKeyFrame: [],
+          receivedKeyFrame: [],
+        },
+        TX: {
+          packetsLost: [],
+          jitter: [],
+          latency: [],
+          bitRate: [],
+          frameRate: [],
+          resolutionWidth: [],
+          resolutionHeight: [],
+          requestedKeyFrame: [],
+          receivedKeyFrame: [],
+        },
+      },
+    };
+    this.lastEmittedStartStopEvent = {
+      audio: {
+        local: undefined,
+        remote: undefined,
+      },
+      video: {
+        local: undefined,
+        remote: undefined,
+      },
+      share: {
+        local: undefined,
+        remote: undefined,
+      },
+    };
+  }
+
+  populateResults(lastMqa) {
+    // Audio
+
+    this.localMQEStats.audio.RX.packetsLost.push(lastMqa.audioReceive[0].common.mediaHopByHopLost);
+    this.localMQEStats.audio.RX.jitter.push(lastMqa.audioReceive[0].streams[0].common.rtpJitter);
+    this.localMQEStats.audio.RX.latency.push(lastMqa.audioReceive[0].common.roundTripTime);
+    this.localMQEStats.audio.RX.bitRate.push(
+      lastMqa.audioReceive[0].streams[0].common.receivedBitrate
+    );
+
+    this.localMQEStats.audio.TX.packetsLost.push(lastMqa.audioTransmit[0].common.remoteLossRate);
+    this.localMQEStats.audio.TX.jitter.push(lastMqa.audioTransmit[0].common.remoteJitter);
+    this.localMQEStats.audio.TX.latency.push(lastMqa.audioTransmit[0].common.roundTripTime);
+    this.localMQEStats.audio.TX.bitRate.push(
+      lastMqa.audioTransmit[0].streams[0].common.transmittedBitrate
+    );
+
+    // Video
+
+    this.localMQEStats.video.RX.packetsLost.push(lastMqa.videoReceive[0].common.mediaHopByHopLost);
+    this.localMQEStats.video.RX.jitter.push(lastMqa.videoReceive[0].streams[0].common.rtpJitter);
+    this.localMQEStats.video.RX.latency.push(
+      lastMqa.videoReceive[0].streams[0].common.roundTripTime
+    );
+    this.localMQEStats.video.RX.bitRate.push(
+      lastMqa.videoReceive[0].streams[0].common.receivedBitrate
+    );
+    this.localMQEStats.video.RX.frameRate.push(
+      lastMqa.videoReceive[0].streams[0].common.receivedFrameRate
+    );
+    this.localMQEStats.video.RX.resolutionWidth.push(
+      lastMqa.videoReceive[0].streams[0].receivedWidth
+    );
+    this.localMQEStats.video.RX.resolutionHeight.push(
+      lastMqa.videoReceive[0].streams[0].receivedHeight
+    );
+    this.localMQEStats.video.RX.requestedKeyFrame.push();
+    this.localMQEStats.video.RX.receivedKeyFrame.push();
+
+    this.localMQEStats.video.TX.packetsLost.push(lastMqa.videoTransmit[0].common.remoteLossRate);
+    this.localMQEStats.video.TX.jitter.push(lastMqa.videoTransmit[0].common.remoteJitter);
+    this.localMQEStats.video.TX.latency.push(lastMqa.videoTransmit[0].common.roundTripTime);
+    this.localMQEStats.video.TX.bitRate.push(
+      lastMqa.videoTransmit[0].streams[0].common.transmittedBitrate
+    );
+    this.localMQEStats.video.TX.frameRate.push(
+      lastMqa.videoTransmit[0].streams[0].common.transmittedFrameRate
+    );
+    this.localMQEStats.video.TX.resolutionWidth.push(
+      lastMqa.videoTransmit[0].streams[0].transmittedWidth
+    );
+    this.localMQEStats.video.TX.resolutionHeight.push(
+      lastMqa.videoTransmit[0].streams[0].transmittedHeight
+    );
+    this.localMQEStats.video.TX.requestedKeyFrame.push(
+      lastMqa.videoTransmit[0].streams[0].requestedKeyFrames
+    );
+    this.localMQEStats.video.TX.receivedKeyFrame.push();
   }
 
-  /**
-   * Resets cumulative stats arrays.
-   *
-   * @public
-   * @memberof StatsAnalyzer
-   * @returns {void}
-   */
   resetStatsResults() {
-    Object.keys(this.statsResults).forEach((mediaType) => {
-      if (mediaType.includes('recv')) {
-        this.statsResults[mediaType].recv.meanRtpJitter = [];
-      }
+    this.statsResults.audio.send.meanRemoteJitter = [];
+    this.statsResults.video.send.meanRemoteJitter = [];
+    this.statsResults.share.send.meanRemoteJitter = [];
 
-      if (mediaType.includes('send')) {
-        this.statsResults[mediaType].send.meanRemoteJitter = [];
-        this.statsResults[mediaType].send.meanRoundTripTime = [];
-      }
-    });
+    this.statsResults.audio.recv.meanRtpJitter = [];
+
+    // TODO: currently no values are present
+    this.statsResults.video.recv.meanRtpJitter = [];
+    this.statsResults.share.recv.meanRtpJitter = [];
+
+    // Reset the roundTripTime
+    this.statsResults.audio.send.meanRoundTripTime = [];
+    this.statsResults.video.send.meanRoundTripTime = [];
+    this.statsResults.share.send.meanRoundTripTime = [];
   }
 
   /**
@@ -142,101 +233,86 @@ export class StatsAnalyzer extends EventsScope {
   }
 
   /**
-   * captures MQA data from media connection
+   * captures MQA data from peerconnection
    *
    * @public
    * @memberof StatsAnalyzer
    * @returns {void}
    */
-  sendMqaData() {
-    const newMqa = cloneDeep(emptyMqaInterval);
-
-    Object.keys(this.statsResults).forEach((mediaType) => {
-      if (!this.lastMqaDataSent[mediaType]) {
-        this.lastMqaDataSent[mediaType] = {};
-      }
-
-      if (!this.lastMqaDataSent[mediaType].send && mediaType.includes('-send')) {
-        this.lastMqaDataSent[mediaType].send = {};
-      }
-
-      if (!this.lastMqaDataSent[mediaType].recv && mediaType.includes('-recv')) {
-        this.lastMqaDataSent[mediaType].recv = {};
-      }
-
-      if (mediaType.includes('audio-send') || mediaType.includes('audio-share-send')) {
-        const audioSender = cloneDeep(emptyAudioTransmit);
-
-        getAudioSenderMqa({
-          audioSender,
-          statsResults: this.statsResults,
-          lastMqaDataSent: this.lastMqaDataSent,
-          mediaType,
-        });
-        newMqa.audioTransmit.push(audioSender);
-
-        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('audio-recv') || mediaType.includes('audio-share-recv')) {
-        const audioReceiver = cloneDeep(emptyAudioReceive);
-
-        getAudioReceiverMqa({
-          audioReceiver,
-          statsResults: this.statsResults,
-          lastMqaDataSent: this.lastMqaDataSent,
-          mediaType,
-        });
-        newMqa.audioReceive.push(audioReceiver);
-
-        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
-      } else if (mediaType.includes('video-send') || mediaType.includes('video-share-send')) {
-        const videoSender = cloneDeep(emptyVideoTransmit);
-
-        getVideoSenderMqa({
-          videoSender,
-          statsResults: this.statsResults,
-          lastMqaDataSent: this.lastMqaDataSent,
-          mediaType,
-        });
-        newMqa.videoTransmit.push(videoSender);
+  public sendMqaData() {
+    const audioReceiver = mqaData.intervals[0].audioReceive[0];
+    const audioSender = mqaData.intervals[0].audioTransmit[0];
+    const videoReceiver = mqaData.intervals[0].videoReceive[0];
+    const videoSender = mqaData.intervals[0].videoTransmit[0];
+    const shareSender = mqaData.intervals[0].videoTransmit[1];
+    const shareReceiver = mqaData.intervals[0].videoReceive[1];
+
+    getAudioSenderMqa({
+      audioSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+    });
+    getAudioReceiverMqa({
+      audioReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+    });
 
-        this.lastMqaDataSent[mediaType].send = cloneDeep(this.statsResults[mediaType].send);
-      } else if (mediaType.includes('video-recv') || mediaType.includes('video-share-recv')) {
-        const videoReceiver = cloneDeep(emptyVideoReceive);
+    getVideoReceiverMqa({
+      videoReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+    });
+    getVideoSenderMqa({
+      videoSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+    });
 
-        getVideoReceiverMqa({
-          videoReceiver,
-          statsResults: this.statsResults,
-          lastMqaDataSent: this.lastMqaDataSent,
-          mediaType,
-        });
-        newMqa.videoReceive.push(videoReceiver);
+    // Capture mqa for share scenario
 
-        this.lastMqaDataSent[mediaType].recv = cloneDeep(this.statsResults[mediaType].recv);
-      }
+    getVideoSenderMqa({
+      videoSender: shareSender,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      isShareStream: true,
     });
 
-    newMqa.intervalMetadata.peerReflexiveIP = this.statsResults.connectionType.local.ipAddress;
+    getVideoReceiverMqa({
+      videoReceiver: shareReceiver,
+      statsResults: this.statsResults,
+      lastMqaDataSent: this.lastMqaDataSent,
+      isShareStream: true,
+    });
+    mqaData.intervals[0].intervalMetadata.peerReflexiveIP =
+      this.statsResults.connectionType.local.ipAddress[0];
 
     // Adding peripheral information
-    newMqa.intervalMetadata.peripherals.push({information: _UNKNOWN_, name: MEDIA_DEVICES.SPEAKER});
-    if (this.statsResults['audio-send']) {
-      newMqa.intervalMetadata.peripherals.push({
-        information: this.statsResults['audio-send'].trackLabel || _UNKNOWN_,
-        name: MEDIA_DEVICES.MICROPHONE,
-      });
-    }
-    if (this.statsResults['video-send']) {
-      newMqa.intervalMetadata.peripherals.push({
-        information: this.statsResults['video-send'].trackLabel || _UNKNOWN_,
-        name: MEDIA_DEVICES.CAMERA,
-      });
-    }
+    mqaData.intervals[0].intervalMetadata.peripherals = [];
+    mqaData.intervals[0].intervalMetadata.peripherals.push({
+      information: _UNKNOWN_,
+      name: MEDIA_DEVICES.SPEAKER,
+    });
+    mqaData.intervals[0].intervalMetadata.peripherals.push({
+      information: this.peerConnection?.audioTransceiver?.sender?.track?.label || _UNKNOWN_,
+      name: MEDIA_DEVICES.MICROPHONE,
+    });
+    mqaData.intervals[0].intervalMetadata.peripherals.push({
+      information: this.peerConnection?.videoTransceiver?.sender?.track?.label || _UNKNOWN_,
+      name: MEDIA_DEVICES.CAMERA,
+    });
 
-    newMqa.networkType = this.statsResults.connectionType.local.networkType;
+    // @ts-ignore
+    mqaData.networkType = this.statsResults.connectionType.local.networkType;
 
     this.mqaSentCount += 1;
 
-    newMqa.intervalNumber = this.mqaSentCount;
+    mqaData.intervals[0].intervalNumber = this.mqaSentCount;
+
+    // DO Deep copy, for some reason it takes the reference all the time rather then old value set
+    this.lastMqaDataSent = cloneDeep(this.statsResults);
+
+    this.populateResults(mqaData.intervals[0]);
 
     this.resetStatsResults();
 
@@ -247,23 +323,23 @@ export class StatsAnalyzer extends EventsScope {
       },
       EVENTS.MEDIA_QUALITY,
       {
-        data: newMqa,
+        data: mqaData.intervals[0],
         // @ts-ignore
-        networkType: newMqa.networkType,
+        networkType: mqaData.networkType,
       }
     );
   }
 
   /**
-   * updated the media connection when changed
+   * updated the peerconnection when changed
    *
    * @private
-   * @memberof StatsAnalyzer
-   * @param {RoapMediaConnection} mediaConnection
+   * @memberof updatePeerconnection
+   * @param {PeerConnection} peerConnection
    * @returns {void}
    */
-  updateMediaConnection(mediaConnection: any) {
-    this.mediaConnection = mediaConnection;
+  updatePeerconnection(peerConnection: any) {
+    this.peerConnection = peerConnection;
   }
 
   /**
@@ -271,13 +347,13 @@ export class StatsAnalyzer extends EventsScope {
    *
    * @public
    * @memberof StatsAnalyzer
-   * @param {RoapMediaConnection} mediaConnection
+   * @param {PeerConnection} peerConnection
    * @returns {Promise}
    */
-  public startAnalyzer(mediaConnection: any) {
+  public startAnalyzer(peerConnection: any) {
     if (!this.statsStarted) {
       this.statsStarted = true;
-      this.mediaConnection = mediaConnection;
+      this.peerConnection = peerConnection;
 
       return this.getStatsAndParse().then(() => {
         this.statsInterval = setInterval(() => {
@@ -317,7 +393,7 @@ export class StatsAnalyzer extends EventsScope {
     if (sendOneLastMqa) {
       return this.getStatsAndParse().then(() => {
         this.sendMqaData();
-        this.mediaConnection = null;
+        this.peerConnection = null;
       });
     }
 
@@ -339,17 +415,6 @@ export class StatsAnalyzer extends EventsScope {
       return;
     }
 
-    // Generate empty stats results
-    if (!this.statsResults[type]) {
-      this.statsResults[type] = {};
-    }
-
-    if (isSender && !this.statsResults[type].send) {
-      this.statsResults[type].send = cloneDeep(emptySender);
-    } else if (!isSender && !this.statsResults[type].recv) {
-      this.statsResults[type].recv = cloneDeep(emptyReceiver);
-    }
-
     switch (getStatsResult.type) {
       case 'outbound-rtp':
         this.processOutboundRTPResult(getStatsResult, type);
@@ -359,7 +424,8 @@ export class StatsAnalyzer extends EventsScope {
         break;
       case 'remote-inbound-rtp':
       case 'remote-outbound-rtp':
-        this.compareSentAndReceived(getStatsResult, type);
+        // @ts-ignore
+        this.compareSentAndReceived(getStatsResult, type, isSender);
         break;
       case 'remotecandidate':
       case 'remote-candidate':
@@ -380,34 +446,23 @@ export class StatsAnalyzer extends EventsScope {
   /**
    * Filters the get stats results for types
    * @private
-   * @param {Array} statsItem
+   * @param {Array} getStatsResults
    * @param {String} type
    * @param {boolean} isSender
    * @returns {void}
    */
-  filterAndParseGetStatsResults(statsItem: any, type: string, isSender: boolean) {
+  private filterAndParseGetStatsResults(
+    getStatsResults: Array<any>,
+    type: string,
+    isSender: boolean
+  ) {
     const {types} = DEFAULT_GET_STATS_FILTER;
 
-    // get the successful candidate pair before parsing stats.
-    statsItem.report.forEach((report) => {
-      if (report.type === 'candidate-pair' && report.state === 'succeeded') {
-        this.successfulCandidatePair = report;
-      }
-    });
-
-    statsItem.report.forEach((result) => {
+    getStatsResults.forEach((result) => {
       if (types.includes(result.type)) {
         this.parseGetStatsResult(result, type, isSender);
       }
     });
-
-    if (this.statsResults[type]) {
-      this.statsResults[type].direction = statsItem.currentDirection;
-      this.statsResults[type].trackLabel = statsItem.localTrackLabel;
-      this.statsResults[type].csi = statsItem.csi;
-      // reset the successful candidate pair.
-      this.successfulCandidatePair = {};
-    }
   }
 
   /**
@@ -421,7 +476,7 @@ export class StatsAnalyzer extends EventsScope {
       return;
     }
 
-    if (type.includes('audio-send')) {
+    if (type === STATS.AUDIO_CORRELATE) {
       this.statsResults[type].send.audioLevel = result.audioLevel;
       this.statsResults[type].send.totalAudioEnergy = result.totalAudioEnergy;
     }
@@ -456,10 +511,6 @@ export class StatsAnalyzer extends EventsScope {
     // eslint-disable-next-line no-param-reassign
     if (currentValue === undefined) currentValue = 0;
 
-    if (!this.lastEmittedStartStopEvent[mediaType]) {
-      this.lastEmittedStartStopEvent[mediaType] = {};
-    }
-
     const lastEmittedEvent = isLocal
       ? this.lastEmittedStartStopEvent[mediaType].local
       : this.lastEmittedStartStopEvent[mediaType].remote;
@@ -468,7 +519,7 @@ export class StatsAnalyzer extends EventsScope {
 
     if (currentValue - previousValue > 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STARTED : EVENTS.REMOTE_MEDIA_STARTED;
-    } else if (currentValue === previousValue && currentValue > 0) {
+    } else if (currentValue === previousValue && currentValue >= 0) {
       newEvent = isLocal ? EVENTS.LOCAL_MEDIA_STOPPED : EVENTS.REMOTE_MEDIA_STOPPED;
     }
 
@@ -500,29 +551,21 @@ export class StatsAnalyzer extends EventsScope {
    */
   private compareLastStatsResult() {
     if (this.lastStatsResults !== null && this.meetingMediaStatus) {
-      const getCurrentStatsTotals = (keyPrefix: string, value: string): number =>
-        Object.keys(this.statsResults)
-          .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.statsResults[cur]?.recv[value] || 0), 0);
-
-      const getPreviousStatsTotals = (keyPrefix: string, value: string): number =>
-        Object.keys(this.statsResults)
-          .filter((key) => key.startsWith(keyPrefix))
-          .reduce((prev, cur) => prev + (this.lastStatsResults[cur]?.recv[value] || 0), 0);
-
-      if (this.meetingMediaStatus.expected.sendAudio && this.lastStatsResults['audio-send']) {
-        // compare audio stats sent
-        // NOTE: relies on there being only one sender.
-        const currentStats = this.statsResults['audio-send'].send;
-        const previousStats = this.lastStatsResults['audio-send'].send;
+      // compare audio stats sent
+      let mediaType = STATS.AUDIO_CORRELATE;
+      let currentStats = null;
+      let previousStats = null;
+
+      if (this.meetingMediaStatus.expected.sendAudio) {
+        currentStats = this.statsResults[mediaType].send;
+        previousStats = this.lastStatsResults[mediaType].send;
 
         if (
           currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets sent`,
-            currentStats.totalPacketsSent
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
         } else {
           if (
@@ -530,20 +573,19 @@ export class StatsAnalyzer extends EventsScope {
             currentStats.totalAudioEnergy === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No audio Energy present`,
-              currentStats.totalAudioEnergy
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Energy present`
             );
           }
 
           if (currentStats.audioLevel === 0) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> audio level is 0 for the user`
+              `StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} level is 0 for the user`
             );
           }
         }
 
         this.emitStartStopEvents(
-          'audio',
+          mediaType,
           previousStats.totalPacketsSent,
           currentStats.totalPacketsSent,
           true
@@ -552,199 +594,266 @@ export class StatsAnalyzer extends EventsScope {
 
       if (this.meetingMediaStatus.expected.receiveAudio) {
         // compare audio stats received
-        const currentPacketsReceived = getCurrentStatsTotals('audio-recv', 'totalPacketsReceived');
-        const previousPacketsReceived = getPreviousStatsTotals(
-          'audio-recv',
-          'totalPacketsReceived'
-        );
-        const currentSamplesReceived = getCurrentStatsTotals('audio-recv', 'totalSamplesReceived');
-        const previousSamplesReceived = getPreviousStatsTotals(
-          'audio-recv',
-          'totalSamplesReceived'
-        );
+        currentStats = this.statsResults[mediaType].recv;
+        previousStats = this.lastStatsResults[mediaType].recv;
 
-        if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
+        if (
+          currentStats.totalPacketsReceived === previousStats.totalPacketsReceived ||
+          currentStats.totalPacketsReceived === 0
+        ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio RTP packets received`,
-            currentPacketsReceived
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`
           );
         } else if (
-          currentSamplesReceived === previousSamplesReceived ||
-          currentSamplesReceived === 0
+          currentStats.totalSamplesReceived === previousStats.totalSamplesReceived ||
+          currentStats.totalSamplesReceived === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No audio samples received`,
-            currentSamplesReceived
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} samples received`
           );
         }
 
-        this.emitStartStopEvents('audio', previousPacketsReceived, currentPacketsReceived, false);
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.totalPacketsReceived,
+          currentStats.totalPacketsReceived,
+          false
+        );
       }
 
-      if (this.meetingMediaStatus.expected.sendVideo && this.lastStatsResults['video-send']) {
+      mediaType = STATS.VIDEO_CORRELATE;
+      if (this.meetingMediaStatus.expected.sendVideo) {
         // compare video stats sent
-        const currentStats = this.statsResults['video-send'].send;
-        const previousStats = this.lastStatsResults['video-send'].send;
+        currentStats = this.statsResults[mediaType].send;
+        previousStats = this.lastStatsResults[mediaType].send;
 
         if (
           currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets sent`,
-            currentStats.totalPacketsSent
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
-        } else {
+        } else if (this.lastEmittedStartStopEvent[mediaType].local !== EVENTS.LOCAL_MEDIA_STOPPED) {
           if (
             currentStats.framesEncoded === previousStats.framesEncoded ||
             currentStats.framesEncoded === 0
           ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_VIDEO_ENCODED;
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video Frames Encoded`,
-              currentStats.framesEncoded
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames Encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_VIDEO_ENCODED,
+              {
+                mediaType,
+              }
             );
           }
 
           if (
-            this.statsResults['video-send'].send.framesSent ===
-              this.lastStatsResults['video-send'].send.framesSent ||
-            this.statsResults['video-send'].send.framesSent === 0
+            this.statsResults.resolutions[mediaType].send.framesSent ===
+              this.lastStatsResults.resolutions[mediaType].send.framesSent ||
+            this.statsResults.resolutions[mediaType].send.framesSent === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video Frames sent`,
-              this.statsResults['video-send'].send.framesSent
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent`
             );
           }
-        }
 
-        this.emitStartStopEvents('video', previousStats.framesSent, currentStats.framesSent, true);
+          // Video is encoded but frames are not sent
+          if (
+            currentStats.framesEncoded !== previousStats.framesEncoded &&
+            (currentStats.framesSent === previousStats.framesSent || currentStats.framesSent === 0)
+          ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_FRAMES_SENT;
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent even though frames are encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_FRAMES_SENT,
+              {
+                mediaType,
+              }
+            );
+          }
+        }
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.framesSent,
+          currentStats.framesSent,
+          true
+        );
       }
 
       if (this.meetingMediaStatus.expected.receiveVideo) {
-        // compare video stats received
-        const currentPacketsReceived = getCurrentStatsTotals('video-recv', 'totalPacketsReceived');
-        const previousPacketsReceived = getPreviousStatsTotals(
-          'video-recv',
-          'totalPacketsReceived'
-        );
-        const currentFramesReceived = getCurrentStatsTotals('video-recv', 'framesReceived');
-        const previousFramesReceived = getPreviousStatsTotals('video-recv', 'framesReceived');
-        const currentFramesDecoded = getCurrentStatsTotals('video-recv', 'framesDecoded');
-        const previousFramesDecoded = getPreviousStatsTotals('video-recv', 'framesDecoded');
-        const currentFramesDropped = getCurrentStatsTotals('video-recv', 'framesDropped');
-        const previousFramesDropped = getPreviousStatsTotals('video-recv', 'framesDropped');
-
-        if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
+        // compare video stats reveived
+
+        currentStats = this.statsResults[mediaType].recv;
+        previousStats = this.lastStatsResults[mediaType].recv;
+
+        if (
+          currentStats.totalPacketsReceived === previousStats.totalPacketsReceived ||
+          currentStats.totalPacketsReceived === 0
+        ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No video RTP packets received`,
-            currentPacketsReceived
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`
           );
         } else {
-          if (currentFramesReceived === previousFramesReceived || currentFramesReceived === 0) {
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesReceived ===
+              this.lastStatsResults.resolutions[mediaType].recv.framesReceived ||
+            this.statsResults.resolutions[mediaType].recv.framesReceived === 0
+          ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video frames received`,
-              currentFramesReceived
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`
             );
           }
 
-          if (currentFramesDecoded === previousFramesDecoded || currentFramesDecoded === 0) {
+          if (
+            this.statsResults[mediaType].recv.framesDecoded ===
+              this.lastStatsResults[mediaType].recv.framesDecoded ||
+            this.statsResults.resolutions[mediaType].send.framesDecoded === 0
+          ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No video frames decoded`,
-              currentFramesDecoded
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames decoded`
             );
           }
 
-          if (currentFramesDropped - previousFramesDropped > 10) {
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesDropped -
+              this.lastStatsResults.resolutions[mediaType].recv.framesDropped >
+            10
+          ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> video frames are getting dropped`,
-              currentFramesDropped - previousFramesDropped
+              `StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`
             );
           }
         }
 
-        this.emitStartStopEvents('video', previousFramesDecoded, currentFramesDecoded, false);
+        this.emitStartStopEvents(
+          mediaType,
+          previousStats.framesDecoded,
+          currentStats.framesDecoded,
+          false
+        );
       }
 
-      if (this.meetingMediaStatus.expected.sendShare && this.lastStatsResults['video-share-send']) {
+      mediaType = STATS.SHARE_CORRELATE;
+      if (this.meetingMediaStatus.expected.sendShare) {
         // compare share stats sent
 
-        const currentStats = this.statsResults['video-share-send'].send;
-        const previousStats = this.lastStatsResults['video-share-send'].send;
+        currentStats = this.statsResults[mediaType].send;
+        previousStats = this.lastStatsResults[mediaType].send;
 
         if (
           currentStats.totalPacketsSent === previousStats.totalPacketsSent ||
           currentStats.totalPacketsSent === 0
         ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets sent`,
-            currentStats.totalPacketsSent
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets sent`
           );
-        } else {
+        } else if (this.lastEmittedStartStopEvent[mediaType].local !== EVENTS.LOCAL_MEDIA_STOPPED) {
           if (
             currentStats.framesEncoded === previousStats.framesEncoded ||
             currentStats.framesEncoded === 0
           ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_VIDEO_ENCODED;
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames getting encoded`,
-              currentStats.framesEncoded
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames getting encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_VIDEO_ENCODED,
+              {
+                mediaType,
+              }
             );
           }
 
           if (
-            this.statsResults['video-share-send'].send.framesSent ===
-              this.lastStatsResults['video-share-send'].send.framesSent ||
-            this.statsResults['video-share-send'].send.framesSent === 0
+            this.statsResults.resolutions[mediaType].send.framesSent ===
+              this.lastStatsResults.resolutions[mediaType].send.framesSent ||
+            this.statsResults.resolutions[mediaType].send.framesSent === 0
           ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames sent`,
-              this.statsResults['video-share-send'].send.framesSent
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames sent`
+            );
+          }
+
+          // Share video is encoded but frames are not sent
+          if (
+            currentStats.framesEncoded !== previousStats.framesEncoded &&
+            (currentStats.framesSent === previousStats.framesSent || currentStats.framesSent === 0)
+          ) {
+            this.lastEmittedStartStopEvent[mediaType].local = EVENTS.NO_FRAMES_SENT;
+            LoggerProxy.logger.info(
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} Frames sent even though frames are being encoded`
+            );
+            this.emit(
+              {
+                file: 'statsAnalyzer',
+                function: 'compareLastStatsResult',
+              },
+              EVENTS.NO_FRAMES_SENT,
+              {
+                mediaType,
+              }
             );
           }
         }
-      }
 
-      if (this.meetingMediaStatus.expected.sendShare) {
         // TODO:need to check receive share value
-        // compare share stats received
-        const currentPacketsReceived = getCurrentStatsTotals(
-          'video-share-recv',
-          'totalPacketsReceived'
-        );
-        const previousPacketsReceived = getPreviousStatsTotals(
-          'video-share-recv',
-          'totalPacketsReceived'
-        );
-        const currentFramesReceived = getCurrentStatsTotals('video-share-recv', 'framesReceived');
-        const previousFramesReceived = getPreviousStatsTotals('video-share-recv', 'framesReceived');
-        const currentFramesDecoded = getCurrentStatsTotals('video-share-recv', 'framesDecoded');
-        const previousFramesDecoded = getPreviousStatsTotals('video-share-recv', 'framesDecoded');
-        const currentFramesDropped = getCurrentStatsTotals('video-share-recv', 'framesDropped');
-        const previousFramesDropped = getPreviousStatsTotals('video-share-recv', 'framesDropped');
-
-        if (currentPacketsReceived === previousPacketsReceived || currentPacketsReceived === 0) {
+        // compare share stats reveived
+        currentStats = this.statsResults[mediaType].recv;
+        previousStats = this.lastStatsResults[mediaType].recv;
+
+        if (
+          currentStats.totalPacketsReceived === previousStats.totalPacketsReceived ||
+          currentStats.totalPacketsSent === 0
+        ) {
           LoggerProxy.logger.info(
-            `StatsAnalyzer:index#compareLastStatsResult --> No share RTP packets received`,
-            currentPacketsReceived
+            `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} RTP packets received`
           );
         } else {
-          if (currentFramesReceived === previousFramesReceived || currentFramesReceived === 0) {
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesReceived ===
+              this.lastStatsResults.resolutions[mediaType].recv.framesReceived ||
+            this.statsResults.resolutions[mediaType].recv.framesReceived === 0
+          ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames received`,
-              currentFramesReceived
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames received`
             );
           }
 
-          if (currentFramesDecoded === previousFramesDecoded || currentFramesDecoded === 0) {
+          if (
+            this.statsResults[mediaType].recv.framesDecoded ===
+              this.lastStatsResults[mediaType].recv.framesDecoded ||
+            this.statsResults.resolutions[mediaType].send.framesDecoded === 0
+          ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> No share frames decoded`,
-              currentFramesDecoded
+              `StatsAnalyzer:index#compareLastStatsResult --> No ${mediaType} frames decoded`
             );
           }
 
-          if (currentFramesDropped - previousFramesDropped > 10) {
+          if (
+            this.statsResults.resolutions[mediaType].recv.framesDropped -
+              this.lastStatsResults.resolutions[mediaType].recv.framesDropped >
+            10
+          ) {
             LoggerProxy.logger.info(
-              `StatsAnalyzer:index#compareLastStatsResult --> share frames are getting dropped`,
-              currentFramesDropped - previousFramesDropped
+              `StatsAnalyzer:index#compareLastStatsResult --> ${mediaType} frames are getting dropped`
             );
           }
         }
@@ -764,16 +873,13 @@ export class StatsAnalyzer extends EventsScope {
    * @returns {Promise}
    */
   private getStatsAndParse() {
-    if (!this.mediaConnection) {
+    if (!this.peerConnection) {
       return Promise.resolve();
     }
 
-    if (
-      this.mediaConnection &&
-      this.mediaConnection.getConnectionState() === ConnectionState.Failed
-    ) {
+    if (this.peerConnection && this.peerConnection.connectionState === CONNECTION_STATE.FAILED) {
       LoggerProxy.logger.trace(
-        'StatsAnalyzer:index#getStatsAndParse --> media connection is in failed state'
+        'StatsAnalyzer:index#getStatsAndParse --> PeerConnection is in failed state'
       );
 
       return Promise.resolve();
@@ -781,49 +887,43 @@ export class StatsAnalyzer extends EventsScope {
 
     LoggerProxy.logger.trace('StatsAnalyzer:index#getStatsAndParse --> Collecting Stats');
 
-    return this.mediaConnection.getTransceiverStats().then((transceiverStats) => {
-      transceiverStats.video.receivers.forEach((receiver, i) =>
-        this.filterAndParseGetStatsResults(receiver, `video-recv-${i}`, false)
-      );
-      transceiverStats.audio.receivers.forEach((receiver, i) =>
-        this.filterAndParseGetStatsResults(receiver, `audio-recv-${i}`, false)
-      );
-      transceiverStats.screenShareVideo.receivers.forEach((receiver, i) =>
-        this.filterAndParseGetStatsResults(receiver, `video-share-recv-${i}`, false)
-      );
-      transceiverStats.screenShareAudio.receivers.forEach((receiver, i) =>
-        this.filterAndParseGetStatsResults(receiver, `audio-share-recv-${i}`, false)
-      );
-
-      transceiverStats.video.senders.forEach((sender, i) => {
-        if (i > 0) {
-          throw new Error('Stats Analyzer does not support multiple senders.');
-        }
-        this.filterAndParseGetStatsResults(sender, 'video-send', true);
-      });
-      transceiverStats.audio.senders.forEach((sender, i) => {
-        if (i > 0) {
-          throw new Error('Stats Analyzer does not support multiple senders.');
-        }
-        this.filterAndParseGetStatsResults(sender, 'audio-send', true);
-      });
-      transceiverStats.screenShareVideo.senders.forEach((sender, i) => {
-        if (i > 0) {
-          throw new Error('Stats Analyzer does not support multiple senders.');
-        }
-        this.filterAndParseGetStatsResults(sender, 'video-share-send', true);
-      });
-      transceiverStats.screenShareAudio.senders.forEach((sender, i) => {
-        if (i > 0) {
-          throw new Error('Stats Analyzer does not support multiple senders.');
-        }
-        this.filterAndParseGetStatsResults(sender, 'audio-share-send', true);
-      });
-
+    return Promise.all([
+      this.peerConnection.videoTransceiver.sender.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, true);
+      }),
+
+      this.peerConnection.videoTransceiver.receiver.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.VIDEO_CORRELATE, false);
+      }),
+
+      this.peerConnection.audioTransceiver.sender.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, true);
+      }),
+
+      this.peerConnection.audioTransceiver.receiver.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.AUDIO_CORRELATE, false);
+      }),
+
+      // TODO: add checks for screen share
+      this.peerConnection.shareTransceiver.sender.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, true);
+      }),
+
+      this.peerConnection.shareTransceiver.receiver.getStats().then((res) => {
+        this.filterAndParseGetStatsResults(res, STATS.SHARE_CORRELATE, false);
+      }),
+    ]).then(() => {
+      this.statsResults[STATS.AUDIO_CORRELATE].direction =
+        this.peerConnection.audioTransceiver.currentDirection;
+      this.statsResults[STATS.VIDEO_CORRELATE].direction =
+        this.peerConnection.videoTransceiver.currentDirection;
+      this.statsResults[STATS.SHARE_CORRELATE].direction =
+        this.peerConnection.shareTransceiver.currentDirection;
+
+      // Process Stats results every 5 seconds
       this.compareLastStatsResult();
 
       // Save the last results to compare with the current
-      // DO Deep copy, for some reason it takes the reference all the time rather then old value set
       this.lastStatsResults = JSON.parse(JSON.stringify(this.statsResults));
 
       LoggerProxy.logger.trace(
@@ -836,27 +936,51 @@ export class StatsAnalyzer extends EventsScope {
    * Processes OutboundRTP stats result and stores
    * @private
    * @param {*} result
-   * @param {*} mediaType
+   * @param {*} type
    * @returns {void}
    */
-  private processOutboundRTPResult(result: any, mediaType: any) {
+  private processOutboundRTPResult(result: any, type: any) {
+    const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.SEND_DIRECTION;
 
+    this.processTrackResult(result, type, sendrecvType);
     if (result.bytesSent) {
-      const kilobytes = 0;
+      let kilobytes = 0;
 
-      if (result.frameWidth && result.frameHeight) {
-        this.statsResults[mediaType][sendrecvType].width = result.frameWidth;
-        this.statsResults[mediaType][sendrecvType].height = result.frameHeight;
-        this.statsResults[mediaType][sendrecvType].framesSent = result.framesSent;
-        this.statsResults[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
+      if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesSent) {
+        this.statsResults.internal[mediaType][sendrecvType].prevBytesSent = result.bytesSent;
+      }
+      if (!this.statsResults.internal[mediaType][sendrecvType].framesEncoded) {
+        this.statsResults.internal[mediaType][sendrecvType].framesEncoded = result.framesEncoded;
+      }
+      if (!this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded) {
+        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded =
+          result.keyFramesEncoded;
       }
 
+      const bytes =
+        result.bytesSent - this.statsResults.internal[mediaType][sendrecvType].prevBytesSent;
+
+      this.statsResults.internal[mediaType][sendrecvType].prevBytesSent = result.bytesSent;
+
+      kilobytes = bytes / 1024;
+
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
+      this.statsResults[mediaType].bytesSent = kilobytes;
+      this.statsResults[mediaType][sendrecvType].framesEncoded =
+        result.framesEncoded - this.statsResults.internal[mediaType][sendrecvType].framesEncoded;
+      this.statsResults[mediaType][sendrecvType].keyFramesEncoded =
+        result.keyFramesEncoded -
+        this.statsResults.internal[mediaType][sendrecvType].keyFramesEncoded;
+      this.statsResults.internal[mediaType].outboundRtpId = result.id;
+
+      if (!this.statsResults.internal[mediaType][sendrecvType].packetsSent) {
+        this.statsResults.internal[mediaType][sendrecvType].packetsSent = result.packetsSent;
+      }
 
-      this.statsResults[mediaType][sendrecvType].framesEncoded = result.framesEncoded;
-      this.statsResults[mediaType][sendrecvType].keyFramesEncoded = result.keyFramesEncoded;
-      this.statsResults[mediaType][sendrecvType].packetsSent = result.packetsSent;
+      this.statsResults[mediaType][sendrecvType].packetsSent =
+        result.packetsSent - this.statsResults.internal[mediaType][sendrecvType].packetsSent;
+      this.statsResults.internal[mediaType][sendrecvType].packetsSent = result.packetsSent;
 
       // Data saved to send MQA metrics
 
@@ -886,58 +1010,81 @@ export class StatsAnalyzer extends EventsScope {
    * Processes InboundRTP stats result and stores
    * @private
    * @param {*} result
-   * @param {*} mediaType
+   * @param {*} type
    * @returns {void}
    */
-  private processInboundRTPResult(result: any, mediaType: any) {
+  private processInboundRTPResult(result: any, type: any) {
+    const mediaType = type || STATS.AUDIO_CORRELATE;
     const sendrecvType = STATS.RECEIVE_DIRECTION;
 
+    this.processTrackResult(result, type, sendrecvType);
     if (result.bytesReceived) {
       let kilobytes = 0;
-      const receiveSlot = this.receiveSlotCallback(result.ssrc);
-      const idAndCsi = receiveSlot
-        ? `id: "${receiveSlot.id || ''}"${receiveSlot.csi ? ` and csi: ${receiveSlot.csi}` : ''}`
-        : '';
-
-      if (result.frameWidth && result.frameHeight) {
-        this.statsResults[mediaType][sendrecvType].width = result.frameWidth;
-        this.statsResults[mediaType][sendrecvType].height = result.frameHeight;
-        this.statsResults[mediaType][sendrecvType].framesReceived = result.framesReceived;
+
+      if (!this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived) {
+        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived =
+          result.bytesReceived;
+      }
+
+      if (!this.statsResults.internal[mediaType][sendrecvType].pliCount) {
+        this.statsResults.internal[mediaType][sendrecvType].pliCount = result.pliCount;
+      }
+
+      if (!this.statsResults.internal[mediaType][sendrecvType].packetsLost) {
+        this.statsResults.internal[mediaType][sendrecvType].packetsLost = result.packetsLost;
+      }
+
+      if (!this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived) {
+        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived =
+          result.packetsReceived;
+      }
+
+      if (!this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp) {
+        this.statsResults.internal[mediaType][sendrecvType].lastPacketReceivedTimestamp =
+          result.lastPacketReceivedTimestamp;
       }
 
       const bytes =
-        result.bytesReceived - this.statsResults[mediaType][sendrecvType].totalBytesReceived;
+        result.bytesReceived -
+        this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived;
+
+      this.statsResults.internal[mediaType][sendrecvType].prevBytesReceived = result.bytesReceived;
 
       kilobytes = bytes / 1024;
       this.statsResults[mediaType][sendrecvType].availableBandwidth = kilobytes.toFixed(1);
-
-      let currentPacketsLost =
-        result.packetsLost - this.statsResults[mediaType][sendrecvType].totalPacketsLost;
-      if (currentPacketsLost < 0) {
-        currentPacketsLost = 0;
+      this.statsResults[mediaType].bytesReceived = kilobytes.toFixed(1);
+
+      this.statsResults[mediaType][sendrecvType].pliCount =
+        result.pliCount - this.statsResults.internal[mediaType][sendrecvType].pliCount;
+      this.statsResults[mediaType][sendrecvType].currentPacketsLost =
+        result.packetsLost - this.statsResults.internal[mediaType][sendrecvType].packetsLost;
+      if (this.statsResults[mediaType][sendrecvType].currentPacketsLost < 0) {
+        this.statsResults[mediaType][sendrecvType].currentPacketsLost = 0;
       }
 
-      const currentPacketsReceived =
-        result.packetsReceived - this.statsResults[mediaType][sendrecvType].totalPacketsReceived;
-      this.statsResults[mediaType][sendrecvType].totalPacketsReceived = result.packetsReceived;
+      this.statsResults[mediaType][sendrecvType].packetsReceived =
+        result.packetsReceived -
+        this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived;
+      this.statsResults.internal[mediaType][sendrecvType].totalPacketsReceived =
+        result.packetsReceived;
 
-      if (currentPacketsReceived === 0) {
-        if (receiveSlot) {
-          LoggerProxy.logger.info(
-            `StatsAnalyzer:index#processInboundRTPResult --> No packets received for receive slot ${idAndCsi}`,
-            currentPacketsReceived
-          );
-        }
+      if (this.statsResults[mediaType][sendrecvType].packetsReceived === 0) {
+        LoggerProxy.logger.info(
+          `StatsAnalyzer:index#processInboundRTPResult --> No packets received for ${mediaType} `,
+          this.statsResults[mediaType][sendrecvType].packetsReceived
+        );
       }
 
       //  Check the over all packet Lost ratio
       this.statsResults[mediaType][sendrecvType].currentPacketLossRatio =
-        currentPacketsLost > 0
-          ? currentPacketsLost / (currentPacketsReceived + currentPacketsLost)
+        this.statsResults[mediaType][sendrecvType].currentPacketsLost > 0
+          ? this.statsResults[mediaType][sendrecvType].currentPacketsLost /
+            (this.statsResults[mediaType][sendrecvType].packetsReceived +
+              this.statsResults[mediaType][sendrecvType].currentPacketsLost)
           : 0;
       if (this.statsResults[mediaType][sendrecvType].currentPacketLossRatio > 3) {
         LoggerProxy.logger.info(
-          `StatsAnalyzer:index#processInboundRTPResult --> Packets getting lost from the receiver with slot ${idAndCsi}`,
+          'StatsAnalyzer:index#processInboundRTPResult --> Packets getting lost from the receiver ',
           this.statsResults[mediaType][sendrecvType].currentPacketLossRatio
         );
       }
@@ -997,48 +1144,126 @@ export class StatsAnalyzer extends EventsScope {
     if (!result || !result.id) {
       return;
     }
+    const RemoteCandidateType = {};
+    const RemoteTransport = {};
+    const RemoteIpAddress = {};
+    const RemoteNetworkType = {};
 
-    // We only care about the successful local candidate
-    if (this.successfulCandidatePair?.localCandidateId !== result.id) {
-      return;
+    if (!result.id) return;
+
+    const sendRecvType = isSender ? STATS.SEND_DIRECTION : STATS.RECEIVE_DIRECTION;
+    const ipType = isRemote ? STATS.REMOTE : STATS.LOCAL;
+
+    if (!RemoteCandidateType[result.id]) {
+      RemoteCandidateType[result.id] = [];
     }
 
-    let transport;
-    if (result.relayProtocol) {
-      transport = result.relayProtocol.toUpperCase();
-    } else if (result.protocol) {
-      transport = result.protocol.toUpperCase();
+    if (!RemoteTransport[result.id]) {
+      RemoteTransport[result.id] = [];
     }
 
-    const sendRecvType = isSender ? STATS.SEND_DIRECTION : STATS.RECEIVE_DIRECTION;
-    const ipType = isRemote ? STATS.REMOTE : STATS.LOCAL;
+    if (!RemoteIpAddress[result.id]) {
+      RemoteIpAddress[result.id] = [];
+    }
+    if (!RemoteNetworkType[result.id]) {
+      RemoteNetworkType[result.id] = [];
+    }
+
+    if (
+      result.candidateType &&
+      RemoteCandidateType[result.id].indexOf(result.candidateType) === -1
+    ) {
+      RemoteCandidateType[result.id].push(result.candidateType);
+    }
 
-    if (!this.statsResults.candidates) {
-      this.statsResults.candidates = {};
+    if (result.protocol && RemoteTransport[result.id].indexOf(result.protocol) === -1) {
+      RemoteTransport[result.id].push(result.protocol.toUpperCase());
     }
 
-    this.statsResults.candidates[result.id] = {
-      candidateType: result.candidateType,
-      ipAddress: result.ip, // TODO: add ports
+    if (
+      result.ip &&
+      RemoteIpAddress[result.id].indexOf(`${result.ip}:${result.portNumber}`) === -1
+    ) {
+      RemoteIpAddress[result.id].push(`${result.ip}`); // TODO: Add ports
+    }
+
+    if (result.networkType && RemoteNetworkType[result.id].indexOf(result.networkType) === -1) {
+      RemoteNetworkType[result.id].push(result.networkType);
+    }
+
+    this.statsResults.internal.candidates[result.id] = {
+      candidateType: RemoteCandidateType[result.id],
+      ipAddress: RemoteIpAddress[result.id],
       portNumber: result.port,
-      networkType: result.networkType,
+      networkType: RemoteNetworkType[result.id],
       priority: result.priority,
-      transport,
+      transport: RemoteTransport[result.id],
       timestamp: result.time,
       id: result.id,
       type: result.type,
     };
 
-    this.statsResults.connectionType[ipType].candidateType = result.candidateType;
-    this.statsResults.connectionType[ipType].ipAddress = result.ipAddress;
+    this.statsResults.connectionType[ipType].candidateType = RemoteCandidateType[result.id];
+    this.statsResults.connectionType[ipType].ipAddress = RemoteIpAddress[result.id];
 
     this.statsResults.connectionType[ipType].networkType =
-      result.networkType === NETWORK_TYPE.VPN ? NETWORK_TYPE.UNKNOWN : result.networkType;
-    this.statsResults.connectionType[ipType].transport = transport;
+      RemoteNetworkType[result.id][0] === NETWORK_TYPE.VPN
+        ? NETWORK_TYPE.UNKNOWN
+        : RemoteNetworkType[result.id][0];
+    this.statsResults.connectionType[ipType].transport = RemoteTransport[result.id];
 
     this.statsResults[type][sendRecvType].totalRoundTripTime = result.totalRoundTripTime;
   };
 
+  /**
+   * Process Track results
+   *
+   * @private
+   * @param {*} result
+   * @param {*} mediaType
+   * @param {*} sendrecvType
+   * @returns {void}
+   * @memberof StatsAnalyzer
+   */
+  private processTrackResult(result: any, mediaType: any, sendrecvType: any) {
+    if (!result || mediaType === STATS.AUDIO_CORRELATE) {
+      return;
+    }
+    if (result.type !== 'inbound-rtp' && result.type !== 'outbound-rtp') {
+      return;
+    }
+    if (result.frameWidth && result.frameHeight) {
+      this.statsResults.resolutions[mediaType][sendrecvType].width = result.frameWidth;
+      this.statsResults.resolutions[mediaType][sendrecvType].height = result.frameHeight;
+    }
+
+    if (sendrecvType === STATS.RECEIVE_DIRECTION) {
+      this.statsResults.resolutions[mediaType][sendrecvType].framesReceived = result.framesReceived;
+      this.statsResults.resolutions[mediaType][sendrecvType].framesDecoded = result.framesDecoded;
+      this.statsResults.resolutions[mediaType][sendrecvType].framesDropped = result.framesDropped;
+    } else if (sendrecvType === STATS.SEND_DIRECTION) {
+      this.statsResults.resolutions[mediaType][sendrecvType].framesSent = result.framesSent;
+      this.statsResults.resolutions[mediaType][sendrecvType].hugeFramesSent = result.hugeFramesSent;
+    }
+
+    if (result.trackIdentifier && mediaType !== STATS.AUDIO_CORRELATE) {
+      this.statsResults.resolutions[mediaType][sendrecvType].trackIdentifier =
+        result.trackIdentifier;
+
+      const jitterBufferDelay = result && result.jitterBufferDelay;
+      const jitterBufferEmittedCount = result && result.jitterBufferEmittedCount;
+
+      this.statsResults.resolutions[mediaType][sendrecvType].avgJitterDelay =
+        jitterBufferEmittedCount && +jitterBufferDelay / +jitterBufferEmittedCount;
+
+      // Used to calculate the jitter
+      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferDelay =
+        result.jitterBufferDelay;
+      this.statsResults.resolutions[mediaType][sendrecvType].jitterBufferEmittedCount =
+        result.jitterBufferEmittedCount;
+    }
+  }
+
   /**
    *
    * @private
@@ -1047,17 +1272,21 @@ export class StatsAnalyzer extends EventsScope {
    * @returns {void}
    * @memberof StatsAnalyzer
    */
-  compareSentAndReceived(result, type) {
-    // Don't compare on transceivers without a sender.
-    if (!type || !this.statsResults[type].send) {
+  private compareSentAndReceived(result: any, type: any) {
+    if (!type) {
       return;
     }
 
     const mediaType = type;
 
+    if (!this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver) {
+      this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;
+    }
+
     const currentPacketLoss =
-      result.packetsLost - this.statsResults[mediaType].send.totalPacketsLostOnReceiver;
+      result.packetsLost - this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver;
 
+    this.statsResults.internal[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;
     this.statsResults[mediaType].send.packetsLostOnReceiver = currentPacketLoss;
     this.statsResults[mediaType].send.totalPacketsLostOnReceiver = result.packetsLost;