@livedigital/client 2.21.0 → 2.22.0

package/dist/types/engine.d.ts

@@ -7,11 +7,13 @@ import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult } from '../engine/wid/types';
+import { IssueDetectorResult, NetworkScores } from '../engine/wid/types';
 import { LogLevel } from './common';
 export declare type IssuesHandler = (issues: IssueDetectorResult) => void;
+export declare type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;
 export interface CreateIssueDetectorParams {
     onIssues?: IssuesHandler;
+    onNetworkScoresUpdated?: NetworkScoresUpdatedHandler;
     ignoreSSRCList?: number[];
 }
 export interface CreateMediaParams {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@livedigital/client",
   "author": "vlprojects",
   "license": "MIT",
-  "version": "2.21.0",
+  "version": "2.22.0",
   "private": false,
   "bugs": {
     "url": "https://github.com/vlprojects/livedigital-sdk/issues"

package/src/engine/DefaultEngineDependenciesFactory.ts

@@ -50,6 +50,7 @@ class DefaultEngineDependenciesFactory implements EngineDependenciesFactory {
   createIssueDetector(params: CreateIssueDetectorParams): WebRTCIssueDetector {
     return new WebRTCIssueDetector({
       onIssues: params.onIssues,
+      onNetworkScoresUpdated: params.onNetworkScoresUpdated,
       ignoreSSRCList: params.ignoreSSRCList,
     });
   }

package/src/engine/index.ts

@@ -28,7 +28,7 @@ import VideoTrack from './media/tracks/VideoTrack';
 import PeerTrack from './media/tracks/PeerTrack';
 import WebRTCIssueDetector from './wid/WebRTCIssueDetector';
 import { retryAsync } from '../helpers/retry';
-import { EngineDependenciesFactory, IssuesHandler } from '../types/engine';
+import { EngineDependenciesFactory, IssuesHandler, NetworkScoresUpdatedHandler } from '../types/engine';
 import { LogLevels } from '../constants/common';
 import { LoadBalancerApiClientParams } from './network/LoadBalancerClient';
 import validateAppData from '../helpers/appDataValidator';
@@ -42,6 +42,7 @@ type EngineParams = {
   logLevel?: LogLevel;
   onLogMessage?: LogMessageHandler;
   onIssues?: IssuesHandler;
+  onNetworkScoresUpdated?: NetworkScoresUpdatedHandler;
 };
 
 class Engine {
@@ -108,6 +109,7 @@ class Engine {
 
     this.webRtcIssueDetector = dependenciesFactory.createIssueDetector({
       onIssues: params.onIssues,
+      onNetworkScoresUpdated: params.onNetworkScoresUpdated,
       ignoreSSRCList: [1234], // mediasoup-client probator
     });
 

package/src/engine/wid/WebRTCIssueDetector.ts

@@ -1,4 +1,4 @@
-import { WebRTCStats } from '@peermetrics/webrtc-stats';
+import { WebRTCStats, WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
 import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
 import {
   WebRTCIssueDetectorConstructorParams,
@@ -16,6 +16,7 @@ import OutboundNetworkIssueDetector from './detectors/OutboundNetworkIssueDetect
 import NetworkMediaSyncIssueDetector from './detectors/NetworkMediaSyncIssueDetector';
 import AvailableOutgoingBitrateIssueDetector from './detectors/AvailableOutgoingBitrateIssueDetector';
 import VideoCodecMismatchDetector from './detectors/VideoCodecMismatchDetector';
+import NetworkScoresCalculator from './lib/NetworkScoresCalculator';
 
 class WebRTCIssueDetector {
   private readonly webrtcStats: WebRTCStats;
@@ -26,6 +27,8 @@ class WebRTCIssueDetector {
 
   private readonly detectors: IssueDetector[] = [];
 
+  private readonly networkScoresCalculator: NetworkScoresCalculator;
+
   readonly eventEmitter = new WebRTCIssueEmitter();
 
   #running = false;
@@ -35,6 +38,10 @@ class WebRTCIssueDetector {
       this.eventEmitter.on(EventType.Issue, params.onIssues);
     }
 
+    if (params.onNetworkScoresUpdated) {
+      this.eventEmitter.on(EventType.NetworkScoresUpdated, params.onNetworkScoresUpdated);
+    }
+
     // Move instantiation from the constructor
     this.webrtcStats = new WebRTCStats({
       getStatsInterval: this.getStatsInterval,
@@ -55,11 +62,15 @@ class WebRTCIssueDetector {
       new VideoCodecMismatchDetector(),
     ];
 
+    this.networkScoresCalculator = new NetworkScoresCalculator();
+
     this.webrtcStats.on('stats', (event) => {
       this.detectIssues({
         data: event.data,
         ignoreSSRCList: params.ignoreSSRCList,
       });
+
+      this.calculateNetworkScores(event.data);
     });
   }
 
@@ -115,6 +126,11 @@ class WebRTCIssueDetector {
     }
   }
 
+  private calculateNetworkScores(data: WebRTCStatsEventData): void {
+    const networkScores = this.networkScoresCalculator.calculate(data);
+    this.eventEmitter.emit(EventType.NetworkScoresUpdated, networkScores);
+  }
+
   private wrapRTCPeerConnection(): void {
     if (!window.RTCPeerConnection) {
       return;

package/src/engine/wid/WebRTCIssueEmitter.ts

@@ -1,9 +1,16 @@
 import { EventEmitter } from 'events';
-import { EventType, EventPayload, IssueDetectorResult } from './types';
+import {
+  EventType,
+  EventPayload,
+  IssueDetectorResult,
+  NetworkScores,
+} from './types';
 
 export declare interface WebRTCIssueEmitter {
-  on(event: EventType, listener: (issues: IssueDetectorResult) => void): this;
-  emit(event: EventType, payload: EventPayload): boolean;
+  on(event: EventType.Issue, listener: (payload: IssueDetectorResult) => void): this;
+  on(event: EventType.NetworkScoresUpdated, listener: (payload: NetworkScores) => void): this;
+  emit(event: EventType.Issue, payload: EventPayload): boolean;
+  emit(event: EventType.NetworkScoresUpdated, payload: NetworkScores): boolean;
 }
 
 export class WebRTCIssueEmitter extends EventEmitter {}

package/src/engine/wid/detectors/InboundNetworkIssueDetector.ts

@@ -65,36 +65,17 @@ class InboundNetworkIssueDetector implements IssueDetector {
       ? Math.round((deltaPacketLost * 100) / (deltaPacketReceived + deltaPacketLost))
       : 0;
 
-    const effectiveLatency = rtt + (avgJitter * 2) + 10;
-    let rFactor = effectiveLatency < 160
-      ? 93.2 - (effectiveLatency / 40)
-      : 93.2 - (effectiveLatency / 120) - 10;
-    rFactor -= (packetsLoss * 2.5);
-    const mos = 1 + (0.035) * rFactor + (0.000007) * rFactor * (rFactor - 60) * (100 - rFactor);
-
     const isHighPacketsLoss = packetsLoss > 5;
     const isHighJitter = avgJitter >= 200;
     const isHighRTT = rtt >= 250;
     const isHighJitterBufferDelay = avgJitterBufferDelay > 500;
-    const isPoorConnectionQuality = mos < 3.1;
-
     const isNetworkIssue = (!isHighPacketsLoss && isHighJitter) || isHighJitter || isHighPacketsLoss;
     const isServerIssue = isHighRTT && !isHighJitter && !isHighPacketsLoss;
     const isNetworkMediaLatencyIssue = isHighPacketsLoss && isHighJitter;
     const isNetworkMediaSyncIssue = isHighJitter && isHighJitterBufferDelay;
 
     const debug = `packetLoss: ${packetsLoss}%, jitter: ${avgJitter}, rtt: ${rtt},`
-      + ` jitterBuffer: ${avgJitterBufferDelay}ms, MOS: ${mos}`;
-
-    if (isPoorConnectionQuality) {
-      issues.push({
-        type: IssueType.Network,
-        reason: IssueReason.LowInboundMOS,
-        iceCandidate: data.connection.local.id,
-        debug,
-        data: mos,
-      });
-    }
+      + ` jitterBuffer: ${avgJitterBufferDelay}ms`;
 
     if (isNetworkIssue) {
       issues.push({

package/src/engine/wid/detectors/OutboundNetworkIssueDetector.ts

@@ -65,20 +65,11 @@ class OutboundNetworkIssueDetector implements IssueDetector {
       ? Math.round((deltaPacketLost * 100) / (deltaPacketSent + deltaPacketLost))
       : 0;
 
-    const effectiveLatency = rtt + (avgJitter * 2) + 10;
-    let rFactor = effectiveLatency < 160
-      ? 93.2 - (effectiveLatency / 40)
-      : 93.2 - (effectiveLatency / 120) - 10;
-    rFactor -= (packetsLoss * 2.5);
-    const mos = 1 + (0.035) * rFactor + (0.000007) * rFactor * (rFactor - 60) * (100 - rFactor);
-
     const isHighPacketsLoss = packetsLoss > 5;
     const isHighJitter = avgJitter >= 200;
-    const isPoorConnectionQuality = mos < 3.5;
     const isNetworkMediaLatencyIssue = isHighPacketsLoss && isHighJitter;
     const isNetworkIssue = (!isHighPacketsLoss && isHighJitter) || isHighJitter || isHighPacketsLoss;
-    const debug = `packetLoss: ${packetsLoss}%, jitter: ${avgJitter}, rtt: ${rtt},`
-      + ` MOS: ${mos}`;
+    const debug = `packetLoss: ${packetsLoss}%, jitter: ${avgJitter}, rtt: ${rtt}`;
 
     if (isNetworkMediaLatencyIssue) {
       issues.push({
@@ -98,16 +89,6 @@ class OutboundNetworkIssueDetector implements IssueDetector {
       });
     }
 
-    if (isPoorConnectionQuality) {
-      issues.push({
-        type: IssueType.Network,
-        reason: IssueReason.LowOutboundMOS,
-        iceCandidate: data.connection.local.id,
-        debug,
-        data: mos,
-      });
-    }
-
     return issues;
   }
 }

package/src/engine/wid/lib/NetworkScoresCalculator.ts

@@ -0,0 +1,122 @@
+/* eslint-disable class-methods-use-this */
+import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { NetworkScore, NetworkScores } from '../types';
+
+class NetworkScoresCalculator {
+  #lastProcessedStats: { [connectionId: string]: WebRTCStatsEventData } = {};
+
+  calculate(data: WebRTCStatsEventData): NetworkScores {
+    const outbound = this.calcucateOutboundScore(data);
+    const inbound = this.calculateInboundScore(data);
+    this.#lastProcessedStats[data.connection.id] = data;
+    return { outbound, inbound };
+  }
+
+  private calcucateOutboundScore(data: WebRTCStatsEventData): NetworkScore | undefined {
+    const remoteInboundRTPStreamsStats = [
+      ...data.remote?.audio.inbound || [],
+      ...data.remote?.video.inbound || [],
+    ];
+
+    if (!remoteInboundRTPStreamsStats.length) {
+      return undefined;
+    }
+
+    const previousStats = this.#lastProcessedStats[data.connection.id];
+    if (!previousStats) {
+      return undefined;
+    }
+
+    const previousRemoteInboundRTPStreamsStats = [
+      ...previousStats.remote?.audio.inbound || [],
+      ...previousStats.remote?.video.inbound || [],
+    ];
+
+    const { packetsSent } = data.connection;
+    const lastPacketsSent = previousStats.connection.packetsSent;
+
+    const rtpNetworkStats = remoteInboundRTPStreamsStats.reduce((stats, currentStreamStats) => {
+      const previousStreamStats = previousRemoteInboundRTPStreamsStats
+        .find((stream) => stream.ssrc === currentStreamStats.ssrc);
+
+      return {
+        sumJitter: stats.sumJitter + currentStreamStats.jitter,
+        packetsLost: stats.packetsLost + currentStreamStats.packetsLost,
+        lastPacketsLost: stats.lastPacketsLost + (previousStreamStats?.packetsLost || 0),
+      };
+    }, {
+      sumJitter: 0,
+      packetsLost: 0,
+      lastPacketsLost: 0,
+    });
+
+    const rtt = (1e3 * data.connection.currentRoundTripTime) || 0;
+    const { sumJitter } = rtpNetworkStats;
+    const avgJitter = sumJitter / remoteInboundRTPStreamsStats.length;
+
+    const deltaPacketSent = packetsSent - lastPacketsSent;
+    const deltaPacketLost = rtpNetworkStats.packetsLost - rtpNetworkStats.lastPacketsLost;
+
+    const packetsLoss = deltaPacketSent && deltaPacketLost
+      ? Math.round((deltaPacketLost * 100) / (deltaPacketSent + deltaPacketLost))
+      : 0;
+
+    return this.calculateMOS({ avgJitter, rtt, packetsLoss });
+  }
+
+  private calculateInboundScore(data: WebRTCStatsEventData): NetworkScore | undefined {
+    const inboundRTPStreamsStats = [...data.audio?.inbound, ...data.video?.inbound];
+    if (!inboundRTPStreamsStats.length) {
+      return undefined;
+    }
+
+    const previousStats = this.#lastProcessedStats[data.connection.id];
+    if (!previousStats) {
+      return undefined;
+    }
+
+    const previousInboundStreamStats = [...previousStats.video?.inbound, ...previousStats.audio?.inbound];
+    const { packetsReceived } = data.connection;
+    const lastPacketsReceived = previousStats.connection.packetsReceived;
+
+    const rtpNetworkStats = inboundRTPStreamsStats.reduce((stats, currentStreamStats) => {
+      const previousStreamStats = previousInboundStreamStats.find((stream) => stream.ssrc === currentStreamStats.ssrc);
+      return {
+        sumJitter: stats.sumJitter + currentStreamStats.jitter,
+        packetsLost: stats.packetsLost + currentStreamStats.packetsLost,
+        lastPacketsLost: stats.lastPacketsLost + (previousStreamStats?.packetsLost || 0),
+      };
+    }, {
+      sumJitter: 0,
+      packetsLost: 0,
+      lastPacketsLost: 0,
+    });
+
+    const rtt = (1e3 * data.connection.currentRoundTripTime) || 0;
+    const { sumJitter } = rtpNetworkStats;
+    const avgJitter = sumJitter / inboundRTPStreamsStats.length;
+
+    const deltaPacketReceived = packetsReceived - lastPacketsReceived;
+    const deltaPacketLost = rtpNetworkStats.packetsLost - rtpNetworkStats.lastPacketsLost;
+
+    const packetsLoss = deltaPacketReceived && deltaPacketLost
+      ? Math.round((deltaPacketLost * 100) / (deltaPacketReceived + deltaPacketLost))
+      : 0;
+
+    return this.calculateMOS({ avgJitter, rtt, packetsLoss });
+  }
+
+  private calculateMOS(
+    { avgJitter, rtt, packetsLoss }:
+    { avgJitter: number, rtt: number, packetsLoss: number },
+  ): number {
+    const effectiveLatency = rtt + (avgJitter * 2) + 10;
+    let rFactor = effectiveLatency < 160
+      ? 93.2 - (effectiveLatency / 40)
+      : 93.2 - (effectiveLatency / 120) - 10;
+    rFactor -= (packetsLoss * 2.5);
+    return 1 + (0.035) * rFactor + (0.000007) * rFactor * (rFactor - 60) * (100 - rFactor);
+  }
+}
+
+export default NetworkScoresCalculator;

package/src/engine/wid/types.ts

@@ -14,12 +14,14 @@ export interface IssueDetector {
 
 export enum EventType {
   Issue = 'issue',
+  NetworkScoresUpdated = 'network-scores-updated',
 }
 
 export type EventPayload = IssueDetectorResult;
 
 export type WebRTCIssueDetectorConstructorParams = {
   onIssues?: (payload: IssueDetectorResult) => void,
+  onNetworkScoresUpdated?: (payload: NetworkScores) => void,
   ignoreSSRCList?: number[],
 };
 
@@ -60,3 +62,10 @@ export type DetectIssuesPayload = {
   data: WebRTCStatsEventData,
   ignoreSSRCList?: number[],
 };
+
+export type NetworkScore = number;
+
+export type NetworkScores = {
+  outbound?: NetworkScore,
+  inbound?: NetworkScore,
+};

package/src/index.ts

@@ -14,7 +14,7 @@ import Engine from './engine';
 import Peer from './engine/Peer';
 import { LoadBalancerApiClientParams } from './engine/network/LoadBalancerClient';
 import DefaultEngineDependenciesFactory from './engine/DefaultEngineDependenciesFactory';
-import { IssuesHandler } from './types/engine';
+import { IssuesHandler, NetworkScoresUpdatedHandler } from './types/engine';
 
 type ClientParams = {
   observer?: EnhancedEventEmitter;
@@ -24,6 +24,7 @@ type ClientParams = {
   logLevel?: LogLevel,
   onLogMessage?: LogMessageHandler;
   onIssues?: IssuesHandler,
+  onNetworkScoresUpdated?: NetworkScoresUpdatedHandler,
 };
 
 class Client {
@@ -37,6 +38,7 @@ class Client {
       network,
       onLogMessage,
       onIssues,
+      onNetworkScoresUpdated,
       logLevel,
     } = params;
 
@@ -54,6 +56,7 @@ class Client {
       logLevel,
       onLogMessage,
       onIssues,
+      onNetworkScoresUpdated,
     });
   }
 

package/src/types/engine.ts

@@ -7,13 +7,16 @@ import ChannelEventHandler from '../engine/handlers/ChannelEventHandler';
 import MediaSoupEventHandler from '../engine/handlers/MediaSoupEventHandler';
 import WebRTCIssueDetector from '../engine/wid/WebRTCIssueDetector';
 import { LoadBalancerApiClientParams } from '../engine/network/LoadBalancerClient';
-import { IssueDetectorResult } from '../engine/wid/types';
+import { IssueDetectorResult, NetworkScores } from '../engine/wid/types';
 import { LogLevel } from './common';
 
 export type IssuesHandler = (issues: IssueDetectorResult) => void;
 
+export type NetworkScoresUpdatedHandler = (networks: NetworkScores) => void;
+
 export interface CreateIssueDetectorParams {
   onIssues?: IssuesHandler;
+  onNetworkScoresUpdated?: NetworkScoresUpdatedHandler;
   ignoreSSRCList?: number[];
 }