Take round trip time into account when calculating the quality

A high round trip time means that there is a delay in the connection,
which is in itself bad (specially in a conversation instead of in a
"monologue").

Besides that a delay in the connection can also cause that some packets,
even if they are not lost, are discarded anyway to try to keep the
playing rate in real time.

The round trip time is only available for sent data, but not received
data.

Signed-off-by: Daniel Calviño Sánchez <[email protected]>

src/utils/webrtc/analyzers/PeerConnectionAnalyzer.js

@@ -78,6 +78,13 @@ function PeerConnectionAnalyzer() {
 		'audio': new AverageStatValue(5, STAT_VALUE_TYPE.RELATIVE),
 		'video': new AverageStatValue(5, STAT_VALUE_TYPE.RELATIVE),
 	}
+	// Latest values have a higher weight than the default one to better detect
+	// sudden changes in the round trip time, which can lead to discarded (but
+	// not lost) packets.
+	this._roundTripTime = {
+		'audio': new AverageStatValue(5, STAT_VALUE_TYPE.RELATIVE, 5),
+		'video': new AverageStatValue(5, STAT_VALUE_TYPE.RELATIVE, 5),
+	}
 	// Only the last relative value is used, but as it is a cumulative value the
 	// previous one is needed as a base to calculate the last one.
 	this._timestamps = {
@@ -218,6 +225,11 @@ PeerConnectionAnalyzer.prototype = {
 			'video': -1,
 		}
 
+		const roundTripTime = {
+			'audio': -1,
+			'video': -1,
+		}
+
 		for (const stat of stats.values()) {
 			if (stat.type === 'outbound-rtp') {
 				if ('packetsSent' in stat && 'kind' in stat) {
@@ -238,6 +250,9 @@ PeerConnectionAnalyzer.prototype = {
 				if ('packetsLost' in stat && 'kind' in stat) {
 					packetsLost[stat.kind] = stat.packetsLost
 				}
+				if ('roundTripTime' in stat && 'kind' in stat) {
+					roundTripTime[stat.kind] = stat.roundTripTime
+				}
 			}
 		}
 
@@ -289,6 +304,9 @@ PeerConnectionAnalyzer.prototype = {
 				const packetsPerSecond = this._packets[kind].getLastRelativeValue() / elapsedSeconds
 				this._packetsPerSecond[kind].add(packetsPerSecond)
 			}
+			if (roundTripTime[kind] >= 0) {
+				this._roundTripTime[kind].add(roundTripTime[kind])
+			}
 		}
 	},
 
@@ -376,14 +394,14 @@ PeerConnectionAnalyzer.prototype = {
 	},
 
 	_calculateConnectionQualityAudio: function() {
-		return this._calculateConnectionQuality(this._packetsLostRatio['audio'], this._packetsPerSecond['audio'])
+		return this._calculateConnectionQuality(this._packetsLostRatio['audio'], this._packetsPerSecond['audio'], this._roundTripTime['audio'])
 	},
 
 	_calculateConnectionQualityVideo: function() {
-		return this._calculateConnectionQuality(this._packetsLostRatio['video'], this._packetsPerSecond['video'])
+		return this._calculateConnectionQuality(this._packetsLostRatio['video'], this._packetsPerSecond['video'], this._roundTripTime['video'])
 	},
 
-	_calculateConnectionQuality: function(packetsLostRatio, packetsPerSecond) {
+	_calculateConnectionQuality: function(packetsLostRatio, packetsPerSecond, roundTripTime) {
 		if (!packetsLostRatio.hasEnoughData() || !packetsPerSecond.hasEnoughData()) {
 			return CONNECTION_QUALITY.UNKNOWN
 		}
@@ -393,6 +411,14 @@ PeerConnectionAnalyzer.prototype = {
 			return CONNECTION_QUALITY.NO_TRANSMITTED_DATA
 		}
 
+		// A high round trip time means that the delay is high, but it can also
+		// imply that some packets, even if they are not lost, are anyway
+		// discarded to try to keep the playing rate in real time.
+		// Round trip time is measured in seconds.
+		if (roundTripTime.hasEnoughData() && roundTripTime.getWeightedAverage() > 1.5) {
+			return CONNECTION_QUALITY.VERY_BAD
+		}
+
 		// In some cases there may be packets being transmitted without any lost
 		// packet, but if the number of packets is too low the connection is
 		// most likely in bad shape anyway.