@reactoo/watchtogether-sdk-js 2.6.68 → 2.6.69

package/src/modules/wt-room.js

@@ -2,7 +2,7 @@
 
 import adapter from 'webrtc-adapter';
 import emitter from './wt-emitter';
-import {decodeJanusDisplay, generateUUID, wait} from "./wt-utils";
+import {decodeJanusDisplay, generateUUID, maxJitter, median, wait} from "./wt-utils";
 
 class Room {
 
@@ -182,11 +182,15 @@ class RoomSession {
 		this.sessiontype = type;
 		this.initialBitrate = 0;
 		this.simulcast = false;
-		this.simulcastBitrates = {
-			high: 900000,
-			medium: 300000,
-			low: 100000
-		};
+		this.simulcastMode = 'controlled'; // controlled, manual, auto
+		this.simulcastDefaultManualSubstream = 0; // 0 = maximum quality
+
+		// ordered from low to high
+		this.simulcastBitrates = [
+			{ rid: 'l', active: true, maxBitrate: 180000, maxFramerate: 20, scaleResolutionDownBy: 3.3333333333333335, priority: "low" },
+			{ rid: 'm', active: true, maxBitrate: 800000, maxFramerate: 25, scaleResolutionDownBy: 1.3333333333333333, priority: "low" },
+			{ rid: 'h', active: true, maxBitrate: 1700000, maxFramerate: 30, priority: "low" },
+		];
 		this.recordingFilename = null;
 		this.pluginName = RoomSession.sessionTypes[type];
 		this.id = null;
@@ -205,7 +209,15 @@ class RoomSession {
 		this.isMuted = [];
 		this.isVideoEnabled = false;
 		this.isAudioEnabed = false;
-		this._sendMessageTimout = 5000;
+		this._statsMaxLength = 21;
+		this._upStatsLength = 20;
+		this._downStatsLength = 5;
+		this._statsTimeoutStopped = true;
+		this._statsTimeoutId = null;
+		this._statsInterval = 1000;
+		this._aqInterval = 2500;
+		this._aqTimeoutId = null;
+		this._sendMessageTimeout = 5000;
 		this._retries = 0;
 		this._maxRetries = 5;
 		this._keepAliveId = null;
@@ -388,7 +400,7 @@ class RoomSession {
 						this.ws.removeEventListener('message', parseResponse);
 						this._abortController.signal.removeEventListener('abort', abortResponse);
 						reject({type: 'warning', id: 3, message: 'send timeout', data: requestData});
-					}, this._sendMessageTimout);
+					}, this._sendMessageTimeout);
 					this._abortController.signal.addEventListener('abort', abortResponse);
 					this.ws.send(JSON.stringify(requestData));
 				} else {
@@ -402,7 +414,7 @@ class RoomSession {
 				return Promise.reject(e);
 			}
 			else if(e.id === 29 && retry > 0) {
-				return wait(this._sendMessageTimout).then(() => this._send(request, ignoreResponse, dontResolveOnAck, retry - 1));
+				return wait(this._sendMessageTimeout).then(() => this._send(request, ignoreResponse, dontResolveOnAck, retry - 1));
 			}
 			else if(retry > 0) {
 				return this._send(request, ignoreResponse, dontResolveOnAck, retry - 1);
@@ -533,6 +545,8 @@ class RoomSession {
 				let list = msg["publishers"] || {};
 				let leaving = msg["leaving"];
 				let kicked = msg["kicked"];
+				let substream = msg["substream"];
+				let temporal = msg["temporal"];
 
 				//let joining = msg["joining"];
 				let unpublished = msg["unpublished"];
@@ -596,6 +610,14 @@ class RoomSession {
 				}
 				else if (event === "event") {
 
+					if(substream !== undefined && substream !== null) {
+						this._log('Substream event:', substream, sender);
+					}
+
+					if(temporal !== undefined && temporal !== null) {
+						this._log('Temporal event:', temporal);
+					}
+
 					if (msg["streams"] !== undefined && msg["streams"] !== null) {
 						this._log('Got my own streams back', msg["streams"]);
 					}
@@ -729,7 +751,8 @@ class RoomSession {
 					}
 
 				}
-			} else if (type === "webrtcup") {
+			}
+			else if (type === "webrtcup") {
 
 				if(this.simulcast) {
 					return;
@@ -757,13 +780,28 @@ class RoomSession {
 			let event = msg["videoroom"];
 			let error = msg["error"];
 			let substream = msg["substream"];
+			let mid = msg["mid"];
+			let temporal = msg["temporal"];
+
+			if(substream !== undefined && substream !== null) {
+				this._log('Substream: ',substream);
+				this._setSelectedSubstream(sender, mid, substream);
+				this._resetStats(sender, mid);
+			}
+
+			if(temporal !== undefined && temporal !== null) {
+				this._log('Temporal: ', temporal);
+			}
+
+			if(type === "webrtcup") {
+				this.requestKeyFrame(handle.handleId);
+			}
 
 			if (event === "updated") {
 				this._log('Remote has updated tracks', msg);
 				if(msg["streams"]) {
 					this._updateTransceiverMap(handle.handleId, msg["streams"]);
 				}
-
 			}
 
 			if (event === "attached") {
@@ -923,7 +961,11 @@ class RoomSession {
 					dtmfSender: null,
 					trickle: true,
 					iceDone: false,
-					isIceRestarting: false
+					isIceRestarting: false,
+					stats: {},
+					selectedSubstream: {},
+					simulcastSubstreamManualSelect: {},
+					simulcastSwitchFailedAttempts: {},
 				};
 
 				if (handleId === this.handleId) {
@@ -976,7 +1018,11 @@ class RoomSession {
 					dtmfSender: null,
 					trickle: true,
 					iceDone: false,
-					isIceRestarting: false
+					isIceRestarting: false,
+					stats: {},
+					selectedSubstream: {},
+					simulcastSubstreamManualSelect: {},
+					simulcastSwitchFailedAttempts: {},
 				}
 			};
 			this._participants.push(handle);
@@ -1053,16 +1099,23 @@ class RoomSession {
 			return;
 		}
 		let config = handle.webrtcStuff;
-		config.tracksMap = structuredClone(streams.map(s => ({
-			active: !s.disabled,
-			description: s.description,
-			display: s.display,
-			id: s.id,
-			mid: s.mid,
-			mindex: s.mindex,
-			codec: s.codec,
-			type: s.type,
-		})));
+		config.tracksMap = structuredClone(streams.map(s => {
+			let source = null;
+			try {
+				source = JSON.parse(s.description)?.source;
+			} catch(e) {}
+			return {
+				active: !s.disabled,
+				description: s.description,
+				source: source,
+				display: s.display,
+				id: s.id,
+				mid: s.mid,
+				mindex: s.mindex,
+				codec: s.codec,
+				type: s.type,
+			}
+		}));
 	}
 
 	_updateRemoteParticipantStreamMap(handleId) {
@@ -1189,7 +1242,22 @@ class RoomSession {
 		});
 	}
 
-	connect(roomId, pin, server, iceServers, token, display, userId, webrtcVersion = 0, initialBitrate = 0, recordingFilename, simulcast = false, simulcastBitrates = {}) {
+	connect(
+		roomId,
+		pin,
+		server,
+		iceServers,
+		token,
+		display,
+		userId,
+		webrtcVersion = 0,
+		initialBitrate = 0,
+		recordingFilename,
+		simulcast = false,
+		simulcastBitrates = this.simulcastBitrates,
+		simulcastMode = this.simulcastMode,
+		simulcastDefaultManualSubstream = this.simulcastDefaultManualSubstream
+	) {
 
 		if (this.isConnecting) {
 			return Promise.reject({type: 'warning', id: 16, message: 'connection already in progress'});
@@ -1214,8 +1282,16 @@ class RoomSession {
 		this.recordingFilename = recordingFilename;
 		this.isConnecting = true;
 		this.simulcast = simulcast;
-		this.simulcastBitrates = {...this.simulcastBitrates, ...simulcastBitrates};
-
+		this.simulcastMode = simulcastMode;
+		this.simulcastDefaultManualSubstream = simulcastDefaultManualSubstream;
+		if(simulcastBitrates !== null) {
+			this.simulcastBitrates = structuredClone(simulcastBitrates).sort((a, b) => {
+				if(a.maxBitrate === b.maxBitrate) {
+					return a.maxFramerate - b.maxFramerate;
+				}
+				return a.maxBitrate - b.maxBitrate;
+			});
+		}
 		this.emit('joining', true);
 		return new Promise((resolve, reject) => {
 
@@ -1252,6 +1328,8 @@ class RoomSession {
 					})
 					.then(() => this._joinRoom(roomId, pin, userId, display))
 					.then(() => {
+						this._enableStatsWatch();
+						this._enableSubstreamAutoSelect();
 						this.isConnecting = false;
 						this.emit('joining', false);
 						resolve(this);
@@ -1282,10 +1360,11 @@ class RoomSession {
 		}
 
 		this._abortController?.abort?.();
+		this.isDisconnecting = true;
 		this._stopKeepAlive();
-
+		this._disableStatsWatch();
+		this._disableSubstreamAutoSelect();
 		let isConnected = this.isConnected;
-		this.isDisconnecting = true;
 		return Promise.all(this._participants.map(p => this._removeParticipant(p.handleId)))
 			.finally(() => {
 				this._wipeListeners();
@@ -1436,18 +1515,305 @@ class RoomSession {
 		return this._participants.find(p => p.handleId === handleId || (rfid && p.rfid === rfid) || (userId && decodeJanusDisplay(p.userId)?.userId === userId));
 	}
 
+	_disableStatsWatch() {
+		if (this._statsTimeoutId) {
+			clearInterval(this._statsTimeout);
+			this._statsTimeoutStopped = true;
+			this._statsTimeoutId = null;
+		}
+	}
+	_enableStatsWatch() {
+		if (this._statsTimeoutId) {
+			clearTimeout(this._statsTimeoutId);
+			this._statsTimeoutId = null;
+		}
+		this._statsTimeoutStopped = false;
+		const loop = () => {
+			let startTime = performance.now();
+			let endTime = null;
+			this._getStats('video')
+				.then(participantsStats => {
+					endTime = performance.now();
+					this._parseVideoStats(participantsStats);
+				})
+				.finally(() => {
+					if (!this._statsTimeoutStopped) {
+						this._statsTimeoutId = setTimeout(loop, this._statsInterval - Math.min((endTime - startTime), this._statsInterval));
+					}
+				})
+		};
+		loop()
+	}
+
+	_enableSubstreamAutoSelect() {
+
+		if(!this.simulcast) {
+			return;
+		}
+
+		if(this._aqTimeoutId) {
+			clearTimeout(this._aqTimeoutId);
+			this._aqTimeoutId = null;
+		}
+		
+		this._aqTimeoutId = setInterval(() => {
+			this._participants.forEach(p => {
+				if(p.handleId !== this.handleId) {
+
+					const transceivers = p.webrtcStuff?.pc?.getTransceivers();
+					const mids = transceivers?.filter(t => t.receiver.track.kind === "video")?.map(t => t.mid) || [];
+					mids.forEach(mid => {
+
+						const source = p.webrtcStuff.tracksMap.find(t => t.mid === mid)?.source;
+						const manualSelectedSubstream = p.webrtcStuff.simulcastSubstreamManualSelect?.[mid];
+						const defaultSelectedSubstream = typeof this.simulcastDefaultManualSubstream === 'object'
+								? (this.simulcastDefaultManualSubstream[source] !== undefined ? this.simulcastDefaultManualSubstream[source] : this.simulcastDefaultManualSubstream['default'])
+								: this.simulcastDefaultManualSubstream;
+						const simulcastMode = typeof this.simulcastMode === 'object'
+							? (this.simulcastMode[source] !== undefined ? this.simulcastMode[source] : this.simulcastMode['default'])
+							: this.simulcastMode;
+						const failedAttempts = p.webrtcStuff.simulcastSwitchFailedAttempts[mid] || 0;
+
+						if((simulcastMode === 'auto' && !manualSelectedSubstream) || failedAttempts > 3) {
+							// do nothing
+						}
+						
+						else if(simulcastMode === 'manual' || manualSelectedSubstream) {
+							const currentSubstream = p.webrtcStuff.selectedSubstream[mid];
+							if(manualSelectedSubstream && currentSubstream !== manualSelectedSubstream) {
+								this.selectSubStream(p.handleId, manualSelectedSubstream, undefined, mid, false)
+									.then(() => {
+										p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 0
+									})
+									.catch(() => {
+										if(!p.webrtcStuff.simulcastSwitchFailedAttempts[mid]) {
+											p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 1;
+										}
+										else {
+											p.webrtcStuff.simulcastSwitchFailedAttempts[mid]++;
+										}
+									});
+							}
+							else if(defaultSelectedSubstream !== currentSubstream) {
+								this.selectSubStream(p.handleId, defaultSelectedSubstream, undefined, mid, false)
+									.then(() => {
+										p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 0
+									})
+									.catch(() => {
+										if(!p.webrtcStuff.simulcastSwitchFailedAttempts[mid]) {
+											p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 1;
+										}
+										else {
+											p.webrtcStuff.simulcastSwitchFailedAttempts[mid]++;
+										}
+									});
+							}
+						}
+
+						else if(simulcastMode === 'controlled') {
+							const currentSubstream = p.webrtcStuff.selectedSubstream[mid];
+							const settingsForCurrentSubstream = this.simulcastBitrates?.[this.simulcastBitrates.length - 1 - currentSubstream];
+							let directionDecision = 0;
+							if(p.webrtcStuff?.stats?.[mid]?.length > this._upStatsLength) {
+								const upMedianStats = this._calculateMedianStats(p.webrtcStuff.stats[mid].slice(this._upStatsLength * -1));
+								if(upMedianStats?.framesPerSecond > Math.floor(settingsForCurrentSubstream.maxFramerate * 0.9) || upMedianStats?.freezeDurationSinceLast < (this._upStatsLength * this._statsInterval * 0.1) / 1000 || this._upStatsLength?.freezeCountSinceLast < 3) {
+									directionDecision = 1;
+								}
+							}
+
+							if(p.webrtcStuff?.stats?.[mid]?.length > this._downStatsLength) {
+								const downMedianStats = this._calculateMedianStats(p.webrtcStuff.stats[mid].slice(this._downStatsLength * -1));
+								if(downMedianStats?.framesPerSecond < Math.floor(settingsForCurrentSubstream.maxFramerate * 0.7) || downMedianStats?.freezeDurationSinceLast > (this._downStatsLength * this._statsInterval * 0.33) / 1000 || downMedianStats?.freezeCountSinceLast > 5 || downMedianStats?.jitter > maxJitter(settingsForCurrentSubstream.maxFramerate)) {
+									directionDecision = -1;
+								}
+							}
+
+							if(directionDecision!== 0) {
+								this._log('directionDecision for mid', mid, directionDecision);
+							}
+
+							if(directionDecision === -1) {
+								if(currentSubstream < this.simulcastBitrates.length - 1) {
+									this._log('switching to low res', currentSubstream + 1);
+									this.selectSubStream(p.handleId, currentSubstream + 1, undefined, mid, false)
+										.then(() => {
+											p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 0
+										})
+										.catch(() => {
+											this._resetStats(p.handleId, mid);
+
+											if(!p.webrtcStuff.simulcastSwitchFailedAttempts[mid]) {
+												p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 1;
+											}
+											else {
+												p.webrtcStuff.simulcastSwitchFailedAttempts[mid]++;
+											}
+										});
+								}
+							}
+							else if (directionDecision === 1) {
+								if(currentSubstream > 0) {
+									this._log('switching to high res', currentSubstream - 1);
+									this.selectSubStream(p.handleId, currentSubstream - 1, undefined, mid, false)
+										.then(() => {
+											p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 0
+										})
+										.catch(() => {
+											this._resetStats(p.handleId, mid);
+											if(!p.webrtcStuff.simulcastSwitchFailedAttempts[mid]) {
+												p.webrtcStuff.simulcastSwitchFailedAttempts[mid] = 1;
+											}
+											else {
+												p.webrtcStuff.simulcastSwitchFailedAttempts[mid]++;
+											}
+										});
+								}
+							}
+						}
+					});
+				}
+			})
+		}, this._aqInterval);
+	}
+
+	_disableSubstreamAutoSelect() {
+		if(this._aqTimeoutId) {
+			clearTimeout(this._aqTimeoutId);
+			this._aqTimeoutId = null;
+		}
+	}
+
+	_calculateMedianStats(stats) {
+		let medianStats = {
+			framesPerSecond: null,
+			jitter: null,
+			roundTripTime: null,
+			freezeDurationSinceLast: null,
+			freezeCountSinceLast: null,
+		};
+		let keys = Object.keys(medianStats);
+		keys.forEach(key => {
+			if(key === 'freezeDurationSinceLast' || key ==='freezeCountSinceLast') {
+				medianStats[key] = stats.reduce((acc, cur) => acc + cur[key], 0);
+			}
+			// median but ignore first value of stats array
+			else {
+				let values = stats.map(s => s[key]);
+				medianStats[key] = median(values)
+			}
+
+		});
+		medianStats.statsLength = stats.length;
+		return medianStats;
+	}
+
+	_parseVideoStats(participantsStats) {
+		participantsStats.forEach(sourceStats => {
+			sourceStats.forEach(participantStats => {
+				if(participantStats !== null && participantStats?.handle?.handleId !== this.handleId) {
+					let handle = this._getHandle(participantStats.handle.handleId);
+					if(handle) {
+
+						if(!handle.webrtcStuff.stats[participantStats.mid]) {
+							handle.webrtcStuff.stats[participantStats.mid] = [];
+						}
+
+						const stats = {
+							framesPerSecond: null,
+							framesDropped: null,
+							totalFreezesDuration: null,
+							freezeDurationSinceLast: null,
+							freezeCount: null,
+							jitter: null,
+							packetsLost: null,
+							nackCount: null,
+							roundTripTime: null,
+							width: null,
+							height: null,
+							networkType: null,
+							powerEfficientDecoder: null,
+						};
+						participantStats.stats.forEach(report => {
+							if(report.type === 'inbound-rtp' && report.kind === 'video') {
+								stats.framesPerSecond = report.framesPerSecond || 0;
+								stats.framesDropped = report.framesDropped || 0;
+								stats.totalFreezesDuration = report.totalFreezesDuration || 0;
+								stats.freezeDurationSinceLast = (report.totalFreezesDuration || 0) - (handle.webrtcStuff.stats?.[participantStats.mid]?.[handle.webrtcStuff.stats?.[participantStats.mid]?.length - 1]?.totalFreezesDuration || 0);
+								stats.freezeCount = report.freezeCount || 0;
+								stats.freezeCountSinceLast = (report.freezeCount || 0) - (handle.webrtcStuff.stats?.[participantStats.mid]?.[handle.webrtcStuff.stats?.[participantStats.mid]?.length - 1]?.freezeCount || 0);
+								stats.jitter = report.jitter;
+								stats.packetsLost = report.packetsLost;
+								stats.nackCount = report.nackCount;
+								stats.width = report.frameWidth;
+								stats.height = report.frameHeight;
+								stats.powerEfficientDecoder = report.powerEfficientDecoder;
+							}
+							if(report.type === 'candidate-pair') {
+								stats.roundTripTime = report.currentRoundTripTime;
+							}
+							if(report.type === 'local-candidate') {
+								stats.networkType = report.networkType;
+							}
+						});
+
+						// pushing stats into handle stats array but keeping only 6 last stats
+						handle.webrtcStuff.stats[participantStats.mid].push(stats);
+						if(handle.webrtcStuff.stats[participantStats.mid].length > this._statsMaxLength) {
+							handle.webrtcStuff.stats[participantStats.mid].shift();
+						}
+						
+						this.emit('rtcStats', {handleId: participantStats.handle.handleId, stats, source: participantStats.source, mid: participantsStats.mid});
+					}
+				}
+			});
+		})
+
+	}
+
 	_getStats(type = null) {
 		return Promise.all(this._participants.map(participant => {
-			let mediaTrack = null;
+			let mediaTrack = [];
 			if (type === 'video') {
-				mediaTrack = participant.webrtcStuff && participant.webrtcStuff.stream && participant.webrtcStuff.stream.getVideoTracks().length && participant.webrtcStuff.stream.getVideoTracks()[0];
+				mediaTrack = participant?.webrtcStuff?.stream?.getVideoTracks() || [];
 			} else if (type === 'audio') {
-				mediaTrack = participant.webrtcStuff && participant.webrtcStuff.stream && participant.webrtcStuff.stream.getAudioTracks().length && participant.webrtcStuff.stream.getAudioTracks()[0];
+				mediaTrack = participant?.webrtcStuff?.stream?.getAudioTracks() || [];
+			}
+			if(type !== null ) {
+				const transceivers = participant?.webrtcStuff?.pc?.getTransceivers();
+				return Promise.all(mediaTrack.map(track => {
+					const source = Object.keys(participant.webrtcStuff.streamMap).find(s => participant.webrtcStuff.streamMap[s].find(t => t === track.id));
+					const mid = transceivers.find(t => t.receiver?.track?.id === track.id || t.sender?.track?.id === track.id)?.mid;
+					return participant.webrtcStuff.pc.getStats(track)
+						.then(r =>({stats: r, source, mid, handle: participant}))
+						.catch(e => Promise.reject({stats: null, error: e, handle: participant, source, mid}))
+				}))
+			}
+			else {
+				return participant?.webrtcStuff?.pc?.getStats(null)
+					.then(r => ({handle: participant, stats: r}))
+					.catch(e => Promise.reject({handle: participant, error: e}))
 			}
-			return participant.webrtcStuff && participant.webrtcStuff.pc && participant.webrtcStuff.pc.getStats(mediaTrack)
-				.then(r => ({handle: participant, stats: r}))
-				.catch(e => Promise.resolve({handle: participant, stats: e}))
 		}))
+		
+		
+	}
+
+	_resetStats(handleId, mid) {
+		let handle = this._getHandle(handleId);
+		if(handle) {
+			let config = handle.webrtcStuff;
+			if(!mid) {
+				Object.keys(config.stats).forEach(mid => {
+					config.stats[mid] = [config.stats[mid][config.stats[mid].length - 1]];
+				})
+			}
+			else {
+				// clearing stats for the new substream
+				if(config.stats[mid]) {
+					config.stats[mid] = [config.stats[mid][config.stats[mid].length - 1]];
+				}
+			}
+		}
 	}
 
 	_sendTrickleCandidate(handleId, candidate) {
@@ -2053,7 +2419,7 @@ class RoomSession {
 								"body": {"request": "start", ...(this.roomId && {"room": this.roomId}), ...(this.pin && {pin: this.pin})},
 								"jsep": _jsep
 							});
-						});
+						})
 				}, (e) => Promise.reject({
 					type: 'warning',
 					id: 23,
@@ -2231,18 +2597,12 @@ class RoomSession {
 					config.pc.addTrack(stream.getVideoTracks()[0], config.stream);
 				}
 				else {
-					let bitRates = this.simulcastBitrates;
 					if(adapter.browserDetails.browser !== 'firefox') {
 						// standard
-
 						config.pc.addTransceiver(stream.getVideoTracks()[0], {
 							direction: 'sendonly',
 							streams: [config.stream],
-							sendEncodings: [
-								{ rid: 'h', active: true, scalabilityMode: 'L1T2', maxBitrate: bitRates.high },
-								{ rid: 'm', active: true, scalabilityMode: 'L1T2', maxBitrate: bitRates.medium, scaleResolutionDownBy: 2 },
-								{ rid: 'l', active: true, scalabilityMode: 'L1T2', maxBitrate: bitRates.low, scaleResolutionDownBy: 4 }
-							]
+							sendEncodings: structuredClone(this.simulcastBitrates)
 						})
 					}
 					else {
@@ -2254,11 +2614,7 @@ class RoomSession {
 						let sender = transceiver ? transceiver.sender : null;
 						if(sender) {
 							let parameters = sender.getParameters() || {};
-							parameters.encodings = stream.getVideoTracks()[0].sendEncodings || [
-								{ rid: 'h', active: true, maxBitrate: bitRates.high },
-								{ rid: 'm', active: true, maxBitrate: bitRates.medium, scaleResolutionDownBy: 2 },
-								{ rid: 'l', active: true, maxBitrate: bitRates.low, scaleResolutionDownBy: 4 }
-							];
+							parameters.encodings = stream.getVideoTracks()[0].sendEncodings || structuredClone(this.simulcastBitrates);
 							sender.setParameters(parameters);
 						}
 					}
@@ -2572,13 +2928,99 @@ class RoomSession {
 			}
 		}).catch(() => null)
 	}
-	selectSubStream(handleId, substream = 2) {
-		this.sendMessage(handleId, {
-			"body": {
-				"request": "configure",
-				"substream": substream
+
+	_setSelectedSubstream(handleId, mid, substream)  {
+		let handle = this._getHandle(handleId);
+		if(handle) {
+			let config = handle.webrtcStuff;
+			if(!mid) {
+				Object.keys(config.selectedSubstream).forEach(mid => {
+					config.selectedSubstream[mid] = substream;
+				})
+			} else {
+				config.selectedSubstream[mid] = substream;
 			}
-		}).catch(() => null)
+		}
+	}
+
+	selectSubStream(handleId, substream = 2, source, mid, manual = true) {
+		let handle = this._getHandle(handleId);
+		if(!handle) {
+			return Promise.resolve();
+		}
+		let config = handle.webrtcStuff;
+		return new Promise((resolve, reject) => {
+			let messageTimeoutId;
+			let abortResponse = () => {
+				clearTimeout(messageTimeoutId);
+				this._abortController.signal.removeEventListener('abort', abortResponse);
+				this.ws.removeEventListener('message', parseResponse);
+				reject('aborted');
+			};
+			let parseResponse = (event) => {
+				let json = JSON.parse(event.data);
+				var sender = json["sender"];
+				if(sender === handleId) {
+					let plugindata = json["plugindata"] || {};
+					let msg = plugindata["data"] || {};
+					let substream = msg["substream"];
+					if(substream !== undefined && substream !== null && (mid !== undefined ? msg["mid"] === mid : true)) {
+						clearTimeout(messageTimeoutId);
+						this._abortController.signal.removeEventListener('abort', abortResponse);
+						this.ws.removeEventListener('message', parseResponse);
+						if(manual) {
+							config.simulcastSubstreamManualSelect[mid] = substream;
+						}
+						resolve({substream, sender});
+					}
+				}
+			}
+
+			if(source !== undefined || mid !== undefined) {
+				if(mid === undefined) {
+					let transceivers = config.pc.getTransceivers();
+					for(let trackId of config.streamMap[source]) {
+						let transceiver = transceivers.find(transceiver => transceiver.receiver.track && transceiver.receiver.track.kind === 'video' && transceiver.receiver.track.id === trackId)
+						if(transceiver) {
+							mid = transceiver.mid;
+							break;
+						}
+					}
+				}
+				if(mid !== undefined) {
+
+					if(manual && substream === null) {
+						config.simulcastSubstreamManualSelect[mid] = substream;
+						resolve({substream, sender: handleId});
+						return;
+					}
+
+					this.ws.addEventListener('message', parseResponse);
+					this._abortController.signal.addEventListener('abort', abortResponse);
+					messageTimeoutId = setTimeout(() => {
+						this._abortController.signal.removeEventListener('abort', abortResponse);
+						this.ws.removeEventListener('message', parseResponse);
+						reject('timeout');
+					}, 2000);
+
+					this.sendMessage(handleId, {
+						"body": {
+							"request": "configure",
+							"streams": [
+								{
+									mid, substream: parseInt(substream)
+								}
+							]
+						}
+					})
+				} else {
+					reject('no mid found');
+				}
+			}
+			else {
+				reject('no source or mid');
+			}
+		});
 	}
 
 	setTalkIntercomChannels(groups = ['participants']) {