feat: Improve FrozenVideo and VideoDecoderCPU detectors (#32)

Author: desher

.eslintrc

@@ -15,6 +15,8 @@
     "no-underscore-dangle": "off",
     "max-len": ["error", { "code": 120 }],
     "import/extensions": "off",
-    "import/no-cycle": "off"
+    "import/no-cycle": "off",
+    "no-continue": "off",
+    "import/prefer-default-export": "off"
   }
 }

README.md

@@ -51,14 +51,13 @@ By default, WebRTCIssueDetector can be created with minimum of mandatory constru
 ```typescript
 import WebRTCIssueDetector, {
   QualityLimitationsIssueDetector,
-  FramesDroppedIssueDetector,
-  FramesEncodedSentIssueDetector,
   InboundNetworkIssueDetector,
   OutboundNetworkIssueDetector,
   NetworkMediaSyncIssueDetector,
   AvailableOutgoingBitrateIssueDetector,
   UnknownVideoDecoderImplementationDetector,
   FrozenVideoTrackDetector,
+  VideoDecoderIssueDetector,
 } from 'webrtc-issue-detector';
 
 const widWithDefaultConstructorArgs = new WebRTCIssueDetector();
@@ -68,14 +67,13 @@ const widWithDefaultConstructorArgs = new WebRTCIssueDetector();
 const widWithCustomConstructorArgs = new WebRTCIssueDetector({
   detectors: [ // you are free to change the detectors list according to your needs
     new QualityLimitationsIssueDetector(),
-    new FramesDroppedIssueDetector(),
-    new FramesEncodedSentIssueDetector(),
     new InboundNetworkIssueDetector(),
     new OutboundNetworkIssueDetector(),
     new NetworkMediaSyncIssueDetector(),
     new AvailableOutgoingBitrateIssueDetector(),
     new UnknownVideoDecoderImplementationDetector(),
     new FrozenVideoTrackDetector(),
+    new VideoDecoderIssueDetector(),
   ],
   getStatsInterval: 10_000, // set custom stats parsing interval
   onIssues: (payload: IssueDetectorResult) => {
@@ -106,34 +104,18 @@ const exampleIssue = {
 }
 ```
 
-### FramesDroppedIssueDetector
+### VideoDecoderIssueDetector
 Detects issues with decoder.
 ```js
 const exampleIssue = {
     type: 'cpu',
     reason: 'decoder-cpu-throttling',
     statsSample: {
-      deltaFramesDropped: 100,
-      deltaFramesReceived: 1000,
-      deltaFramesDecoded: 900,
-      framesDroppedPct: 10,
+      affectedStreamsPercent: 67,
+      throtthedStreams: [
+        { ssrc: 123, allDecodeTimePerFrame: [1.2, 1.6, 1.9, 2.4, 2.9], volatility: 1.7 },
+      ]
     },
-    ssrc: 1234,
-}
-```
-
-### FramesEncodedSentIssueDetector
-Detects issues with outbound network throughput.
-```js
-const exampleIssue = {
-    type: 'network',
-    reason: 'outbound-network-throughput',
-    statsSample: {
-      deltaFramesSent: 900,
-      deltaFramesEncoded: 1000,
-      missedFramesPct: 10,
-    },
-    ssrc: 1234,
 }
 ```
 

src/WebRTCIssueDetector.ts

