decoder issue detector test

Author: desher

src/WebRTCIssueDetector.ts

@@ -24,6 +24,7 @@ import {
   QualityLimitationsIssueDetector,
   UnknownVideoDecoderImplementationDetector,
   FrozenVideoTrackDetector,
+  VideoDecoderIssueDetector,
 } from './detectors';
 import { CompositeRTCStatsParser, RTCStatsParser } from './parser';
 import createLogger from './utils/logger';
@@ -67,6 +68,7 @@ class WebRTCIssueDetector {
       new AvailableOutgoingBitrateIssueDetector(),
       new UnknownVideoDecoderImplementationDetector(),
       new FrozenVideoTrackDetector(),
+      new VideoDecoderIssueDetector(),
     ];
 
     this.networkScoresCalculator = params.networkScoresCalculator ?? new DefaultNetworkScoresCalculator();

src/detectors/VideoDecoderIssueDetector.ts

@@ -0,0 +1,71 @@
+import {
+  IssueDetectorResult,
+  WebRTCStatsParsed,
+} from '../types';
+import BaseIssueDetector, { BaseIssueDetectorParams } from './BaseIssueDetector';
+
+interface VideoDecoderIssueDetectorParams extends BaseIssueDetectorParams {
+  decodeTimePerFrameIncreaseSpeedThreshold?: number;
+  minDecodeTimePerFrameIncreaseCases?: number;
+}
+
+class VideoDecoderIssueDetector extends BaseIssueDetector {
+  #decodeTimePerFrameIncreaseSpeedThreshold: number;
+
+  #minDecodeTimePerFrameIncreaseCases: number;
+
+  constructor(params: VideoDecoderIssueDetectorParams = {}) {
+    super(params);
+    this.#decodeTimePerFrameIncreaseSpeedThreshold = params.decodeTimePerFrameIncreaseSpeedThreshold ?? 1.05;
+    this.#minDecodeTimePerFrameIncreaseCases = params.minDecodeTimePerFrameIncreaseCases ?? 3;
+  }
+
+  performDetection(data: WebRTCStatsParsed): IssueDetectorResult {
+    const { connection: { id: connectionId } } = data;
+    const issues = this.processData(data);
+    this.setLastProcessedStats(connectionId, data);
+    return issues;
+  }
+
+  private processData(data: WebRTCStatsParsed): IssueDetectorResult {
+    const currentIncomeVideoStreams = data.video.inbound;
+    const allLastProcessedStats = this
+      .getAllLastProcessedStats(data.connection.id);
+
+    const issues: IssueDetectorResult = [];
+
+    currentIncomeVideoStreams.forEach((incomeVideoStream) => {
+      const lastIncomeVideoStreamStats = allLastProcessedStats
+        .map((connectionStats) => connectionStats.video.inbound.find(
+          (videoStreamStats) => videoStreamStats.id === incomeVideoStream.id,
+        ))
+        .filter((stats) => (stats?.framesDecoded || 0) > 0 && (stats?.totalDecodeTime || 0) > 0);
+
+      if (lastIncomeVideoStreamStats.length < this.#minDecodeTimePerFrameIncreaseCases) {
+        return;
+      }
+
+      const decodeTimePerFrame = lastIncomeVideoStreamStats
+        .map((stats) => (stats!.totalDecodeTime * 1000) / stats!.framesDecoded);
+
+      const currentDecodeTimePerFrame = (incomeVideoStream.totalDecodeTime * 1000) / incomeVideoStream.framesDecoded;
+      decodeTimePerFrame.push(currentDecodeTimePerFrame);
+
+      const mean = decodeTimePerFrame.reduce((acc, val) => acc + val, 0) / decodeTimePerFrame.length;
+      const squaredDiffs = decodeTimePerFrame.map((val) => (val - mean) ** 2);
+      const variance = squaredDiffs.reduce((acc, val) => acc + val, 0) / squaredDiffs.length;
+      const volatility = Math.sqrt(variance);
+
+      console.log({
+        decodeTimePerFrame,
+        mean,
+        variance,
+        volatility,
+      });
+    });
+
+    return issues;
+  }
+}
+
+export default VideoDecoderIssueDetector;

src/detectors/index.ts

@@ -8,3 +8,4 @@ export { default as OutboundNetworkIssueDetector } from './OutboundNetworkIssueD
 export { default as QualityLimitationsIssueDetector } from './QualityLimitationsIssueDetector';
 export { default as UnknownVideoDecoderImplementationDetector } from './UnknownVideoDecoderImplementationDetector';
 export { default as FrozenVideoTrackDetector } from './FrozenVideoTrackDetector';
+export { default as VideoDecoderIssueDetector } from './VideoDecoderIssueDetector';