@observertc/observer-js 0.42.9 → 1.0.1-57a1811.0

package/src/ObservedInboundRtp.ts

@@ -0,0 +1,205 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { InboundRtpStats } from './schema/ClientSample';
+
+export class ObservedInboundRtp implements InboundRtpStats {
+	public appData?: Record<string, unknown>;
+
+	private _visited = false;
+
+	transportId?: string | undefined;
+	codecId?: string | undefined;
+	packetsReceived?: number | undefined;
+	packetsLost?: number | undefined;
+	mid?: string | undefined;
+	remoteId?: string | undefined;
+	framesDecoded?: number | undefined;
+	keyFramesDecoded?: number | undefined;
+	framesRendered?: number | undefined;
+	framesDropped?: number | undefined;
+	frameWidth?: number | undefined;
+	frameHeight?: number | undefined;
+	framesPerSecond?: number | undefined;
+	qpSum?: number | undefined;
+	totalDecodeTime?: number | undefined;
+	totalInterFrameDelay?: number | undefined;
+	totalSquaredInterFrameDelay?: number | undefined;
+	pauseCount?: number | undefined;
+	totalPausesDuration?: number | undefined;
+	freezeCount?: number | undefined;
+	totalFreezesDuration?: number | undefined;
+	lastPacketReceivedTimestamp?: number | undefined;
+	headerBytesReceived?: number | undefined;
+	packetsDiscarded?: number | undefined;
+	fecBytesReceived?: number | undefined;
+	fecPacketsReceived?: number | undefined;
+	fecPacketsDiscarded?: number | undefined;
+	bytesReceived?: number | undefined;
+	nackCount?: number | undefined;
+	firCount?: number | undefined;
+	pliCount?: number | undefined;
+	totalProcessingDelay?: number | undefined;
+	estimatedPlayoutTimestamp?: number | undefined;
+	jitterBufferDelay?: number | undefined;
+	jitterBufferTargetDelay?: number | undefined;
+	jitterBufferEmittedCount?: number | undefined;
+	jitterBufferMinimumDelay?: number | undefined;
+	totalSamplesReceived?: number | undefined;
+	concealedSamples?: number | undefined;
+	silentConcealedSamples?: number | undefined;
+	concealmentEvents?: number | undefined;
+	insertedSamplesForDeceleration?: number | undefined;
+	removedSamplesForAcceleration?: number | undefined;
+	audioLevel?: number | undefined;
+	totalAudioEnergy?: number | undefined;
+	totalSamplesDuration?: number | undefined;
+	framesReceived?: number | undefined;
+	decoderImplementation?: string | undefined;
+	playoutId?: string | undefined;
+	powerEfficientDecoder?: boolean | undefined;
+	framesAssembledFromMultiplePackets?: number | undefined;
+	totalAssemblyTime?: number | undefined;
+	retransmittedPacketsReceived?: number | undefined;
+	retransmittedBytesReceived?: number | undefined;
+	rtxSsrc?: number | undefined;
+	fecSsrc?: number | undefined;
+	totalCorruptionProbability?: number | undefined;
+	totalSquaredCorruptionProbability?: number | undefined;
+	corruptionMeasurements?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+	jitter?: number | undefined;
+	
+	public bitrate = 0;
+	public fractionLost?: number;
+	public bitPerPixel = 0;
+
+	public deltaLostPackets = 0;
+	public deltaReceivedPackets = 0;
+	public deltaBytesReceived = 0;
+	public deltaReceivedSamples = 0;
+	public deltaSilentConcealedSamples = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public ssrc: number,
+		public kind: MediaKind,
+		public trackIdentifier: string,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getRemoteOutboundRtp() {
+		return this._peerConnection.observedRemoteOutboundRtps.get(this.ssrc);
+	}
+
+	public getIceTransport() {
+		return this._peerConnection.observedIceTransports.get(this.transportId ?? '');
+	}
+
+	public getCodec() {
+		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
+	}
+
+	public getMediaPlayout() {
+		return this._peerConnection.observedMediaPlayouts.get(this.playoutId ?? '');
+	}
+
+	public getTrack() {
+		return this._peerConnection.observedInboundTracks.get(this.trackIdentifier);
+	}
+
+	public update(stats: InboundRtpStats) {
+		this._visited = true;
+		this.deltaBytesReceived = 0;
+		this.deltaLostPackets = 0;
+		this.deltaReceivedPackets = 0;
+		this.deltaReceivedSamples = 0;
+		this.deltaSilentConcealedSamples = 0;
+		this.bitrate = 0;
+		this.jitter = undefined;
+		this.fractionLost = undefined;
+		this.bitPerPixel = 0;
+
+		const elapsedTimeInMs = stats.timestamp - this.timestamp;
+
+		if (elapsedTimeInMs) {
+			// update metrics here
+			if (this.bytesReceived && stats.bytesReceived && this.bytesReceived < stats.bytesReceived) {
+				this.bitrate = ((stats.bytesReceived - (this.bytesReceived ?? 0)) * 8) / elapsedTimeInMs;
+			}
+			if (this.packetsLost && stats.packetsLost && this.packetsLost < stats.packetsLost) {
+				this.deltaLostPackets = stats.packetsLost - this.packetsLost;
+			}
+			if (this.packetsReceived && stats.packetsReceived && this.packetsReceived < stats.packetsReceived) {
+				this.deltaReceivedPackets = stats.packetsReceived - this.packetsReceived;
+			}
+			if (this.totalSamplesReceived && stats.totalSamplesReceived && this.totalSamplesReceived < stats.totalSamplesReceived) {
+				this.deltaReceivedSamples = stats.totalSamplesReceived - this.totalSamplesReceived;
+			}
+			if (this.silentConcealedSamples && stats.silentConcealedSamples && this.silentConcealedSamples < stats.silentConcealedSamples) {
+				this.deltaSilentConcealedSamples = stats.silentConcealedSamples - this.silentConcealedSamples;
+			}
+			if (stats.bytesReceived && this.framesReceived && stats.framesReceived && this.framesReceived < stats.framesReceived) {
+				this.bitPerPixel = (stats.bytesReceived - (this.bytesReceived ?? 0)) / (stats.framesReceived - this.framesReceived);
+			}
+			if (this.deltaLostPackets && this.deltaReceivedPackets) {
+				this.fractionLost = this.deltaLostPackets / (this.deltaLostPackets + this.deltaReceivedPackets);
+			}
+		}
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.codecId = stats.codecId;
+		this.packetsReceived = stats.packetsReceived;
+		this.packetsLost = stats.packetsLost;
+		this.mid = stats.mid;
+		this.remoteId = stats.remoteId;
+		this.framesDecoded = stats.framesDecoded;
+		this.keyFramesDecoded = stats.keyFramesDecoded;
+		this.framesRendered = stats.framesRendered;
+		this.framesDropped = stats.framesDropped;
+		this.frameWidth = stats.frameWidth;
+		this.frameHeight = stats.frameHeight;
+		this.framesPerSecond = stats.framesPerSecond;
+		this.qpSum = stats.qpSum;
+		this.totalDecodeTime = stats.totalDecodeTime;
+		this.totalInterFrameDelay = stats.totalInterFrameDelay;
+		this.totalSquaredInterFrameDelay = stats.totalSquaredInterFrameDelay;
+		this.pauseCount = stats.pauseCount;
+		this.totalPausesDuration = stats.totalPausesDuration;
+		this.freezeCount = stats.freezeCount;
+		this.totalFreezesDuration = stats.totalFreezesDuration;
+		this.lastPacketReceivedTimestamp = stats.lastPacketReceivedTimestamp;
+		this.headerBytesReceived = stats.headerBytesReceived;
+		this.packetsDiscarded = stats.packetsDiscarded;
+		this.fecBytesReceived = stats.fecBytesReceived;
+		this.fecPacketsReceived = stats.fecPacketsReceived;
+		this.fecPacketsDiscarded = stats.fecPacketsDiscarded;
+		this.bytesReceived = stats.bytesReceived;
+		this.nackCount = stats.nackCount;
+		this.firCount = stats.firCount;
+		this.pliCount = stats.pliCount;
+		this.totalProcessingDelay = stats.totalProcessingDelay;
+		this.estimatedPlayoutTimestamp = stats.estimatedPlayoutTimestamp;
+		this.jitterBufferDelay = stats.jitterBufferDelay;
+		this.jitterBufferTargetDelay = stats.jitterBufferTargetDelay;
+		this.jitterBufferEmittedCount = stats.jitterBufferEmittedCount;
+		this.jitterBufferMinimumDelay = stats.jitterBufferMinimumDelay;
+		this.totalSamplesReceived = stats.totalSamplesReceived;
+		this.concealedSamples = stats.concealedSamples;
+		this.silentConcealedSamples = stats.silentConcealedSamples;
+		this.concealmentEvents = stats.concealmentEvents;
+	}
+}

