@livedigital/client 2.22.1 → 2.23.0

package/dist/types/common.d.ts

@@ -236,6 +236,59 @@ export declare enum DeviceErrors {
     DeviceIsBusy = "DeviceIsBusy",
     NotAllowedError = "NotAllowedError"
 }
+export declare type TrackInboundStats = {
+    consumerId: string;
+    codec?: RTCRtpCodecParameters;
+    currentSpatialLayerParams?: SpatialLayerParams;
+    availableSpatialLayers?: SpatialLayerParams[];
+    requestedSpatialLayer?: number;
+    score: number;
+    dtlsState?: RTCDtlsTransportState;
+    rtcStats?: ExtendedRTCInboundRtpStreamStats;
+};
+export declare type TrackOutboundStats = {
+    producerId?: string;
+    codec?: RTCRtpCodecParameters;
+    dtlsState?: RTCDtlsTransportState;
+    rtcStats?: RTCOutboundRtpStreamStats;
+};
+export declare type PeerTrackInfo = {
+    trackId: string;
+    readyState: MediaStreamTrackState;
+    isRemote: boolean;
+    kind: MediaKind;
+    label: TrackLabel;
+    paused: boolean;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    aspectRatio?: number;
+    trackInboundStats?: TrackInboundStats;
+    trackOutboundStats?: TrackOutboundStats;
+};
+export declare type BaseTrackInfo = {
+    trackId: string;
+    readyState: MediaStreamTrackState;
+    kind: MediaKind;
+    label: TrackLabel;
+    paused: boolean;
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    aspectRatio?: number;
+    trackOutboundStats?: TrackOutboundStats;
+};
+export declare type PeerInfo = {
+    id: string;
+    appData: Record<string, unknown>;
+    role: Role;
+    channelIds: string[];
+    appId: string;
+    uid?: string;
+    loginDate: Date;
+    connectionQuality: number;
+    tracks: PeerTrackInfo[];
+};
 export declare type UpdatePeerAppDataPayload = {
     peerId: string;
     appData: Record<string, unknown>;

package/package.json

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

package/src/engine/Peer.ts

@@ -8,6 +8,7 @@ import {
   ChangePreferredLayersPayload,
   Role,
   ProducerSetMaxSpatialLayer,
+  PeerInfo,
 } from '../types/common';
 import EnhancedEventEmitter from '../EnhancedEventEmitter';
 import Engine from './index';
@@ -157,6 +158,25 @@ class Peer {
     }
   }
 
