@livedigital/client 2.24.0-fix-pause-tracks.1 → 2.24.0

package/dist/engine/media/tracks/PeerTrack.d.ts

@@ -9,7 +9,6 @@ interface PeerTrackConstructor {
     consumer?: PeerConsumer;
     engine: Engine;
     isPaused: boolean;
-    isProducerPaused?: boolean;
     peerEventEmitter: EnhancedEventEmitter;
 }
 declare class PeerTrack {
@@ -39,6 +38,5 @@ declare class PeerTrack {
     private restartConsumer;
     private isInboundRTPStreamActive;
     private clearCheckStateTimeout;
-    setIsTrackProducerPaused(value: boolean): void;
 }
 export default PeerTrack;

package/dist/engine/wid/WebRTCIssueDetector.d.ts

@@ -2,16 +2,15 @@ import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
 import { WebRTCIssueDetectorConstructorParams } from './types';
 declare class WebRTCIssueDetector {
     #private;
-    private readonly webrtcStats;
-    private readonly webrtcStatsPeerId;
-    private readonly getStatsInterval;
+    readonly eventEmitter: WebRTCIssueEmitter;
     private readonly detectors;
     private readonly networkScoresCalculator;
-    readonly eventEmitter: WebRTCIssueEmitter;
+    private readonly statsReporter;
+    private readonly compositeStatsParser;
+    private readonly logger;
     constructor(params: WebRTCIssueDetectorConstructorParams);
     watchNewPeerConnections(): void;
     stopWatchingNewPeerConnections(): void;
-    resetWatchedPeerConnectionsList(): void;
     handleNewPeerConnection(pc: RTCPeerConnection): void;
     private emitIssues;
     private detectIssues;

package/dist/engine/wid/detectors/AvailableOutgoingBitrateIssueDetector.d.ts

@@ -1,7 +1,6 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class AvailableOutgoingBitrateIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
 }
 export default AvailableOutgoingBitrateIssueDetector;

package/dist/engine/wid/detectors/FramesDroppedIssueDetector.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class FramesDroppedIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
 }
 export default FramesDroppedIssueDetector;

package/dist/engine/wid/detectors/FramesEncodedSentIssueDetector.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class FramesEncodedSentIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
 }
 export default FramesEncodedSentIssueDetector;

package/dist/engine/wid/detectors/InboundNetworkIssueDetector.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class InboundNetworkIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
 }
 export default InboundNetworkIssueDetector;

package/dist/engine/wid/detectors/NetworkMediaSyncIssueDetector.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class NetworkMediaSyncIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
 }
 export default NetworkMediaSyncIssueDetector;

package/dist/engine/wid/detectors/OutboundNetworkIssueDetector.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class OutboundNetworkIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
 }
 export default OutboundNetworkIssueDetector;

package/dist/engine/wid/detectors/QualityLimitationsIssueDetector.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class QualityLimitationsIssueDetector implements IssueDetector {
     #private;
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
 }
 export default QualityLimitationsIssueDetector;

package/dist/engine/wid/detectors/VideoCodecMismatchDetector.d.ts