package/src/ObservedInboundTrack.ts

@@ -0,0 +1,70 @@
+import { CalculatedScore } from './scores/CalculatedScore';
+import { MediaKind } from './common/types';
+import { InboundTrackSample } from './schema/ClientSample';
+import { Detectors } from './detectors/Detectors';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedInboundRtp } from './ObservedInboundRtp';
+import { ObservedMediaPlayout } from './ObservedMediaPlayout';
+
+export class ObservedInboundTrack implements InboundTrackSample {
+	public readonly detectors: Detectors;
+	public readonly calculatedScore: CalculatedScore = {
+		weight: 1,
+		value: undefined,
+	};
+	public appData?: Record<string, unknown>;
+
+	private _visited = false;
+
+	attachments?: Record<string, unknown> | undefined;
+
+	constructor(
+		public timestamp: number,
+		public readonly id: string,
+		public readonly kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection,
+		private readonly _inboundRtp?: ObservedInboundRtp,
+		private readonly _mediaPlayout?: ObservedMediaPlayout,
+	) {
+		this.detectors = new Detectors();
+	}
+
+	public get score() { 
+		return this.calculatedScore.value; 
+	}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getInboundRtp() {
+		return this._inboundRtp;
+	}
+
+	public getMediaPlayout() {
+		return this._mediaPlayout;
+	}
+
+	public getRemoteOutboundTrack() {
+		return this._peerConnection.client.call.remoteTrackResolver?.resolveRemoteOutboundTrack(this);
+	}
+
+	public update(stats: InboundTrackSample): void {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.calculatedScore.value = stats.score;
+		this.attachments = stats.attachments;
+	
+		this.detectors.update();
+	}
+	
+}

