@livedigital/client 2.22.1 → 2.22.2

package/package.json

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

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

@@ -7,8 +7,14 @@ import {
 } from '../types';
 
 class VideoCodecMismatchDetector implements IssueDetector {
+  readonly UNKNOWN_DECODER = 'unknown';
+
   #lastProcessedStats: { [connectionId: string]: WebRTCStatsEventData | undefined } = {};
 
+  #lastDecoderWithIssue: {
+    [connectionId: string]: { [ssrc: string]: string | undefined } | undefined;
+  } = {};
+
   detect(data: WebRTCStatsEventData): IssueDetectorResult {
     const issues = this.processData(data);
     this.#lastProcessedStats[data.connection.id] = data;
@@ -17,31 +23,56 @@ class VideoCodecMismatchDetector implements IssueDetector {
 
   private processData(data: WebRTCStatsEventData): IssueDetectorResult {
     const issues: IssueDetectorResult = [];
-    const previousInboundRTPVideoStreamsStats = this.#lastProcessedStats[data.connection.id]?.video.inbound;
+    const { id: connectionId } = data.connection;
+    const previousInboundRTPVideoStreamsStats = this.#lastProcessedStats[connectionId]?.video.inbound;
 
     data.video.inbound.forEach((streamStats) => {
       const { decoderImplementation: currentDecoder, ssrc } = streamStats;
       const prevStats = previousInboundRTPVideoStreamsStats?.find((item) => item.ssrc === ssrc);
 
+      // skipping the first iteration on purpose
       if (!prevStats) {
         return;
       }
 
-      const { decoderImplementation: prevDecoder } = prevStats;
+      if (currentDecoder !== this.UNKNOWN_DECODER) {
+        this.setLastDecoderWithIssue(connectionId, ssrc, undefined);
+        return;
+      }
+
+      if (!this.hadLastDecoderWithIssue(connectionId, ssrc)) {
+        this.setLastDecoderWithIssue(connectionId, ssrc, this.UNKNOWN_DECODER);
 
-      if (currentDecoder === 'unknown' && prevDecoder !== 'unknown') {
         issues.push({
+          ssrc,
           type: IssueType.Stream,
           reason: IssueReason.VideoCodecMismatchIssue,
-          ssrc: streamStats.ssrc,
           trackIdentifier: streamStats.track.trackIdentifier,
-          debug: `mimeType: ${streamStats.mimeType}, decoderImplementation: ${streamStats.decoderImplementation}`,
+          debug: `mimeType: ${streamStats.mimeType}, decoderImplementation: ${currentDecoder}`,
         });
       }
     });
 
     return issues;
   }
+
+  private setLastDecoderWithIssue(connectionId: string, ssrc: number, decoder: string | undefined): void {
+    const issues = this.#lastDecoderWithIssue[connectionId] ?? {};
+
+    if (decoder === undefined) {
+      delete issues[ssrc];
+    } else {
+      issues[ssrc] = decoder;
+    }
+
+    this.#lastDecoderWithIssue[connectionId] = issues;
+  }
+
+  private hadLastDecoderWithIssue(connectionId: string, ssrc: number): boolean {
+    const issues = this.#lastDecoderWithIssue[connectionId];
+    const decoder = issues && issues[ssrc];
+    return decoder === this.UNKNOWN_DECODER;
+  }
 }
 
 export default VideoCodecMismatchDetector;