@livedigital/client 2.26.0-stop-streams.2 → 2.26.0

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

@@ -1,381 +0,0 @@
-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;
-    };
-}
-export declare type IssueDetectorResult = IssuePayload[];
-export interface IssueDetector {
-    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",
-    CPU = "cpu",
-    Server = "server",
-    Stream = "stream"
-}
-export declare enum IssueReason {
-    OutboundNetworkQuality = "outbound-network-quality",
-    InboundNetworkQuality = "inbound-network-quality",
-    OutboundNetworkMediaLatency = "outbound-network-media-latency",
-    InboundNetworkMediaLatency = "inbound-network-media-latency",
-    NetworkMediaSyncFailure = "network-media-sync-failure",
-    OutboundNetworkThroughput = "outbound-network-throughput",
-    InboundNetworkThroughput = "inbound-network-throughput",
-    EncoderCPUThrottling = "encoder-cpu-throttling",
-    DecoderCPUThrottling = "decoder-cpu-throttling",
-    ServerIssue = "server-issue",
-    VideoCodecMismatchIssue = "codec-mismatch",
-    LowInboundMOS = "low-inbound-mean-opinion-score",
-    LowOutboundMOS = "low-outbound-mean-opinion-score"
-}
-export declare type IssuePayload = {
-    type: IssueType;
-    reason: IssueReason;
-    ssrc?: number;
-    iceCandidate?: string;
-    data?: number;
-    debug?: string;
-    trackIdentifier?: string;
-};
-export declare type DetectIssuesPayload = {
-    data: WebRTCStatsParsed;
-    ignoreSSRCList?: number[];
-};
-export declare type NetworkScore = number;
-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;
-};

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

@@ -1,46 +0,0 @@
-import { LogLevel, TrackLabel } from '../../../types/common';
-import Logger from '../../Logger';
-
-export type GetMediaStreamTrackParams = {
-  label: TrackLabel;
-  constraints: MediaStreamConstraints;
-};
-
-class MediaStreamTrackManager {
-  readonly #logger: Logger;
-
-  constructor(logLevel: LogLevel) {
-    this.#logger = new Logger({
-      namespace: 'MediaStreamTrackManager',
-      logLevel,
-    });
-  }
-
-  async createMediaStreamTrack({ label, constraints }: GetMediaStreamTrackParams): Promise<MediaStreamTrack> {
-    if (MediaStreamTrackManager.isDisplayMedia(label)) {
-      const [track] = await this.createDisplayMediaTracks(constraints);
-      return track;
-    }
-
-    const [track] = await this.createUserMediaTracks(constraints);
-    return track;
-  }
-
-  private static isDisplayMedia(label: TrackLabel): boolean {
-    return [TrackLabel.ScreenVideo, TrackLabel.ScreenAudio].includes(label);
-  }
-
-  async createUserMediaTracks(constraints: MediaStreamConstraints): Promise<MediaStreamTrack[]> {
-    const stream = await navigator.mediaDevices.getUserMedia(constraints);
-    this.#logger.debug('createUserMediaTracks() stream created', { streamId: stream.id });
-    return stream.getTracks();
-  }
-
-  async createDisplayMediaTracks(constraints: MediaStreamConstraints): Promise<MediaStreamTrack[]> {
-    const stream = await navigator.mediaDevices.getDisplayMedia(constraints);
-    this.#logger.debug('getDisplayMediaTracks() stream created', { streamId: stream.id });
-    return stream.getTracks();
-  }
-}
-
-export default MediaStreamTrackManager;

package/src/engine/wid/WebRTCIssueDetector.ts