package/src/ObservedMediaPlayout.ts

@@ -0,0 +1,49 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { MediaPlayoutStats } from './schema/ClientSample';
+
+export class ObservedMediaPlayout implements MediaPlayoutStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	synthesizedSamplesDuration?: number | undefined;
+	synthesizedSamplesEvents?: number | undefined;
+	totalSamplesDuration?: number | undefined;
+	totalPlayoutDelay?: number | undefined;
+	totalSamplesCount?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	
+
+	public update(stats: MediaPlayoutStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.synthesizedSamplesDuration = stats.synthesizedSamplesDuration;
+		this.synthesizedSamplesEvents = stats.synthesizedSamplesEvents;
+		this.totalSamplesDuration = stats.totalSamplesDuration;
+		this.totalPlayoutDelay = stats.totalPlayoutDelay;
+		this.totalSamplesCount = stats.totalSamplesCount;
+		this.attachments = stats.attachments;
+		
+	}
+}

package/src/ObservedMediaSource.ts

@@ -0,0 +1,60 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { MediaSourceStats } from './schema/ClientSample';
+
+export class ObservedMediaSource implements MediaSourceStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	trackIdentifier?: string | undefined;
+	audioLevel?: number | undefined;
+	totalAudioEnergy?: number | undefined;
+	totalSamplesDuration?: number | undefined;
+	echoReturnLoss?: number | undefined;
+	echoReturnLossEnhancement?: number | undefined;
+	width?: number | undefined;
+	height?: number | undefined;
+	frames?: number | undefined;
+	framesPerSecond?: number | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection
+	) {}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getTrack() {
+		return this._peerConnection.observedOutboundTracks.get(this.trackIdentifier ?? '');
+	}
+
+	public update(stats: MediaSourceStats) {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.trackIdentifier = stats.trackIdentifier;
+		this.audioLevel = stats.audioLevel;
+		this.totalAudioEnergy = stats.totalAudioEnergy;
+		this.totalSamplesDuration = stats.totalSamplesDuration;
+		this.echoReturnLoss = stats.echoReturnLoss;
+		this.echoReturnLossEnhancement = stats.echoReturnLossEnhancement;
+		this.width = stats.width;
+		this.height = stats.height;
+		this.frames = stats.frames;
+		this.framesPerSecond = stats.framesPerSecond;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedOutboundRtp.ts

@@ -0,0 +1,156 @@
+import { MediaKind } from './common/types';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { OutboundRtpStats, QualityLimitationDurations } from './schema/ClientSample';
+
+export class ObservedOutboundRtp implements OutboundRtpStats {
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+
+	transportId?: string | undefined;
+	codecId?: string | undefined;
+	packetsSent?: number | undefined;
+	bytesSent?: number | undefined;
+	mid?: string | undefined;
+	mediaSourceId?: string | undefined;
+	remoteId?: string | undefined;
+	rid?: string | undefined;
+	headerBytesSent?: number | undefined;
+	retransmittedPacketsSent?: number | undefined;
+	retransmittedBytesSent?: number | undefined;
+	rtxSsrc?: number | undefined;
+	targetBitrate?: number | undefined;
+	totalEncodedBytesTarget?: number | undefined;
+	frameWidth?: number | undefined;
+	frameHeight?: number | undefined;
+	framesPerSecond?: number | undefined;
+	framesSent?: number | undefined;
+	hugeFramesSent?: number | undefined;
+	framesEncoded?: number | undefined;
+	keyFramesEncoded?: number | undefined;
+	qpSum?: number | undefined;
+	totalEncodeTime?: number | undefined;
+	totalPacketSendDelay?: number | undefined;
+	qualityLimitationReason?: string | undefined;
+	qualityLimitationResolutionChanges?: number | undefined;
+	nackCount?: number | undefined;
+	firCount?: number | undefined;
+	pliCount?: number | undefined;
+	encoderImplementation?: string | undefined;
+	powerEfficientEncoder?: boolean | undefined;
+	active?: boolean | undefined;
+	scalabilityMode?: string | undefined;
+	qualityLimitationDurations?: QualityLimitationDurations | undefined;
+	attachments?: Record<string, unknown> | undefined;
+
+	// derived fields
+	public bitrate = 0;
+	public payloadBitrate = 0;
+	public packetRate = 0;
+	public bitPerPixel = 0;
+	
+	public deltaPacketsSent = 0;
+	public deltaBytesSent = 0;
+
+	public constructor(
+		public timestamp: number,
+		public id: string,
+		public ssrc: number,
+		public kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection,
+	) {
+	}
+
+	public get visited() {
+		const visited = this._visited;
+	
+		this._visited = false;
+	
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getRemoteInboundRtp() {
+		return this._peerConnection.observedRemoteInboundRtps.get(this.ssrc);
+	}
+
+	public getCodec() {
+		return this._peerConnection.observedCodecs.get(this.codecId ?? '');
+	}
+
+	public getMediaSource() {
+		return this._peerConnection.observedMediaSources.get(this.mediaSourceId ?? '');
+	}
+
+	public getTrack() {
+		return this.getMediaSource()?.getTrack();
+	}
+
+	public update(stats: OutboundRtpStats) {
+		this._visited = true;
+		this.bitPerPixel = 0;
+		this.bitrate = 0;
+		this.payloadBitrate = 0;
+		this.packetRate = 0;
+		this.deltaPacketsSent = 0;
+		this.deltaBytesSent = 0;
+
+		const elapsedTimeInMs = stats.timestamp - this.timestamp;
+
+		if (elapsedTimeInMs) {
+			if (stats.packetsSent !== undefined && this.packetsSent !== undefined) {
+				this.deltaPacketsSent = stats.packetsSent - this.packetsSent;
+				this.packetRate = this.deltaPacketsSent / (elapsedTimeInMs / 1000);
+			}
+			if (stats.bytesSent !== undefined && this.bytesSent !== undefined) {
+				this.deltaBytesSent = stats.bytesSent - this.bytesSent;
+				this.bitrate = (this.deltaBytesSent * 8) / (elapsedTimeInMs / 1000);
+			}
+			if (stats.headerBytesSent !== undefined && this.headerBytesSent !== undefined) {
+				this.payloadBitrate = ((this.deltaBytesSent ?? 0 - (stats.headerBytesSent - this.headerBytesSent)) * 8) / (elapsedTimeInMs / 1000);
+			}
+			if (this.framesSent !== undefined && stats.framesSent !== undefined) {
+				this.bitPerPixel = this.deltaBytesSent ? (this.deltaBytesSent * 8) / (this.framesSent - stats.framesSent) : 0;
+			}
+		}
+
+		this.timestamp = stats.timestamp;
+		this.transportId = stats.transportId;
+		this.codecId = stats.codecId;
+		this.packetsSent = stats.packetsSent;
+		this.bytesSent = stats.bytesSent;
+		this.mid = stats.mid;
+		this.mediaSourceId = stats.mediaSourceId;
+		this.remoteId = stats.remoteId;
+		this.rid = stats.rid;
+		this.headerBytesSent = stats.headerBytesSent;
+		this.retransmittedPacketsSent = stats.retransmittedPacketsSent;
+		this.retransmittedBytesSent = stats.retransmittedBytesSent;
+		this.rtxSsrc = stats.rtxSsrc;
+		this.targetBitrate = stats.targetBitrate;
+		this.totalEncodedBytesTarget = stats.totalEncodedBytesTarget;
+		this.frameWidth = stats.frameWidth;
+		this.frameHeight = stats.frameHeight;
+		this.framesPerSecond = stats.framesPerSecond;
+		this.framesSent = stats.framesSent;
+		this.hugeFramesSent = stats.hugeFramesSent;
+		this.framesEncoded = stats.framesEncoded;
+		this.keyFramesEncoded = stats.keyFramesEncoded;
+		this.qpSum = stats.qpSum;
+		this.totalEncodeTime = stats.totalEncodeTime;
+		this.totalPacketSendDelay = stats.totalPacketSendDelay;
+		this.qualityLimitationReason = stats.qualityLimitationReason;
+		this.qualityLimitationResolutionChanges = stats.qualityLimitationResolutionChanges;
+		this.nackCount = stats.nackCount;
+		this.firCount = stats.firCount;
+		this.pliCount = stats.pliCount;
+		this.encoderImplementation = stats.encoderImplementation;
+		this.powerEfficientEncoder = stats.powerEfficientEncoder;
+		this.active = stats.active;
+		this.scalabilityMode = stats.scalabilityMode;
+		this.qualityLimitationDurations = stats.qualityLimitationDurations;
+		this.attachments = stats.attachments;
+	}
+}

package/src/ObservedOutboundTrack.ts

@@ -0,0 +1,69 @@
+import { CalculatedScore } from './scores/CalculatedScore';
+import { MediaKind } from './common/types';
+import { OutboundTrackSample } from './schema/ClientSample';
+import { Detectors } from './detectors/Detectors';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { ObservedOutboundRtp } from './ObservedOutboundRtp';
+import { ObservedMediaSource } from './ObservedMediaSource';
+
+export class ObservedOutboundTrack implements OutboundTrackSample {
+	public readonly detectors: Detectors;
+	private _visited = false;
+	public appData?: Record<string, unknown>;
+	public readonly calculatedScore: CalculatedScore = {
+		weight: 1,
+		value: undefined,
+	};
+
+	attachments?: Record<string, unknown> | undefined;
+
+	constructor(
+		public timestamp: number,
+		public readonly id: string,
+		public readonly kind: MediaKind,
+		private readonly _peerConnection: ObservedPeerConnection,
+		private readonly _outboundRtps?: ObservedOutboundRtp[],
+		private readonly _mediaSource?: ObservedMediaSource,
+	) {
+		this.detectors = new Detectors();
+	}
+
+	public get score() { 
+		return this.calculatedScore.value; 
+	}
+
+	public get visited() {
+		const visited = this._visited;
+
+		this._visited = false;
+
+		return visited;
+	}
+
+	public getPeerConnection() {
+		return this._peerConnection;
+	}
+
+	public getOutboundRtps() {
+		return this._outboundRtps;
+	}
+
+	public getMediaSource() {
+		return this._mediaSource;
+	}
+
+	public getRemoteInboundTracks() {
+		return this._peerConnection.client.call.remoteTrackResolver?.resolveRemoteInboundTracks(this);
+	}
+
+	public update(stats: OutboundTrackSample): void {
+		this._visited = true;
+
+		this.timestamp = stats.timestamp;
+		this.calculatedScore.value = stats.score;
+		this.attachments = stats.attachments;
+
+		this.detectors.update();
+	}
+	
+}