@@ -1,9 +1,8 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { IssueDetector, IssueDetectorResult } from '../types';
+import { IssueDetector, IssueDetectorResult, WebRTCStatsParsed } from '../types';
 declare class VideoCodecMismatchDetector implements IssueDetector {
     #private;
     readonly UNKNOWN_DECODER = "unknown";
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
     private processData;
     private setLastDecoderWithIssue;
     private hadLastDecoderWithIssue;

package/dist/engine/wid/lib/NetworkScoresCalculator.d.ts

@@ -1,8 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
-import { NetworkScores } from '../types';
-declare class NetworkScoresCalculator {
+import { NetworkScores, NetworkScoresCalculator as INetworkScoresCalculator, WebRTCStatsParsed } from '../types';
+declare class NetworkScoresCalculator implements INetworkScoresCalculator {
     #private;
-    calculate(data: WebRTCStatsEventData): NetworkScores;
+    calculate(data: WebRTCStatsParsed): NetworkScores;
     private calcucateOutboundScore;
     private calculateInboundScore;
     private calculateMOS;

package/dist/engine/wid/lib/PeriodicWebRTCStatsReporter.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CompositeStatsParser } from '../types';
+interface PeriodicWebRTCStatsReporterParams {
+    compositeStatsParser: CompositeStatsParser;
+    getStatsInterval?: number;
+}
+declare class PeriodicWebRTCStatsReporter extends EventEmitter {
+    static readonly STATS_REPORT_READY_EVENT = "stats-report-ready";
+    private isStopped;
+    private reportTimer;
+    private readonly getStatsInterval;
+    private readonly compositeStatsParser;
+    constructor(params: PeriodicWebRTCStatsReporterParams);
+    get isRunning(): boolean;
+    startReporting(): void;
+    stopReporting(): void;
+    private parseReports;
+}
+export default PeriodicWebRTCStatsReporter;

package/dist/engine/wid/lib/parser/CompositeRTCStatsParser.d.ts

@@ -0,0 +1,22 @@
+import { CompositeStatsParser, ConnectionInfo, StatsParser, StatsReportItem } from '../../types';
+export interface AddConnectionPayload {
+    id?: string;
+    pc: RTCPeerConnection;
+}
+export interface RemoveConnectionPayload {
+    pc: RTCPeerConnection;
+}
+interface CompositeRTCStatsParserParams {
+    statsParser: StatsParser;
+}
+declare class CompositeRTCStatsParser implements CompositeStatsParser {
+    private readonly connections;
+    private readonly statsParser;
+    constructor(params: CompositeRTCStatsParserParams);
+    listConnections(): ConnectionInfo[];
+    addPeerConnection(payload: AddConnectionPayload): void;
+    removePeerConnection(payload: RemoveConnectionPayload): void;
+    parse(): Promise<StatsReportItem[]>;
+    private removeConnectionsByIndexes;
+}
+export default CompositeRTCStatsParser;

package/dist/engine/wid/lib/parser/RTCStatsParser.d.ts

@@ -0,0 +1,20 @@
+import { ConnectionInfo, StatsParser, StatsReportItem } from '../../types';
+import { Logger } from '../../../../types/common';
+interface WebRTCStatsParserParams {
+    logger: Logger;
+}
+declare class RTCStatsParser implements StatsParser {
+    private readonly prevStats;
+    private readonly allowedReportTypes;
+    private readonly logger;
+    constructor(params: WebRTCStatsParserParams);
+    parse(connection: ConnectionInfo): Promise<StatsReportItem | undefined>;
+    private getConnectionStats;
+    private mapReportsStats;
+    private updateMappedStatsWithReportItemData;
+    private getMediaType;
+    private propagateStatsWithRateValues;
+    private mapConnectionStatsIfNecessary;
+    private prepareConnectionStats;
+}
+export default RTCStatsParser;

package/dist/engine/wid/lib/parser/utils.d.ts

@@ -0,0 +1,7 @@
+interface WithTS {
+    timestamp: number;
+}
+export declare const checkIsConnectionClosed: (pc: RTCPeerConnection) => boolean;
+export declare const calcValueRate: <T extends WithTS>(stats: T, prevStats: T | undefined, statPropName: keyof T) => number;
+export declare const calcBitrate: <T extends WithTS>(stats: T, prevStats: T | undefined, statPropName: keyof T) => number;
+export {};

package/dist/engine/wid/types.d.ts

@@ -1,4 +1,7 @@
-import { WebRTCStatsEventData } from '@peermetrics/webrtc-stats';
+import { Logger } from '../../types/common';
+import PeriodicWebRTCStatsReporter from './lib/PeriodicWebRTCStatsReporter';
+import { AddConnectionPayload } from './lib/parser/CompositeRTCStatsParser';
+import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
 export interface WIDWindow {
     wid: {
         handleNewPeerConnection(pc: RTCPeerConnection): void;
@@ -6,17 +9,43 @@ export interface WIDWindow {
 }
 export declare type IssueDetectorResult = IssuePayload[];
 export interface IssueDetector {
-    detect(data: WebRTCStatsEventData): IssueDetectorResult;
+    detect(data: WebRTCStatsParsed): IssueDetectorResult;
+}
+export interface NetworkScoresCalculator {
+    calculate(data: WebRTCStatsParsed): NetworkScores;
 }
 export declare enum EventType {
     Issue = "issue",
     NetworkScoresUpdated = "network-scores-updated"
 }
 export declare type EventPayload = IssueDetectorResult;
+export interface StatsReportItem {
+    id: string;
+    stats: WebRTCStatsParsed;
+    timeTaken: number;
+}
+export interface ConnectionInfo {
+    id: string;
+    pc: RTCPeerConnection;
+}
+export interface CompositeStatsParser {
+    addPeerConnection: (payload: AddConnectionPayload) => void;
+    parse: () => Promise<StatsReportItem[]>;
+}
+export interface StatsParser {
+    parse: (info: ConnectionInfo) => Promise<StatsReportItem | undefined>;
+}
 export declare type WebRTCIssueDetectorConstructorParams = {
+    issueEmitter: WebRTCIssueEmitter;
+    networkScoresCalculator: NetworkScoresCalculator;
+    detectors: IssueDetector[];
+    compositeStatsParser: CompositeStatsParser;
+    statsReporter: PeriodicWebRTCStatsReporter;
+    logger: Logger;
     onIssues?: (payload: IssueDetectorResult) => void;
     onNetworkScoresUpdated?: (payload: NetworkScores) => void;
     ignoreSSRCList?: number[];
+    getStatsInterval?: number;
 };
 export declare enum IssueType {
     Network = "network",
@@ -49,7 +78,7 @@ export declare type IssuePayload = {
     trackIdentifier?: string;
 };
 export declare type DetectIssuesPayload = {
-    data: WebRTCStatsEventData;
+    data: WebRTCStatsParsed;
     ignoreSSRCList?: number[];
 };
 export declare type NetworkScore = number;
@@ -57,3 +86,296 @@ export declare type NetworkScores = {
     outbound?: NetworkScore;
     inbound?: NetworkScore;
 };
+export declare type ParsedInboundAudioStreamStats = {
+    audioLevel: number;
+    bitrate: number;
+    bytesReceived: number;
+    clockRate: number;
+    codecId: string;
+    concealedSamples: number;
+    concealmentEvents: number;
+    fecPacketsDiscarded: number;
+    fecPacketsReceived: number;
+    headerBytesReceived: number;
+    id: string;
+    insertedSamplesForDeceleration: number;
+    jitter: number;
+    jitterBufferDelay: number;
+    jitterBufferEmittedCount: number;
+    kind: 'audio';
+    lastPacketReceivedTimestamp: number;
+    mediaType: string;
+    mimeType: string;
+    packetRate: number;
+    packetsDiscarded: number;
+    packetsLost: number;
+    packetsReceived: number;
+    payloadType: number;
+    remoteId: string;
+    removedSamplesForAcceleration: number;
+    silentConcealedSamples: number;
+    ssrc: number;
+    timestamp: number;
+    totalAudioEnergy: number;
+    totalSamplesDuration: number;
+    totalSamplesReceived: number;
+    track: {
+        audioLevel: number;
+        concealedSamples: number;
+        concealmentEvents: number;
+        detached: boolean;
+        ended: boolean;
+        id: string;
+        insertedSamplesForDeceleration: number;
+        jitterBufferDelay: number;
+        jitterBufferEmittedCount: number;
+        kind: 'audio';
+        remoteSource: boolean;
+        removedSamplesForAcceleration: number;
+        silentConcealedSamples: number;
+        timestamp: number;
+        totalAudioEnergy: number;
+        totalSamplesDuration: number;
+        totalSamplesReceived: number;
+        trackIdentifier: string;
+        type: string;
+    };
+    trackId: string;
+    transportId: string;
+};
+export declare type ParsedOutboundAudioStreamStats = {
+    bitrate: number;
+    bytesSent: number;
+    clockRate: number;
+    codecId: string;
+    headerBytesSent: number;
+    id: string;
+    kind: string;
+    mediaSourceId: string;
+    mediaType: string;
+    mimeType: string;
+    nackCount: number;
+    packetRate: number;
+    packetsSent: number;
+    payloadType: number;
+    remoteId: string;
+    retransmittedBytesSent: number;
+    retransmittedPacketsSent: number;
+    ssrc: number;
+    timestamp: number;
+    targetBitrate: number;
+    track: {
+        audioLevel: number;
+        echoReturnLoss: number;
+        echoReturnLossEnhancement: number;
+        id: string;
+        kind: string;
+        timestamp: number;
+        totalAudioEnergy: number;
+        totalSamplesDuration: number;
+        trackIdentifier: string;
+        type: string;
+    };
+    trackId: string;
+    transportId: string;
+};
+export declare type ParsedInboundVideoStreamStats = {
+    bitrate: number;
+    bytesReceived: number;
+    clockRate: number;
+    codecId: string;
+    decoderImplementation: string;
+    firCount: number;
+    frameHeight: number;
+    frameWidth: number;
+    framesDecoded: number;
+    framesDropped: number;
+    framesPerSecond: number;
+    framesReceived: number;
+    headerBytesReceived: number;
+    id: string;
+    jitter: number;
+    jitterBufferDelay: number;
+    jitterBufferEmittedCount: number;
+    keyFramesDecoded: number;
+    kind: 'video';
+    mediaType: string;
+    mimeType: string;
+    nackCount: number;
+    packetRate: number;
+    packetsLost: number;
+    packetsReceived: number;
+    payloadType: number;
+    pliCount: number;
+    ssrc: number;
+    timestamp: number;
+    totalDecodeTime: number;
+    totalInterFrameDelay: number;
+    totalSquaredInterFrameDelay: number;
+    track: {
+        detached: boolean;
+        ended: boolean;
+        frameHeight: number;
+        frameWidth: number;
+        framesDecoded: number;
+        framesDropped: number;
+        framesReceived: number;
+        id: string;
+        jitterBufferDelay: number;
+        jitterBufferEmittedCount: number;
+        kind: 'video';
+        remoteSource: boolean;
+        timestamp: number;
+        trackIdentifier: string;
+        type: string;
+    };
+    trackId: string;
+    transportId: string;
+};
+export declare type ParsedOutboundVideoStreamStats = {
+    bitrate: number;
+    bytesSent: number;
+    clockRate: number;
+    codecId: string;
+    encoderImplementation: string;
+    firCount: number;
+    frameHeight: number;
+    frameWidth: number;
+    framesEncoded: number;
+    framesPerSecond: number;
+    framesSent: number;
+    headerBytesSent: number;
+    hugeFramesSent: number;
+    id: string;
+    keyFramesEncoded: number;
+    kind: string;
+    mediaSourceId: string;
+    mediaType: string;
+    mimeType: string;
+    nackCount: number;
+    packetRate: number;
+    packetsSent: number;
+    payloadType: number;
+    pliCount: number;
+    qpSum: number;
+    qualityLimitationDurations: {
+        other: number;
+        cpu: number;
+        bandwidth: number;
+        none: number;
+    };
+    qualityLimitationReason: 'none' | 'bandwidth' | 'cpu' | 'other';
+    qualityLimitationResolutionChanges: number;
+    remoteId: string;
+    retransmittedBytesSent: number;
+    retransmittedPacketsSent: number;
+    rid: string;
+    ssrc: number;
+    timestamp: number;
+    totalEncodeTime: number;
+    totalEncodedBytesTarget: number;
+    totalPacketSendDelay: number;
+    track: {
+        id: string;
+        frames: number;
+        framesPerSecond: number;
+        height: number;
+        timestamp: number;
+        type: string;
+        trackIdentifier: string;
+        kind: string;
+        width: number;
+    };
+    trackId: string;
+    transportId: string;
+    type: string;
+};
+export declare type ParsedConnectionStats = {
+    availableOutgoingBitrate: number;
+    bytesReceived: number;
+    bytesSent: number;
+    currentRoundTripTime: number;
+    id: string;
+    transportId: string;
+    packetsReceived: number;
+    packetsSent: number;
+    state: string;
+    totalRoundTripTime: number;
+    type: string;
+    local: IceCandidateConnectionStats;
+    remote: IceCandidateConnectionStats;
+};
+export declare type IceCandidateConnectionStats = {
+    address: string;
+    candidateType: string;
+    id: string;
+    ip: string;
+    isRemote: boolean;
+    networkType?: string;
+    port: number;
+    priority: number;
+    protocol: 'udp' | 'tcp';
+    timestamp: number;
+    transportId: string;
+    type: 'local-candidate' | 'remote-candidate';
+};
+export declare type ParsedRemoteInboundStreamStats = {
+    clockRate: number;
+    codecId: string;
+    fractionLost: number;
+    id: string;
+    jitter: number;
+    kind: string;
+    localId: string;
+    mimeType: string;
+    packetsLost: number;
+    payloadType: number;
+    roundTripTime: number;
+    roundTripTimeMeasurements: number;
+    ssrc: number;
+    timestamp: number;
+    totalRoundTripTime: number;
+    transportId: string;
+    type: string;
+};
+export declare type ParsedRemoteOutboundStreamStats = {
+    bytesSent: number;
+    clockRate: number;
+    codecId: string;
+    id: string;
+    kind: string;
+    localId: string;
+    mimeType: string;
+    packetsSent: number;
+    payloadType: number;
+    remoteTimestamp: number;
+    reportsSent: number;
+    roundTripTimeMeasurements: number;
+    ssrc: number;
+    timestamp: number;
+    totalRoundTripTime: number;
+    transportId: string;
+    type: string;
+};
+export declare type RemoteParsedStats = {
+    video: {
+        inbound: ParsedRemoteInboundStreamStats[];
+        outbound: ParsedRemoteOutboundStreamStats[];
+    };
+    audio: {
+        inbound: ParsedRemoteInboundStreamStats[];
+        outbound: ParsedRemoteOutboundStreamStats[];
+    };
+};
+export declare type WebRTCStatsParsed = {
+    audio: {
+        inbound: ParsedInboundAudioStreamStats[];
+        outbound: ParsedOutboundAudioStreamStats[];
+    };
+    video: {
+        inbound: ParsedInboundVideoStreamStats[];
+        outbound: ParsedOutboundVideoStreamStats[];
+    };
+    connection: ParsedConnectionStats;
+    remote: RemoteParsedStats;
+};