@observertc/observer-js 0.42.8 → 1.0.0-beta.1

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,74 @@
+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,
+	};
+
+	public addedAt?: number | undefined;
+	public removedAt?: number | undefined;
+
+	public muted?: boolean;
+
+	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();
+	}
+	
+}