@unboundcx/video-sdk-client 2.0.10 → 2.0.11

package/managers/LocalMediaManager.js

@@ -995,28 +995,39 @@ export class LocalMediaManager extends EventEmitter {
 		// Keep a layer active only if its width is within the cap.
 		const capWidth =
 			{ '360p': 640, '540p': 960, '720p': 1280 }[sendResolution] || Infinity;
-		// Per-layer fraction of the bitrate budget — matches produce().
-		const LAYER_FRACTION = { l: 0.18, m: 0.4, h: 1.0 };
+		// Relative weights per rid — matches produce(); the budget is split so
+		// the ACTIVE layers SUM to maxBitrate (simulcast total = sum of layers).
+		const WEIGHT = { l: 0.15, m: 0.35, h: 0.65 };
 
 		try {
 			const params = sender.getParameters();
 			if (!params.encodings || params.encodings.length < 2) return;
 			let changed = false;
+			// First pass: decide which layers stay active under the res cap.
+			const settings = this.streams.camera?.getVideoTracks()[0]?.getSettings();
+			const captureWidth = settings?.width || 1920;
 			for (const enc of params.encodings) {
 				// scaleResolutionDownBy tells us this layer's output width
 				// relative to the captured frame; below the cap stays active.
-				const settings = this.streams.camera?.getVideoTracks()[0]?.getSettings();
-				const captureWidth = settings?.width || 1920;
 				const layerWidth = captureWidth / (enc.scaleResolutionDownBy || 1);
 				const wantActive = layerWidth <= capWidth + 1; // +1 for rounding
 				if (enc.active !== wantActive) {
 					enc.active = wantActive;
 					changed = true;
 				}
-				if (maxBitrate > 0) {
-					const frac = LAYER_FRACTION[enc.rid] ?? 1.0;
-					const ceiling = Math.round(maxBitrate * frac);
-					const next = Math.min(enc.maxBitrate || ceiling, ceiling);
+			}
+			// Second pass: split the budget across the layers that remain active,
+			// normalizing weights so the active set sums to the budget.
+			if (maxBitrate > 0) {
+				const active = params.encodings.filter((e) => e.active !== false);
+				const totalWeight = active.reduce(
+					(s, e) => s + (WEIGHT[e.rid] ?? 1.0),
+					0
+				);
+				for (const enc of active) {
+					const w = WEIGHT[enc.rid] ?? 1.0;
+					const share = Math.round((maxBitrate * w) / totalWeight);
+					const next = Math.min(enc.maxBitrate || share, share);
 					if (enc.maxBitrate !== next) {
 						enc.maxBitrate = next;
 						changed = true;

package/managers/MediasoupManager.js

@@ -674,27 +674,37 @@ export class MediasoupManager extends EventEmitter {
           });
         }
 
-        // HARD bitrate ceiling (data-saver / quality level). The per-branch
-        // numbers above are tuned for full-quality send; on a metered link the
-        // profile's sendMaxBitrate is a budget the encoder must not exceed —
-        // *even during high motion*, which is exactly when resolution/fps caps
-        // alone let the rate spike. Apply it as a ceiling on the top (h) layer,
-        // and scale the lower layers proportionally so the simulcast total
-        // stays within budget. (Screen share never reaches here.)
+        // HARD bitrate ceiling (data-saver / quality level). On a metered link
+        // the profile's sendMaxBitrate is a budget the encoder must not exceed
+        // — even during high motion, when resolution/fps caps alone let the
+        // rate spike. With simulcast, total bandwidth is the SUM of all active
+        // layers, so the budget is split across the layers present such that
+        // the layers SUM to the budget (not each capped at the full budget —
+        // that earlier bug let the total reach ~1.6× the cap). The top layer
+        // gets the lion's share; lower layers get proportionally less.
+        // (Screen share never reaches here.)
         const maxBitrate = Number(options.maxBitrate) || 0;
-        if (maxBitrate > 0 && produceOptions.encodings) {
-          // Fractions of the budget per layer, matching the l/m/h split used
-          // above (~1/8, ~1/3, full). Keys are rids.
-          const LAYER_FRACTION = { l: 0.18, m: 0.4, h: 1.0 };
-          for (const enc of produceOptions.encodings) {
-            const frac = LAYER_FRACTION[enc.rid] ?? 1.0;
-            const ceiling = Math.round(maxBitrate * frac);
+        if (maxBitrate > 0 && produceOptions.encodings?.length) {
+          // Relative weights per rid; we normalize over the layers actually
+          // present so the allocated total always equals the budget whether
+          // there are 1, 2, or 3 layers.
+          const WEIGHT = { l: 0.15, m: 0.35, h: 0.65 };
+          const encs = produceOptions.encodings;
+          const totalWeight = encs.reduce(
+            (sum, e) => sum + (WEIGHT[e.rid] ?? 1.0),
+            0,
+          );
+          for (const enc of encs) {
+            const w = WEIGHT[enc.rid] ?? 1.0;
+            const share = Math.round((maxBitrate * w) / totalWeight);
             // Only ever lower — never raise a layer above its tuned value.
-            enc.maxBitrate = Math.min(enc.maxBitrate || ceiling, ceiling);
+            enc.maxBitrate = Math.min(enc.maxBitrate || share, share);
           }
+          const allocated = encs.reduce((s, e) => s + (e.maxBitrate || 0), 0);
           this.logger.info("VIDEO_QUALITY :: applied hard bitrate ceiling", {
-            maxBitrate: `${(maxBitrate / 1000).toFixed(0)}kbps`,
-            encodings: produceOptions.encodings.map(
+            budget: `${(maxBitrate / 1000).toFixed(0)}kbps`,
+            allocatedTotal: `${(allocated / 1000).toFixed(0)}kbps`,
+            encodings: encs.map(
               (e) => `${e.rid}: ${(e.maxBitrate / 1000).toFixed(0)}kbps`,
             ),
           });

package/managers/StatsCollector.js

@@ -452,15 +452,31 @@ export class StatsCollector {
             report.type === 'outbound-rtp' ||
             report.type === 'remote-outbound-rtp'
           ) {
-            videoStats.packetsSent = this.validateNumber(report.packetsSent);
-            videoStats.bytesSent = this.validateNumber(report.bytesSent);
-            videoStats.framesSent = this.validateNumber(report.framesSent);
-            videoStats.framesPerSecond = this.validateNumber(
-              report.framesPerSecond,
-            );
-            videoStats.frameHeight = this.validateNumber(report.frameHeight);
-            videoStats.frameWidth = this.validateNumber(report.frameWidth);
-            videoStats.scalabilityMode = report.scalabilityMode;
+            // SIMULCAST: there's one outbound-rtp report PER active layer
+            // (l/m/h). Counters that represent the whole producer (bytes,
+            // packets, frames) accumulate across layers; resolution/fps must
+            // reflect the TOP active layer, so only overwrite those when this
+            // report is a bigger frame than what we've seen. Without this the
+            // last report (often the lowest layer) wins and the panel shows
+            // e.g. 270p while we're actually sending 540p.
+            videoStats.packetsSent =
+              (videoStats.packetsSent || 0) +
+              this.validateNumber(report.packetsSent);
+            videoStats.bytesSent =
+              (videoStats.bytesSent || 0) +
+              this.validateNumber(report.bytesSent);
+            videoStats.framesSent =
+              (videoStats.framesSent || 0) +
+              this.validateNumber(report.framesSent);
+            const w = this.validateNumber(report.frameWidth);
+            if (w >= (videoStats.frameWidth || 0)) {
+              videoStats.frameWidth = w;
+              videoStats.frameHeight = this.validateNumber(report.frameHeight);
+              videoStats.framesPerSecond = this.validateNumber(
+                report.framesPerSecond,
+              );
+              videoStats.scalabilityMode = report.scalabilityMode;
+            }
             videoStats.qpSum = report.qpSum;
             videoStats.totalPacketSendDelay = this.validateNumber(
               report.totalPacketSendDelay,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@unboundcx/video-sdk-client",
-	"version": "2.0.10",
+	"version": "2.0.11",
 	"description": "Framework-agnostic WebRTC video meeting SDK powered by mediasoup",
 	"type": "module",
 	"main": "index.js",