@@ -7,6 +7,7 @@ import {
   IssueDetector,
   IssuePayload,
   Logger,
+  NetworkScores,
   StatsReportItem,
   WebRTCIssueDetectorConstructorParams,
   WebRTCStatsParsed,
@@ -16,14 +17,13 @@ import PeriodicWebRTCStatsReporter from './parser/PeriodicWebRTCStatsReporter';
 import DefaultNetworkScoresCalculator from './NetworkScoresCalculator';
 import {
   AvailableOutgoingBitrateIssueDetector,
-  FramesDroppedIssueDetector,
-  FramesEncodedSentIssueDetector,
   InboundNetworkIssueDetector,
   NetworkMediaSyncIssueDetector,
   OutboundNetworkIssueDetector,
   QualityLimitationsIssueDetector,
   UnknownVideoDecoderImplementationDetector,
   FrozenVideoTrackDetector,
+  VideoDecoderIssueDetector,
 } from './detectors';
 import { CompositeRTCStatsParser, RTCStatsParser } from './parser';
 import createLogger from './utils/logger';
@@ -60,14 +60,13 @@ class WebRTCIssueDetector {
 
     this.detectors = params.detectors ?? [
       new QualityLimitationsIssueDetector(),
-      new FramesDroppedIssueDetector(),
-      new FramesEncodedSentIssueDetector(),
       new InboundNetworkIssueDetector(),
       new OutboundNetworkIssueDetector(),
       new NetworkMediaSyncIssueDetector(),
       new AvailableOutgoingBitrateIssueDetector(),
       new UnknownVideoDecoderImplementationDetector(),
       new FrozenVideoTrackDetector(),
+      new VideoDecoderIssueDetector(),
       new MissingStreamDataDetector(),
     ];
 
@@ -90,11 +89,8 @@ class WebRTCIssueDetector {
     }
 
     this.statsReporter.on(PeriodicWebRTCStatsReporter.STATS_REPORT_READY_EVENT, (report: StatsReportItem) => {
-      this.detectIssues({
-        data: report.stats,
-      });
-
-      this.calculateNetworkScores(report.stats);
+      const networkScores = this.calculateNetworkScores(report.stats);
+      this.detectIssues({ data: report.stats }, networkScores);
     });
 
     this.statsReporter.on(PeriodicWebRTCStatsReporter.STATS_REPORTS_PARSED, (data: {
@@ -163,16 +159,19 @@ class WebRTCIssueDetector {
     this.eventEmitter.emit(EventType.Issue, issues);
   }
 
-  private detectIssues({ data }: DetectIssuesPayload): void {
-    const issues = this.detectors.reduce<IssuePayload[]>((acc, detector) => [...acc, ...detector.detect(data)], []);
+  private detectIssues({ data }: DetectIssuesPayload, networkScores: NetworkScores): void {
+    const issues = this.detectors
+      .reduce<IssuePayload[]>((acc, detector) => [...acc, ...detector.detect(data, networkScores)], []);
+
     if (issues.length > 0) {
       this.emitIssues(issues);
     }
   }
 
-  private calculateNetworkScores(data: WebRTCStatsParsed): void {
+  private calculateNetworkScores(data: WebRTCStatsParsed): NetworkScores {
     const networkScores = this.networkScoresCalculator.calculate(data);
     this.eventEmitter.emit(EventType.NetworkScoresUpdated, networkScores);
+    return networkScores;
   }
 
   private wrapRTCPeerConnection(): void {

src/detectors/BaseIssueDetector.ts

@@ -1,4 +1,10 @@
-import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
+import {
+  IssueDetector,
+  IssueDetectorResult,
+  NetworkScores,
+  WebRTCStatsParsed,
+  WebRTCStatsParsedWithNetworkScores,
+} from '../types';
 import { scheduleTask } from '../utils/tasks';
 import { CLEANUP_PREV_STATS_TTL_MS, MAX_PARSED_STATS_STORAGE_SIZE } from '../utils/constants';
 
@@ -13,7 +19,7 @@ export interface BaseIssueDetectorParams {
 }
 
 abstract class BaseIssueDetector implements IssueDetector {
-  readonly #parsedStatsStorage: Map<string, WebRTCStatsParsed[]> = new Map();
+  readonly #parsedStatsStorage: Map<string, WebRTCStatsParsedWithNetworkScores[]> = new Map();
 
   readonly #statsCleanupDelayMs: number;
 
@@ -24,11 +30,19 @@ abstract class BaseIssueDetector implements IssueDetector {
     this.#maxParsedStatsStorageSize = params.maxParsedStatsStorageSize ?? MAX_PARSED_STATS_STORAGE_SIZE;
   }
 
-  abstract performDetection(data: WebRTCStatsParsed): IssueDetectorResult;
+  abstract performDetection(data: WebRTCStatsParsedWithNetworkScores): IssueDetectorResult;
 
-  detect(data: WebRTCStatsParsed): IssueDetectorResult {
-    const result = this.performDetection(data);
+  detect(data: WebRTCStatsParsed, networkScores?: NetworkScores): IssueDetectorResult {
+    const parsedStatsWithNetworkScores = {
+      ...data,
+      networkScores: {
+        ...networkScores,
+        statsSamples: networkScores?.statsSamples || {},
+      },
+    };
+    const result = this.performDetection(parsedStatsWithNetworkScores);
 
+    this.setLastProcessedStats(data.connection.id, parsedStatsWithNetworkScores);
     this.performPrevStatsCleanup({
       connectionId: data.connection.id,
     });
@@ -56,7 +70,7 @@ abstract class BaseIssueDetector implements IssueDetector {
     });
   }
 
-  protected setLastProcessedStats(connectionId: string, parsedStats: WebRTCStatsParsed): void {
+  protected setLastProcessedStats(connectionId: string, parsedStats: WebRTCStatsParsedWithNetworkScores): void {
     if (!connectionId || parsedStats.connection.id !== connectionId) {
       return;
     }
@@ -71,16 +85,16 @@ abstract class BaseIssueDetector implements IssueDetector {
     this.#parsedStatsStorage.set(connectionId, connectionStats);
   }
 
-  protected getLastProcessedStats(connectionId: string): WebRTCStatsParsed | undefined {
+  protected getLastProcessedStats(connectionId: string): WebRTCStatsParsedWithNetworkScores | undefined {
     const connectionStats = this.#parsedStatsStorage.get(connectionId);
     return connectionStats?.[connectionStats.length - 1];
   }
 
-  protected getAllLastProcessedStats(connectionId: string): WebRTCStatsParsed[] {
+  protected getAllLastProcessedStats(connectionId: string): WebRTCStatsParsedWithNetworkScores[] {
     return this.#parsedStatsStorage.get(connectionId) ?? [];
   }
 
-  private deleteLastProcessedStats(connectionId: string): void {
+  protected deleteLastProcessedStats(connectionId: string): void {
     this.#parsedStatsStorage.delete(connectionId);
   }
 }