@observertc/observer-js 0.41.6 → 0.42.0

package/lib/ObservedPeerConnection.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservedPeerConnection = void 0;
 const events_1 = require("events");
-const ObservedInboundTrack_1 = require("./ObservedInboundTrack");
-const ObservedOutboundTrack_1 = require("./ObservedOutboundTrack");
 const ObservedICE_1 = require("./ObservedICE");
 const ObservedDataChannel_1 = require("./ObservedDataChannel");
+const ObservedInboundAudioTrack_1 = require("./ObservedInboundAudioTrack");
+const ObservedInboundVideoTrack_1 = require("./ObservedInboundVideoTrack");
+const ObservedOutboundAudioTrack_1 = require("./ObservedOutboundAudioTrack");
+const ObservedOutboundVideoTrack_1 = require("./ObservedOutboundVideoTrack");
+const CalculatedScore_1 = require("./common/CalculatedScore");
 class ObservedPeerConnection extends events_1.EventEmitter {
     constructor(_model, client) {
         super();
@@ -13,6 +16,7 @@ class ObservedPeerConnection extends events_1.EventEmitter {
         this.client = client;
         this.created = Date.now();
         this.visited = true;
+        this.ωpendingIssuesForScores = [];
         this.totalInboundPacketsLost = 0;
         this.totalInboundPacketsReceived = 0;
         this.totalOutboundPacketsSent = 0;
@@ -143,8 +147,16 @@ class ObservedPeerConnection extends events_1.EventEmitter {
         this._closed = true;
         Array.from(this._inboundAudioTracks.values()).forEach((track) => track.close());
         Array.from(this._inboundVideoTracks.values()).forEach((track) => track.close());
-        Array.from(this._outboundAudioTracks.values()).forEach((track) => track.close());
-        Array.from(this._outboundVideoTracks.values()).forEach((track) => track.close());
+        Array.from(this._outboundAudioTracks.values()).forEach((track) => {
+            var _a;
+            this.client.call.sfuStreamIdToOutboundAudioTrack.delete((_a = track.sfuStreamId) !== null && _a !== void 0 ? _a : '');
+            track.close();
+        });
+        Array.from(this._outboundVideoTracks.values()).forEach((track) => {
+            var _a;
+            this.client.call.sfuStreamIdToOutboundVideoTrack.delete((_a = track.sfuStreamId) !== null && _a !== void 0 ? _a : '');
+            track.close();
+        });
         this.emit('close');
     }
     getTrack(trackId) {
@@ -171,84 +183,6 @@ class ObservedPeerConnection extends events_1.EventEmitter {
         this.receivingVideoBitrate = 0;
         this.ICE.resetMetrics();
     }
-    updateMetrics() {
-        var _a;
-        let sumRttInMs = 0;
-        this._inboundAudioTracks.forEach((track) => {
-            var _a;
-            track.updateMetrics();
-            this.deltaInboundPacketsLost += track.deltaLostPackets;
-            this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
-            this.deltaInboundReceivedBytes += track.deltaBytesReceived;
-            this.deltaReceivedAudioBytes += track.deltaBytesReceived;
-            this.deltaReceivedAudioPackets += track.deltaReceivedPackets;
-            this.receivingAudioBitrate += track.bitrate;
-            sumRttInMs = ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-        });
-        this._inboundVideoTracks.forEach((track) => {
-            var _a;
-            track.updateMetrics();
-            this.deltaInboundPacketsLost += track.deltaLostPackets;
-            this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
-            this.deltaInboundReceivedBytes += track.deltaBytesReceived;
-            this.deltaReceivedVideoBytes += track.deltaBytesReceived;
-            this.deltaReceivedVideoPackets += track.deltaReceivedPackets;
-            this.receivingVideoBitrate += track.bitrate;
-            sumRttInMs = ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-        });
-        this._outboundAudioTracks.forEach((track) => {
-            var _a;
-            track.updateMetrics();
-            this.deltaOutboundPacketsSent += track.deltaSentPackets;
-            this.deltaOutboundSentBytes += track.deltaSentBytes;
-            this.deltaSentAudioBytes += track.deltaSentBytes;
-            this.deltaSentAudioBytes += track.deltaSentPackets;
-            this.sendingAudioBitrate += track.bitrate;
-            sumRttInMs = ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-        });
-        this._outboundVideoTracks.forEach((track) => {
-            var _a;
-            track.updateMetrics();
-            this.deltaOutboundPacketsSent += track.deltaSentPackets;
-            this.deltaOutboundSentBytes += track.deltaSentBytes;
-            this.deltaSentVideoBytes += track.deltaSentBytes;
-            this.deltaSentVideoBytes += track.deltaSentPackets;
-            this.sendingVideoBitrate += track.bitrate;
-            sumRttInMs = ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
-        });
-        this._dataChannels.forEach((channel) => {
-            this.deltaDataChannelBytesSent += channel.deltaBytesSent;
-            this.deltaDataChannelBytesReceived += channel.deltaBytesReceived;
-        });
-        const iceRttInMs = (_a = this.ICE.stats) === null || _a === void 0 ? void 0 : _a.currentRoundTripTime;
-        let nrOfBelongings = this._inboundAudioTracks.size + this._inboundVideoTracks.size + this._outboundAudioTracks.size + this._outboundVideoTracks.size;
-        if (iceRttInMs) {
-            sumRttInMs += iceRttInMs;
-            nrOfBelongings += 1;
-        }
-        this.avgRttInMs = 0 < nrOfBelongings ? sumRttInMs / nrOfBelongings : undefined;
-        this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
-        this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
-        this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
-        this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
-        this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
-        this.totalSentAudioBytes += this.deltaSentAudioBytes;
-        this.totalSentVideoBytes += this.deltaSentVideoBytes;
-        this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
-        this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
-        this.totalReceivedAudioPacktes += this.deltaReceivedAudioPackets;
-        this.totalReceivedVideoPackets += this.deltaReceivedVideoPackets;
-        this.totalSentAudioPackets += this.deltaSentAudioBytes;
-        this.totalSentVideoPackets += this.deltaSentVideoBytes;
-        if (this._elapsedTimeSinceLastUpdate && 0 < this._elapsedTimeSinceLastUpdate) {
-            this.sendingPacketsPerSecond = this.deltaOutboundPacketsSent / (this._elapsedTimeSinceLastUpdate / 1000);
-            this.receivingPacketsPerSecond = this.deltaInboundPacketsReceived / (this._elapsedTimeSinceLastUpdate / 1000);
-        }
-        else {
-            this.sendingPacketsPerSecond = 0;
-            this.receivingPacketsPerSecond = 0;
-        }
-    }
     update(sample, timestamp) {
         if (this._closed)
             return;
@@ -264,6 +198,7 @@ class ObservedPeerConnection extends events_1.EventEmitter {
         this._elapsedTimeSinceLastUpdate = now - this._updated;
         this.visited = true;
         this._updated = now;
+        this._statsTimestamp = timestamp;
         this.emit('update', {
             elapsedTimeInMs: this._elapsedTimeSinceLastUpdate,
         });
@@ -271,7 +206,7 @@ class ObservedPeerConnection extends events_1.EventEmitter {
     createInboundAudioTrack(config) {
         if (this._closed)
             throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedInboundTrack_1.ObservedInboundTrack(Object.assign({ kind: 'audio' }, config), this);
+        const result = new ObservedInboundAudioTrack_1.ObservedInboundAudioTrack(config, this);
         result.on('close', () => {
             this._inboundAudioTracks.delete(result.trackId);
         });
@@ -282,7 +217,7 @@ class ObservedPeerConnection extends events_1.EventEmitter {
     createInboundVideoTrack(config) {
         if (this._closed)
             throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedInboundTrack_1.ObservedInboundTrack(Object.assign({ kind: 'video' }, config), this);
+        const result = new ObservedInboundVideoTrack_1.ObservedInboundVideoTrack(config, this);
         result.on('close', () => {
             this._inboundVideoTracks.delete(result.trackId);
         });
@@ -293,7 +228,7 @@ class ObservedPeerConnection extends events_1.EventEmitter {
     createOutboundAudioTrack(config) {
         if (this._closed)
             throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedOutboundTrack_1.ObservedOutboundTrack(Object.assign({ kind: 'audio' }, config), this);
+        const result = new ObservedOutboundAudioTrack_1.ObservedOutboundAudioTrack(config, this);
         result.on('close', () => {
             this._outboundAudioTracks.delete(result.trackId);
         });
@@ -304,7 +239,7 @@ class ObservedPeerConnection extends events_1.EventEmitter {
     createOutboundVideoTrack(config) {
         if (this._closed)
             throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
-        const result = new ObservedOutboundTrack_1.ObservedOutboundTrack(Object.assign({ kind: 'video' }, config), this);
+        const result = new ObservedOutboundVideoTrack_1.ObservedOutboundVideoTrack(config, this);
         result.on('close', () => {
             this._outboundVideoTracks.delete(result.trackId);
         });
@@ -325,5 +260,141 @@ class ObservedPeerConnection extends events_1.EventEmitter {
         this.emit('newdatachannel', result);
         return result;
     }
+    updateMetrics() {
+        var _a;
+        let sumRttInMs = 0;
+        let sumJitter = 0;
+        const trackScores = [];
+        this._inboundAudioTracks.forEach((track) => {
+            var _a, _b;
+            track.updateMetrics();
+            this.deltaInboundPacketsLost += track.deltaLostPackets;
+            this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
+            this.deltaInboundReceivedBytes += track.deltaBytesReceived;
+            this.deltaReceivedAudioBytes += track.deltaBytesReceived;
+            this.deltaReceivedAudioPackets += track.deltaReceivedPackets;
+            this.receivingAudioBitrate += track.bitrate;
+            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
+            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
+            track.score && trackScores.push(track.score);
+        });
+        this._inboundVideoTracks.forEach((track) => {
+            var _a, _b;
+            track.updateMetrics();
+            this.deltaInboundPacketsLost += track.deltaLostPackets;
+            this.deltaInboundPacketsReceived += track.deltaReceivedPackets;
+            this.deltaInboundReceivedBytes += track.deltaBytesReceived;
+            this.deltaReceivedVideoBytes += track.deltaBytesReceived;
+            this.deltaReceivedVideoPackets += track.deltaReceivedPackets;
+            this.receivingVideoBitrate += track.bitrate;
+            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
+            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
+            track.score && trackScores.push(track.score);
+        });
+        this._outboundAudioTracks.forEach((track) => {
+            var _a, _b;
+            track.updateMetrics();
+            this.deltaOutboundPacketsSent += track.deltaSentPackets;
+            this.deltaOutboundSentBytes += track.deltaSentBytes;
+            this.deltaSentAudioBytes += track.deltaSentBytes;
+            this.deltaSentAudioBytes += track.deltaSentPackets;
+            this.sendingAudioBitrate += track.bitrate;
+            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
+            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
+            track.score && trackScores.push(track.score);
+        });
+        this._outboundVideoTracks.forEach((track) => {
+            var _a, _b;
+            track.updateMetrics();
+            this.deltaOutboundPacketsSent += track.deltaSentPackets;
+            this.deltaOutboundSentBytes += track.deltaSentBytes;
+            this.deltaSentVideoBytes += track.deltaSentBytes;
+            this.deltaSentVideoBytes += track.deltaSentPackets;
+            this.sendingVideoBitrate += track.bitrate;
+            sumRttInMs += ((_a = track.rttInMs) !== null && _a !== void 0 ? _a : 0);
+            sumJitter += ((_b = track.jitter) !== null && _b !== void 0 ? _b : 0);
+            track.score && trackScores.push(track.score);
+        });
+        this._dataChannels.forEach((channel) => {
+            this.deltaDataChannelBytesSent += channel.deltaBytesSent;
+            this.deltaDataChannelBytesReceived += channel.deltaBytesReceived;
+        });
+        const iceRttInMs = (_a = this.ICE.stats) === null || _a === void 0 ? void 0 : _a.currentRoundTripTime;
+        let nrOfBelongings = this._inboundAudioTracks.size + this._inboundVideoTracks.size + this._outboundAudioTracks.size + this._outboundVideoTracks.size;
+        this.avgJitter = 0 < nrOfBelongings ? sumJitter / nrOfBelongings : undefined;
+        if (iceRttInMs) {
+            sumRttInMs += iceRttInMs;
+            nrOfBelongings += 1;
+        }
+        this.avgRttInMs = 0 < nrOfBelongings ? sumRttInMs / nrOfBelongings : undefined;
+        this.totalDataChannelBytesReceived += this.deltaDataChannelBytesReceived;
+        this.totalDataChannelBytesSent += this.deltaDataChannelBytesSent;
+        this.totalInboundPacketsLost += this.deltaInboundPacketsLost;
+        this.totalInboundPacketsReceived += this.deltaInboundPacketsReceived;
+        this.totalOutboundPacketsSent += this.deltaOutboundPacketsSent;
+        this.totalSentAudioBytes += this.deltaSentAudioBytes;
+        this.totalSentVideoBytes += this.deltaSentVideoBytes;
+        this.totalReceivedAudioBytes += this.deltaReceivedAudioBytes;
+        this.totalReceivedVideoBytes += this.deltaReceivedVideoBytes;
+        this.totalReceivedAudioPacktes += this.deltaReceivedAudioPackets;
+        this.totalReceivedVideoPackets += this.deltaReceivedVideoPackets;
+        this.totalSentAudioPackets += this.deltaSentAudioBytes;
+        this.totalSentVideoPackets += this.deltaSentVideoBytes;
+        if (this._elapsedTimeSinceLastUpdate && 0 < this._elapsedTimeSinceLastUpdate) {
+            this.sendingPacketsPerSecond = this.deltaOutboundPacketsSent / (this._elapsedTimeSinceLastUpdate / 1000);
+            this.receivingPacketsPerSecond = this.deltaInboundPacketsReceived / (this._elapsedTimeSinceLastUpdate / 1000);
+        }
+        else {
+            this.sendingPacketsPerSecond = 0;
+            this.receivingPacketsPerSecond = 0;
+        }
+        // calculate quality score
+        this._updateQualityScore(trackScores);
+    }
+    _updateQualityScore(trackScores) {
+        var _a, _b, _c, _d;
+        const mosScore = (0, CalculatedScore_1.calculateLatencyMOS)({
+            avgJitter: (_a = this.avgJitter) !== null && _a !== void 0 ? _a : 0,
+            rttInMs: (_b = this.avgRttInMs) !== null && _b !== void 0 ? _b : 0,
+            packetsLoss: this.deltaInboundPacketsLost,
+        });
+        const score = {
+            remarks: [{
+                    severity: 'none',
+                    text: `MOS score: ${mosScore}`,
+                }],
+            score: mosScore / 10.0,
+            timestamp: (_c = this._statsTimestamp) !== null && _c !== void 0 ? _c : Date.now(),
+        };
+        let sumTrackScores = 0;
+        for (const trackScore of trackScores) {
+            sumTrackScores += trackScore.score;
+        }
+        score.score += sumTrackScores / trackScores.length;
+        score.remarks.push({
+            severity: 'none',
+            text: `Track scores: ${sumTrackScores / trackScores.length}`,
+        });
+        for (const pendingScore of this.ωpendingIssuesForScores) {
+            switch (pendingScore.severity) {
+                case 'critical':
+                    score.score = 0.0;
+                    break;
+                case 'major':
+                    score.score *= 0.5;
+                    break;
+                case 'minor':
+                    score.score *= 0.8;
+                    break;
+            }
+            score.remarks.push({
+                severity: pendingScore.severity,
+                text: (_d = pendingScore.description) !== null && _d !== void 0 ? _d : 'Issue occurred',
+            });
+        }
+        this.ωpendingIssuesForScores = [];
+        this.score = score;
+        this.emit('score', score);
+    }
 }
 exports.ObservedPeerConnection = ObservedPeerConnection;

package/lib/RemoteTrackAssigner.d.ts

@@ -0,0 +1,14 @@
+import { ObservedInboundAudioTrack } from './ObservedInboundAudioTrack';
+import { ObservedInboundVideoTrack } from './ObservedInboundVideoTrack';
+import { ObservedOutboundAudioTrack } from './ObservedOutboundAudioTrack';
+import { ObservedOutboundVideoTrack } from './ObservedOutboundVideoTrack';
+export declare class RemoteTrackAssigner {
+    readonly sfuStreamIdToOutboundVideoTracks: Map<string, ObservedOutboundVideoTrack>;
+    readonly sfuStreamIdToOutboundAudioTracks: Map<string, ObservedOutboundAudioTrack>;
+    readonly pendingInboundVideoTracks: Map<string, ObservedInboundVideoTrack[]>;
+    readonly pendingInboundAudioTracks: Map<string, ObservedInboundAudioTrack[]>;
+    addOutboundAudioTrack(track: ObservedOutboundAudioTrack): void;
+    addOutboundVideoTrack(track: ObservedOutboundVideoTrack): void;
+    addInboundAudioTrack(track: ObservedInboundAudioTrack): void;
+}
+//# sourceMappingURL=RemoteTrackAssigner.d.ts.map

package/lib/RemoteTrackAssigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteTrackAssigner.d.ts","sourceRoot":"","sources":["../src/RemoteTrackAssigner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAE1E,qBAAa,mBAAmB;IAC/B,SAAgB,gCAAgC,0CAAiD;IACjG,SAAgB,gCAAgC,0CAAiD;IACjG,SAAgB,yBAAyB,2CAAkD;IAC3F,SAAgB,yBAAyB,2CAAkD;IAEpF,qBAAqB,CAAC,KAAK,EAAE,0BAA0B;IAcvD,qBAAqB,CAAC,KAAK,EAAE,0BAA0B;IAcvD,oBAAoB,CAAC,KAAK,EAAE,yBAAyB;CA4B5D"}

package/lib/RemoteTrackAssigner.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteTrackAssigner = void 0;
+class RemoteTrackAssigner {
+    constructor() {
+        this.sfuStreamIdToOutboundVideoTracks = new Map();
+        this.sfuStreamIdToOutboundAudioTracks = new Map();
+        this.pendingInboundVideoTracks = new Map();
+        this.pendingInboundAudioTracks = new Map();
+    }
+    addOutboundAudioTrack(track) {
+        const untilSfuStreamIdListener = () => {
+            if (!track.sfuStreamId)
+                return;
+            this.sfuStreamIdToOutboundAudioTracks.set(track.sfuStreamId, track);
+            track.off('update', untilSfuStreamIdListener);
+            // we need to assign to the pending inbound tracks
+        };
+        track.on('update', untilSfuStreamIdListener);
+        untilSfuStreamIdListener();
+    }
+    addOutboundVideoTrack(track) {
+        const untilSfuStreamIdListener = () => {
+            if (!track.sfuStreamId)
+                return;
+            this.sfuStreamIdToOutboundVideoTracks.set(track.sfuStreamId, track);
+            track.off('update', untilSfuStreamIdListener);
+            // we need to assign to the pending inbound tracks
+        };
+        track.on('update', untilSfuStreamIdListener);
+        untilSfuStreamIdListener();
+    }
+    addInboundAudioTrack(track) {
+        const untilSfuStreamIdListener = () => {
+            if (!track.sfuStreamId)
+                return;
+            const outboundTrack = this.sfuStreamIdToOutboundAudioTracks.get(track.sfuStreamId);
+            if (!outboundTrack) {
+                this.pendingInboundAudioTracks.set(track.sfuStreamId, (this.pendingInboundAudioTracks.get(track.sfuStreamId) || []).concat(track));
+                return;
+            }
+            if (outboundTrack) {
+                track.remoteOutboundTrack = outboundTrack;
+            }
+            else {
+                this.pendingInboundAudioTracks.set(track.sfuStreamId, (this.pendingInboundAudioTracks.get(track.sfuStreamId) || []).concat(track));
+            }
+        };
+        track.on('update', untilSfuStreamIdListener);
+    }
+}
+exports.RemoteTrackAssigner = RemoteTrackAssigner;

package/lib/common/CalculatedScore.d.ts

@@ -0,0 +1,79 @@
+import { ClientIssue } from '../monitors/CallSummary';
+import { ObservedInboundVideoTrack } from '../ObservedInboundVideoTrack';
+import { ObservedInboundAudioTrack } from '../ObservedInboundAudioTrack';
+import { ObservedOutboundVideoTrack } from '../ObservedOutboundVideoTrack';
+import { ObservedOutboundAudioTrack } from '../ObservedOutboundAudioTrack';
+export type CalculationRemark = {
+    severity: 'none' | 'minor' | 'major' | 'critical';
+    text: string;
+};
+export type CalculatedScore = {
+    score: number;
+    timestamp: number;
+    remarks: CalculationRemark[];
+    debugText?: string;
+};
+export declare const BPP_RANGES: {
+    lowmotion: {
+        h264: {
+            low: number;
+            high: number;
+        };
+        h265: {
+            low: number;
+            high: number;
+        };
+        vp8: {
+            low: number;
+            high: number;
+        };
+        vp9: {
+            low: number;
+            high: number;
+        };
+    };
+    standard: {
+        h264: {
+            low: number;
+            high: number;
+        };
+        h265: {
+            low: number;
+            high: number;
+        };
+        vp8: {
+            low: number;
+            high: number;
+        };
+        vp9: {
+            low: number;
+            high: number;
+        };
+    };
+    highmotion: {
+        h264: {
+            low: number;
+            high: number;
+        };
+        h265: {
+            low: number;
+            high: number;
+        };
+        vp8: {
+            low: number;
+            high: number;
+        };
+        vp9: {
+            low: number;
+            high: number;
+        };
+    };
+};
+export declare function calculateBaseVideoScore(track: ObservedInboundVideoTrack | ObservedOutboundVideoTrack, newIssues: ClientIssue[]): CalculatedScore | undefined;
+export declare function calculateBaseAudioScore(track: ObservedInboundAudioTrack | ObservedOutboundAudioTrack, newIssues: ClientIssue[]): CalculatedScore | undefined;
+export declare function calculateLatencyMOS({ avgJitter, rttInMs, packetsLoss }: {
+    avgJitter: number;
+    rttInMs: number;
+    packetsLoss: number;
+}): number;
+//# sourceMappingURL=CalculatedScore.d.ts.map

package/lib/common/CalculatedScore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CalculatedScore.d.ts","sourceRoot":"","sources":["../../src/common/CalculatedScore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,yBAAyB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAE3E,MAAM,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAAC;IAClD,IAAI,EAAE,MAAM,CAAC;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,iBAAiB,EAAE,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAA;AAmBD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBtB,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,yBAAyB,GAAG,0BAA0B,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,eAAe,GAAG,SAAS,CAiE5J;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,yBAAyB,GAAG,0BAA0B,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,eAAe,GAAG,SAAS,CA0C5J;AAED,wBAAgB,mBAAmB,CAClC,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,EACnC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACzD,MAAM,CASR"}

package/lib/common/CalculatedScore.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateLatencyMOS = exports.calculateBaseAudioScore = exports.calculateBaseVideoScore = exports.BPP_RANGES = void 0;
+// every track calculates its own score and stores 
+// the latest CalculatedScore in a score property also emits as an event 'score'
+// every peer connection collects the scores and calculates its own score based on RTT, and stores it in the score property similar to track
+// every client collects the scores and calculates its own score based on the peer connection scores, and stores it in the score property similar to track
+// every call collects the scores and calculates its own score based on the client scores, and stores it in the score property similar to track, but
+// but calls only recalculate it after a configured amount of time passed from the last recalculation, and it does not trigger automatically
+/*
+Recommended bpp Ranges for Good Quality
+
+| Content Type       | H.264 (AVC) bpp Range | H.265 (HEVC) bpp Range | VP8 bpp Range | VP9 bpp Range |
+|--------------------|-----------------------|-----------------------|---------------|---------------|
+| Low Motion         | 0.1 - 0.2             | 0.05 - 0.15           | 0.1 - 0.2     | 0.05 - 0.15   |
+| Standard Motion    | 0.15 - 0.25           | 0.1 - 0.2             | 0.15 - 0.25   | 0.1 - 0.2     |
+| High Motion        | 0.25 - 0.4            | 0.15 - 0.3            | 0.25 - 0.4    | 0.15 - 0.3    |
+
+*/
+exports.BPP_RANGES = {
+    'lowmotion': {
+        'h264': { low: 0.1, high: 0.2 },
+        'h265': { low: 0.05, high: 0.15 },
+        'vp8': { low: 0.1, high: 0.2 },
+        'vp9': { low: 0.05, high: 0.15 },
+    },
+    'standard': {
+        'h264': { low: 0.15, high: 0.25 },
+        'h265': { low: 0.1, high: 0.2 },
+        'vp8': { low: 0.15, high: 0.25 },
+        'vp9': { low: 0.1, high: 0.2 },
+    },
+    'highmotion': {
+        'h264': { low: 0.25, high: 0.4 },
+        'h265': { low: 0.15, high: 0.3 },
+        'vp8': { low: 0.25, high: 0.4 },
+        'vp9': { low: 0.15, high: 0.3 },
+    },
+};
+function calculateBaseVideoScore(track, newIssues) {
+    var _a;
+    if (!track.highestLayer) {
+        return;
+    }
+    const { frameHeight, frameWidth, framesPerSecond, bitrate, } = track.highestLayer;
+    const score = {
+        remarks: [],
+        score: 0.0,
+        timestamp: track.statsTimestamp,
+    };
+    if (!frameHeight || !frameWidth || !bitrate || !framesPerSecond) {
+        score.score = 0.0;
+        score.remarks.push({
+            severity: 'major',
+            text: 'Missing data for score calculation',
+        });
+        return score;
+    }
+    const bpp = bitrate / (frameHeight * frameWidth * framesPerSecond);
+    // let's assume vp8 for now
+    const bppRange = exports.BPP_RANGES[track.contentType][track.codec];
+    if (bpp / 2 < bppRange.low) {
+        score.score = 1.0;
+        score.remarks.push({
+            severity: 'major',
+            text: `Bitrate per pixel is too low for ${track.contentType} content`,
+        });
+    }
+    else if (bppRange.low < bpp) {
+        score.score = 1.0;
+        score.remarks.push({
+            severity: 'minor',
+            text: `Bitrate per pixel is good for ${track.contentType} content`,
+        });
+    }
+    else {
+        score.score = Math.min(3.0, 2.0 + ((bpp - bppRange.low) / (bppRange.high - bppRange.low)));
+        score.remarks.push({
+            severity: 'none',
+            text: `Bitrate per pixel is good for ${track.contentType} content`,
+        });
+    }
+    for (const issue of newIssues) {
+        if (issue.severity === 'critical') {
+            score.score = 0.0;
+        }
+        else if (issue.severity === 'major') {
+            score.score *= 0.5;
+        }
+        else if (issue.severity === 'minor') {
+            score.score *= 0.8;
+        }
+        score.remarks.push({
+            severity: issue.severity,
+            text: (_a = issue.description) !== null && _a !== void 0 ? _a : 'Issue occurred',
+        });
+    }
+    return score;
+}
+exports.calculateBaseVideoScore = calculateBaseVideoScore;
+function calculateBaseAudioScore(track, newIssues) {
+    var _a;
+    const score = {
+        remarks: [],
+        score: 0.0,
+        timestamp: track.statsTimestamp,
+    };
+    if (track.bitrate < 8000) {
+        score.score = 1.0;
+        score.remarks.push({
+            severity: 'none',
+            text: 'Bitrate is too low for audio',
+        });
+    }
+    else if (track.bitrate < 16000) {
+        score.score = 2.8;
+        score.remarks.push({
+            severity: 'none',
+            text: 'Bitrate is low for audio',
+        });
+    }
+    else {
+        score.score = 3.0;
+        score.remarks.push({
+            severity: 'none',
+            text: 'Bitrate is good for audio',
+        });
+    }
+    for (const issues of newIssues) {
+        if (issues.severity === 'critical') {
+            score.score = 0.0;
+        }
+        else if (issues.severity === 'major') {
+            score.score *= 0.5;
+        }
+        else if (issues.severity === 'minor') {
+            score.score *= 0.8;
+        }
+        score.remarks.push({
+            severity: issues.severity,
+            text: (_a = issues.description) !== null && _a !== void 0 ? _a : 'Issue occurred',
+        });
+    }
+    return score;
+}
+exports.calculateBaseAudioScore = calculateBaseAudioScore;
+function calculateLatencyMOS({ avgJitter, rttInMs, packetsLoss }) {
+    const effectiveLatency = rttInMs + (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));
+}
+exports.calculateLatencyMOS = calculateLatencyMOS;

package/lib/common/CallEventType.d.ts

@@ -18,7 +18,19 @@ export declare enum CallEventType {
     DATA_CHANNEL_ERROR = "DATA_CHANNEL_ERROR",
     NEGOTIATION_NEEDED = "NEGOTIATION_NEEDED",
     SIGNALING_STATE_CHANGE = "SIGNALING_STATE_CHANGE",
-    CLIENT_ISSUE = "CLIENT_ISSUE"
+    CLIENT_ISSUE = "CLIENT_ISSUE",
+    PRODUCER_ADDED = "PRODUCER_ADDED",
+    PRODUCER_PAUSED = "PRODUCER_PAUSED",
+    PRODUCER_RESUMED = "PRODUCER_RESUMED",
+    PRODUCER_REMOVED = "PRODUCER_REMOVED",
+    CONSUMER_ADDED = "CONSUMER_ADDED",
+    CONSUMER_PAUSED = "CONSUMER_PAUSED",
+    CONSUMER_RESUMED = "CONSUMER_RESUMED",
+    CONSUMER_REMOVED = "CONSUMER_REMOVED",
+    DATA_PRODUCER_OPENED = "DATA_PRODUCER_OPENED",
+    DATA_PRODUCER_CLOSED = "DATA_PRODUCER_CLOSED",
+    DATA_CONSUMER_OPENED = "DATA_CONSUMER_OPENED",
+    DATA_CONSUMER_CLOSED = "DATA_CONSUMER_CLOSED"
 }
 export type CallEventReportType = {
     name: CallEventType.MEDIA_TRACK_ADDED;

package/lib/common/CallEventType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CallEventType.d.ts","sourceRoot":"","sources":["../../src/common/CallEventType.ts"],"names":[],"mappings":"AACA,oBAAY,aAAa;IACxB,YAAY,iBAAiB;IAC7B,UAAU,eAAe;IACzB,aAAa,kBAAkB;IAC/B,WAAW,gBAAgB;IAC3B,sBAAsB,2BAA2B;IACjD,sBAAsB,2BAA2B;IACjD,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,mBAAmB,wBAAwB;IAC3C,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,2BAA2B,gCAAgC;IAC3D,6BAA6B,kCAAkC;IAC/D,4BAA4B,iCAAiC;IAC7D,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,sBAAsB,2BAA2B;IACjD,YAAY,iBAAiB;CAC7B;AAED,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,aAAa,CAAC,iBAAiB,CAAC;IACtC,UAAU,EAAE,yBAAyB,CAAC;CACtC,GAAG;IACH,IAAI,EAAE,aAAa,CAAC,6BAA6B,CAAC;IAClD,UAAU,EAAE,oCAAoC,CAAC;CACjD,GAAG;IACH,IAAI,EAAE,aAAa,CAAC,4BAA4B,CAAC;IACjD,UAAU,EAAE,mCAAmC,CAAC;CAChD,GAAG;IACH,IAAI,EAAE,aAAa,CAAC,2BAA2B,CAAC;IAChD,UAAU,EAAE,kCAAkC,CAAC;CAC/C,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACvC,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,MAAM,MAAM,oCAAoC,GAAG;IAClD,kBAAkB,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;CAC/F,CAAA;AAED,MAAM,MAAM,mCAAmC,GAAG;IACjD,kBAAkB,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,CAAC;CAC3G,CAAA;AAED,MAAM,MAAM,kCAAkC,GAAG;IAChD,iBAAiB,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;CACrD,CAAA"}
+{"version":3,"file":"CallEventType.d.ts","sourceRoot":"","sources":["../../src/common/CallEventType.ts"],"names":[],"mappings":"AACA,oBAAY,aAAa;IACxB,YAAY,iBAAiB;IAC7B,UAAU,eAAe;IACzB,aAAa,kBAAkB;IAC/B,WAAW,gBAAgB;IAC3B,sBAAsB,2BAA2B;IACjD,sBAAsB,2BAA2B;IACjD,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,mBAAmB,wBAAwB;IAC3C,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,2BAA2B,gCAAgC;IAC3D,6BAA6B,kCAAkC;IAC/D,4BAA4B,iCAAiC;IAC7D,iBAAiB,sBAAsB;IACvC,mBAAmB,wBAAwB;IAC3C,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,sBAAsB,2BAA2B;IACjD,YAAY,iBAAiB;IAE7B,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,gBAAgB,qBAAqB;IACrC,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;IACnC,gBAAgB,qBAAqB;IACrC,gBAAgB,qBAAqB;IACrC,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;CAC7C;AAED,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,aAAa,CAAC,iBAAiB,CAAC;IACtC,UAAU,EAAE,yBAAyB,CAAC;CACtC,GAAG;IACH,IAAI,EAAE,aAAa,CAAC,6BAA6B,CAAC;IAClD,UAAU,EAAE,oCAAoC,CAAC;CACjD,GAAG;IACH,IAAI,EAAE,aAAa,CAAC,4BAA4B,CAAC;IACjD,UAAU,EAAE,mCAAmC,CAAC;CAChD,GAAG;IACH,IAAI,EAAE,aAAa,CAAC,2BAA2B,CAAC;IAChD,UAAU,EAAE,kCAAkC,CAAC;CAC/C,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACvC,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,MAAM,MAAM,oCAAoC,GAAG;IAClD,kBAAkB,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,QAAQ,GAAG,KAAK,CAAC;CAC/F,CAAA;AAED,MAAM,MAAM,mCAAmC,GAAG;IACjD,kBAAkB,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,cAAc,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,GAAG,WAAW,CAAC;CAC3G,CAAA;AAED,MAAM,MAAM,kCAAkC,GAAG;IAChD,iBAAiB,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;CACrD,CAAA"}

package/lib/common/CallEventType.js

@@ -24,4 +24,16 @@ var CallEventType;
     CallEventType["NEGOTIATION_NEEDED"] = "NEGOTIATION_NEEDED";
     CallEventType["SIGNALING_STATE_CHANGE"] = "SIGNALING_STATE_CHANGE";
     CallEventType["CLIENT_ISSUE"] = "CLIENT_ISSUE";
+    CallEventType["PRODUCER_ADDED"] = "PRODUCER_ADDED";
+    CallEventType["PRODUCER_PAUSED"] = "PRODUCER_PAUSED";
+    CallEventType["PRODUCER_RESUMED"] = "PRODUCER_RESUMED";
+    CallEventType["PRODUCER_REMOVED"] = "PRODUCER_REMOVED";
+    CallEventType["CONSUMER_ADDED"] = "CONSUMER_ADDED";
+    CallEventType["CONSUMER_PAUSED"] = "CONSUMER_PAUSED";
+    CallEventType["CONSUMER_RESUMED"] = "CONSUMER_RESUMED";
+    CallEventType["CONSUMER_REMOVED"] = "CONSUMER_REMOVED";
+    CallEventType["DATA_PRODUCER_OPENED"] = "DATA_PRODUCER_OPENED";
+    CallEventType["DATA_PRODUCER_CLOSED"] = "DATA_PRODUCER_CLOSED";
+    CallEventType["DATA_CONSUMER_OPENED"] = "DATA_CONSUMER_OPENED";
+    CallEventType["DATA_CONSUMER_CLOSED"] = "DATA_CONSUMER_CLOSED";
 })(CallEventType = exports.CallEventType || (exports.CallEventType = {}));