+  async getInfo(): Promise<PeerInfo> {
+    try {
+      return {
+        id: this.id,
+        appData: this.appData,
+        role: this.role,
+        channelIds: this.channelIds,
+        appId: this.appId,
+        uid: this.uid,
+        loginDate: this.loginDate,
+        connectionQuality: this.overallConnectionQuality,
+        tracks: await Promise.all(Array.from(this.tracks.values()).map((track) => track.getInfo())),
+      };
+    } catch (error) {
+      this.logger.error('getInfo()', { peer: this, error });
+      throw new Error('Error get info');
+    }
+  }
+
   private handleNewProducer(producerData: ProducerData): void {
     if (this.producers.get(producerData.id)) {
       return;

package/src/engine/PeerConsumer.ts

@@ -6,8 +6,10 @@ import {
   ExtendedRTCInboundRtpStreamStats,
   LogLevel,
   SpatialLayerParams,
+  TrackInboundStats,
 } from '../types/common';
 import Logger from './Logger';
+import filterStatsCodecs from '../helpers/filterStatsCodecs';
 
 export type PeerConsumerConstructorParams = {
   consumer: MediasoupConsumer,
@@ -167,6 +169,24 @@ class PeerConsumer {
     this.currentMaxSpatialLayer = spatialLayer;
   }
 
+  async getStats(): Promise<TrackInboundStats | undefined> {
+    try {
+      return {
+        consumerId: this.consumer.id,
+        codec: this.consumer.rtpParameters.codecs.find((codec) => filterStatsCodecs(codec)),
+        score: this.score,
+        dtlsState: this.consumer.rtpReceiver?.transport?.state,
+        availableSpatialLayers: this.availableSpatialLayers,
+        currentSpatialLayerParams: this.currentSpatialLayerParams,
+        requestedSpatialLayer: this.requestedSpatialLayer,
+        rtcStats: await this.getInboundRTPStreamStats(),
+      };
+    } catch (error) {
+      this.logger.debug('getStats()', { error });
+      return undefined;
+    }
+  }
+
   async getInboundRTPStreamStats(): Promise<ExtendedRTCInboundRtpStreamStats> {
     return new Promise((resolve, reject) => {
       const getRTCStatsReport = async (attempt = 0) => {

package/src/engine/media/tracks/BaseTrack.ts

@@ -1,10 +1,11 @@
 import { Producer } from 'mediasoup-client/lib/Producer';
 import { MediaKind } from 'mediasoup-client/lib/RtpParameters';
 import {
+  BaseTrackInfo,
   EncoderConfig,
   LogLevel,
   SocketResponse,
-  TrackLabel,
+  TrackLabel, TrackOutboundStats,
   TrackProduceParams,
 } from '../../../types/common';
 import Logger from '../../Logger';
@@ -14,6 +15,7 @@ import { PRODUCER_CHECK_STATE_TIMEOUT } from '../../../constants/common';
 import Timeout = NodeJS.Timeout;
 import { MEDIASOUP_EVENTS, INTERNAL_CLIENT_EVENTS, CLIENT_EVENTS } from '../../../constants/events';
 import EnhancedEventEmitter from '../../../EnhancedEventEmitter';
+import filterStatsCodecs from '../../../helpers/filterStatsCodecs';
 
 export type BaseTrackConstructorParams = {
   mediaStreamTrack: MediaStreamTrack,
@@ -41,7 +43,7 @@ class BaseTrack {
 
   #producerRestarted = false;
 
-  #clientEventEmitter: EnhancedEventEmitter;
+  readonly #clientEventEmitter: EnhancedEventEmitter;
 
   #closed = false;
 
@@ -379,6 +381,69 @@ class BaseTrack {
       throw new Error('Can`t resume track');
     }
   }
+
+  async getInfo(): Promise<BaseTrackInfo> {
+    const {
+      width, height, frameRate, aspectRatio,
+    } = this.#mediaStreamTrack.getSettings();
+    return {
+      trackId: this.#mediaStreamTrack.id,
+      readyState: this.#mediaStreamTrack.readyState,
+      kind: this.kind,
+      label: this.label,
+      width,
+      height,
+      frameRate,
+      aspectRatio,
+      paused: this.isPaused,
+      trackOutboundStats: await this.getStats(),
+    };
+  }
+
+  async getStats(): Promise<TrackOutboundStats | undefined> {
+    try {
+      return {
+        producerId: this.producer?.id,
+        codec: this.producer?.rtpParameters.codecs.find((codec) => filterStatsCodecs(codec)),
+        dtlsState: this.producer?.rtpSender?.transport?.state,
+        rtcStats: await this.getOutboundRTPStreamStats(),
+      };
+    } catch (error) {
+      this.logger.debug('getStats()', { error });
+      return undefined;
+    }
+  }
+
+  private getOutboundRTPStreamStats(): Promise<RTCOutboundRtpStreamStats> {
+    return new Promise((resolve, reject) => {
+      const getRTCStatsReport = async (attempt = 0) => {
+        if (!this.producer) {
+          throw new Error('Producer is missed');
+        }
+
+        try {
+          const rtcStatsReport = await this.producer.getStats();
+          const outboundRTPStreamStats: RTCOutboundRtpStreamStats = Array.from(rtcStatsReport.values())
+            .find((stat) => stat.type === 'outbound-rtp');
+          if (!outboundRTPStreamStats && attempt < 5) {
+            setTimeout(() => getRTCStatsReport(attempt + 1), 150);
+            return;
+          }
+
+          if (attempt >= 5 && !outboundRTPStreamStats) {
+            reject(new Error('OutboundRTPStreamStat not exist'));
+          }
+
+          resolve(outboundRTPStreamStats);
+        } catch (error) {
+          reject(new Error('Can not get RTCStatsReport'));
+          this.logger.debug('getOutboundRTPStreamStats()', { error });
+        }
+      };
+
+      getRTCStatsReport();
+    });
+  }
 }
 
 export default BaseTrack;

package/src/engine/media/tracks/PeerTrack.ts

@@ -3,7 +3,8 @@ import {
   PreferredLayersParams,
   SetConsumerPriorityParams,
   SpatialLayerParams,
-  TrackLabel,
+  PeerTrackInfo,
+  TrackLabel, TrackOutboundStats,
 } from '../../../types/common';
 import Logger from '../../Logger';
 import { MEDIASOUP_EVENTS, PEER_EVENTS } from '../../../constants/events';
@@ -57,6 +58,10 @@ class PeerTrack {
     this.#peerEventEmitter.safeEmit(PEER_EVENTS.trackStart, this);
   }
 
+  get isRemote(): boolean {
+    return !!this.consumer;
+  }
+
   get mediaStreamTrack(): MediaStreamTrack {
     return this.#mediaStreamTrack;
   }
@@ -238,6 +243,39 @@ class PeerTrack {
     return this.consumer.availableSpatialLayers;
   }
 
+  async getInfo(): Promise<PeerTrackInfo> {
+    const {
+      width, height, frameRate, aspectRatio,
+    } = this.#mediaStreamTrack.getSettings();
+    return {
+      trackId: this.#mediaStreamTrack.id,
+      readyState: this.#mediaStreamTrack.readyState,
+      isRemote: this.isRemote,
+      kind: this.kind,
+      label: this.label,
+      width,
+      height,
+      frameRate,
+      aspectRatio,
+      paused: this.#paused,
+      trackInboundStats: await this.consumer?.getStats(),
+      trackOutboundStats: await this.getOutboundStats(),
+    };
+  }
+
+  private async getOutboundStats(): Promise<TrackOutboundStats | undefined> {
+    if (this.isRemote) {
+      return undefined;
+    }
+
+    const outboundTrack = this.#engine.media.getAllTracks().find((track) => track.getLabel() === this.label);
+    if (!outboundTrack) {
+      return undefined;
+    }
+
+    return outboundTrack.getStats();
+  }
+
   private async requestMaxSpatialLayer(consumerId: string, spatialLayer: number): Promise<void> {
     try {
       if (!this.consumer) {

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;

package/src/helpers/filterStatsCodecs.ts

@@ -0,0 +1,3 @@
+const filterStatsCodecs = (codec: RTCRtpCodecParameters) => codec.mimeType !== 'rtx';
+
+export default filterStatsCodecs;

package/src/types/common.ts

@@ -274,6 +274,64 @@ export enum DeviceErrors {
   NotAllowedError = 'NotAllowedError',
 }
 
+export type TrackInboundStats = {
+  consumerId: string,
+  codec?: RTCRtpCodecParameters,
+  currentSpatialLayerParams?: SpatialLayerParams,
+  availableSpatialLayers?: SpatialLayerParams[],
+  requestedSpatialLayer?: number,
+  score: number,
+  dtlsState?: RTCDtlsTransportState,
+  rtcStats?: ExtendedRTCInboundRtpStreamStats,
+};
+
+export type TrackOutboundStats = {
+  producerId?: string,
+  codec?: RTCRtpCodecParameters,
+  dtlsState?: RTCDtlsTransportState,
+  rtcStats?: RTCOutboundRtpStreamStats,
+};
+
+export type PeerTrackInfo = {
+  trackId: string,
+  readyState: MediaStreamTrackState,
+  isRemote: boolean,
+  kind: MediaKind,
+  label: TrackLabel,
+  paused: boolean,
+  width?: number,
+  height?: number,
+  frameRate?: number,
+  aspectRatio?: number,
+  trackInboundStats?: TrackInboundStats,
+  trackOutboundStats?: TrackOutboundStats,
+};
+
+export type BaseTrackInfo = {
+  trackId: string,
+  readyState: MediaStreamTrackState,
+  kind: MediaKind,
+  label: TrackLabel,
+  paused: boolean,
+  width?: number,
+  height?: number,
+  frameRate?: number,
+  aspectRatio?: number,
+  trackOutboundStats?: TrackOutboundStats,
+};
+
+export type PeerInfo = {
+  id: string,
+  appData: Record<string, unknown>,
+  role: Role,
+  channelIds: string[],
+  appId: string,
+  uid?: string,
+  loginDate: Date,
+  connectionQuality: number,
+  tracks: PeerTrackInfo[],
+};
+
 export type UpdatePeerAppDataPayload = {
   peerId: string,
   appData: Record<string, unknown>,