@@ -1,136 +0,0 @@
-import { WebRTCIssueEmitter } from './WebRTCIssueEmitter';
-import {
-  CompositeStatsParser,
-  DetectIssuesPayload,
-  EventType,
-  IssueDetector,
-  IssuePayload,
-  NetworkScoresCalculator,
-  StatsReportItem,
-  WebRTCIssueDetectorConstructorParams,
-  WebRTCStatsParsed,
-  WIDWindow,
-} from './types';
-import { Logger } from '../../types/common';
-import PeriodicWebRTCStatsReporter from './lib/PeriodicWebRTCStatsReporter';
-
-class WebRTCIssueDetector {
-  readonly eventEmitter: WebRTCIssueEmitter;
-
-  #running = false;
-
-  private readonly detectors: IssueDetector[] = [];
-
-  private readonly networkScoresCalculator: NetworkScoresCalculator;
-
-  private readonly statsReporter: PeriodicWebRTCStatsReporter;
-
-  private readonly compositeStatsParser: CompositeStatsParser;
-
-  private readonly logger: Logger;
-
-  constructor(params: WebRTCIssueDetectorConstructorParams) {
-    this.eventEmitter = params.issueEmitter;
-
-    if (params.onIssues) {
-      this.eventEmitter.on(EventType.Issue, params.onIssues);
-    }
-
-    if (params.onNetworkScoresUpdated) {
-      this.eventEmitter.on(EventType.NetworkScoresUpdated, params.onNetworkScoresUpdated);
-    }
-
-    this.networkScoresCalculator = params.networkScoresCalculator;
-    this.detectors = params.detectors;
-    this.compositeStatsParser = params.compositeStatsParser;
-    this.statsReporter = params.statsReporter;
-    this.logger = params.logger;
-
-    (window as unknown as WIDWindow).wid = this;
-    this.wrapRTCPeerConnection();
-
-    this.statsReporter.on(PeriodicWebRTCStatsReporter.STATS_REPORT_READY_EVENT, (report: StatsReportItem) => {
-      this.detectIssues({
-        data: report.stats,
-        ignoreSSRCList: params.ignoreSSRCList,
-      });
-
-      this.calculateNetworkScores(report.stats);
-    });
-  }
-
-  public watchNewPeerConnections(): void {
-    if (this.#running) {
-      throw new Error('WebRTCIssueDetector is already started');
-    }
-
-    this.#running = true;
-    this.statsReporter.startReporting();
-  }
-
-  public stopWatchingNewPeerConnections(): void {
-    if (!this.#running) {
-      throw new Error('WebRTCIssueDetector is already stopped');
-    }
-
-    this.#running = false;
-    this.statsReporter.stopReporting();
-  }
-
-  public handleNewPeerConnection(pc: RTCPeerConnection): void {
-    if (!this.#running) {
-      this.logger.debug('Skip handling new peer connection. Detector is not running', pc);
-      return;
-    }
-
-    this.logger.debug('Handling new peer connection', pc);
-
-    this.compositeStatsParser.addPeerConnection({ pc });
-  }
-
-  private emitIssues(issues: IssuePayload[]): void {
-    this.eventEmitter.emit(EventType.Issue, issues);
-  }
-
-  private detectIssues({ data, ignoreSSRCList }: DetectIssuesPayload): void {
-    let issues = this.detectors.reduce<IssuePayload[]>((acc, detector) => [...acc, ...detector.detect(data)], []);
-    if (ignoreSSRCList?.length) {
-      issues = issues.filter((issue) => {
-        if (!issue.ssrc) {
-          return true;
-        }
-
-        return !ignoreSSRCList.includes(issue.ssrc);
-      });
-    }
-
-    if (issues.length > 0) {
-      this.emitIssues(issues);
-    }
-  }
-
-  private calculateNetworkScores(data: WebRTCStatsParsed): void {
-    const networkScores = this.networkScoresCalculator.calculate(data);
-    this.eventEmitter.emit(EventType.NetworkScoresUpdated, networkScores);
-  }
-
-  private wrapRTCPeerConnection(): void {
-    if (!window.RTCPeerConnection) {
-      return;
-    }
-
-    const OriginalRTCPeerConnection = window.RTCPeerConnection;
-    const onConnectionCreated = (pc: RTCPeerConnection) => this.handleNewPeerConnection(pc);
-
-    function WIDRTCPeerConnection(rtcConfig?: RTCConfiguration) {
-      const connection = new OriginalRTCPeerConnection(rtcConfig);
-      onConnectionCreated(connection);
-      return connection;
-    }
-
-    WIDRTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
-    (window.RTCPeerConnection as unknown) = WIDRTCPeerConnection;
-  }
-}
-
-export default WebRTCIssueDetector;

package/src/engine/wid/WebRTCIssueEmitter.ts

@@ -1,16 +0,0 @@
-import { EventEmitter } from 'events';
-import {
-  EventType,
-  EventPayload,
-  IssueDetectorResult,
-  NetworkScores,
-} from './types';
-
-export declare interface WebRTCIssueEmitter {
-  on(event: EventType.Issue, listener: (payload: IssueDetectorResult) => void): this;
-  on(event: EventType.NetworkScoresUpdated, listener: (payload: NetworkScores) => void): this;
-  emit(event: EventType.Issue, payload: EventPayload): boolean;
-  emit(event: EventType.NetworkScoresUpdated, payload: NetworkScores): boolean;
-}
-
-export class WebRTCIssueEmitter extends EventEmitter {}

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

@@ -1,57 +0,0 @@
-import {
-  IssueDetector,
-  IssueDetectorResult,
-  IssueReason,
-  IssueType,
-  WebRTCStatsParsed,
-} from '../types';
-
-class AvailableOutgoingBitrateIssueDetector implements IssueDetector {
-  #availableOutgoingBitrateTreshhold = 300000; // 300 kbit/s
-
-  detect(data: WebRTCStatsParsed): IssueDetectorResult {
-    const issues: IssueDetectorResult = [];
-    const { availableOutgoingBitrate } = data.connection;
-    if (availableOutgoingBitrate === undefined) {
-      // availableOutgoingBitrate is not measured yet
-      return issues;
-    }
-
-    const audioStreamsTotalTargetBitrate = data.audio.outbound
-      .reduce((totalBitrate, streamStat) => totalBitrate + streamStat.targetBitrate, 0);
-
-    const videoStreamsTotalBitrate = data.video.outbound
-      .reduce((totalBitrate, streamStat) => totalBitrate + streamStat.bitrate, 0);
-
-    if (!audioStreamsTotalTargetBitrate && !videoStreamsTotalBitrate) {
-      // there are no streams sending through this connection
-      return issues;
-    }
-
-    if (audioStreamsTotalTargetBitrate > availableOutgoingBitrate) {
-      issues.push({
-        type: IssueType.Network,
-        reason: IssueReason.OutboundNetworkThroughput,
-        debug: `availableOutgoingBitrate: ${availableOutgoingBitrate}`
-          + `, audioStreamsTotalTargetBitrate: ${audioStreamsTotalTargetBitrate}`,
-      });
-
-      return issues;
-    }
-
-    if (videoStreamsTotalBitrate > 0 && availableOutgoingBitrate < this.#availableOutgoingBitrateTreshhold) {
-      issues.push({
-        type: IssueType.Network,
-        reason: IssueReason.OutboundNetworkThroughput,
-        debug: `availableOutgoingBitrate: ${availableOutgoingBitrate}`
-          + `, videoStreamsTotalBitrate: ${videoStreamsTotalBitrate}`,
-      });
-
-      return issues;
-    }
-
-    return issues;
-  }
-}
-
-export default AvailableOutgoingBitrateIssueDetector;

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

@@ -1,65 +0,0 @@
-import {
-  IssueDetector,
-  IssueDetectorResult,
-  IssueReason,
-  IssueType,
-  WebRTCStatsParsed,
-} from '../types';
-
-class FramesDroppedIssueDetector implements IssueDetector {
-  #lastProcessedStats: { [connectionId: string]: WebRTCStatsParsed } = {};
-
-  #framesDroppedTreshold = 0.5;
-
-  detect(data: WebRTCStatsParsed): IssueDetectorResult {
-    const issues = this.processData(data);
-    this.#lastProcessedStats[data.connection.id] = data;
-    return issues;
-  }
-
-  private processData(data: WebRTCStatsParsed): IssueDetectorResult {
-    const streamsWithDroppedFrames = data.video.inbound.filter((stats) => stats.framesDropped > 0);
-    const issues: IssueDetectorResult = [];
-    const previousInboundRTPVideoStreamsStats = this.#lastProcessedStats[data.connection.id]?.video.inbound;
-
-    if (!previousInboundRTPVideoStreamsStats) {
-      return issues;
-    }
-
-    streamsWithDroppedFrames.forEach((streamStats) => {
-      const previousStreamStats = previousInboundRTPVideoStreamsStats.find((item) => item.ssrc === streamStats.ssrc);
-      if (!previousStreamStats) {
-        return;
-      }
-
-      if (streamStats.framesDropped === previousStreamStats.framesDropped) {
-        // stream is decoded correctly
-        return;
-      }
-
-      const deltaFramesReceived = streamStats.framesReceived - previousStreamStats.framesReceived;
-      const deltaFramesDecoded = streamStats.framesDecoded - previousStreamStats.framesDecoded;
-      const deltaFramesDropped = streamStats.framesDropped - previousStreamStats.framesDropped;
-      if (deltaFramesReceived === 0 && deltaFramesDecoded === 0) {
-        // looks like stream is stopped, skip checking framesDropped
-        return;
-      }
-
-      const framesDropped = deltaFramesDropped / deltaFramesReceived;
-      if (framesDropped >= this.#framesDroppedTreshold) {
-        // more than half of the received frames were dropped
-        issues.push({
-          type: IssueType.CPU,
-          reason: IssueReason.DecoderCPUThrottling,
-          ssrc: streamStats.ssrc,
-          debug: `framesDropped: ${Math.round(framesDropped * 100)}`
-            + ` , deltaFramesDropped: ${deltaFramesDropped}, deltaFramesReceived: ${deltaFramesReceived}`,
-        });
-      }
-    });
-
-    return issues;
-  }
-}
-
-export default FramesDroppedIssueDetector;