@unboundcx/video-sdk-client 2.0.10 → 2.0.12

package/VideoMeetingClient.js

@@ -829,6 +829,10 @@ export class VideoMeetingClient extends EventEmitter {
         profile.maxSpatialLayer,
         profile.maxTemporalLayer,
       );
+      // Keep the send-cap flag in sync on every level change so QualityMonitor
+      // discounts the BWE floor while we're intentionally throttled — even on
+      // the mid-call path that doesn't re-produce.
+      this.mediasoup.setSendBitrateCap(profile.sendMaxBitrate || 0);
     }
     if (this.remoteMedia) {
       this.remoteMedia.setLayerCeiling(

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

@@ -38,6 +38,12 @@ export class MediasoupManager extends EventEmitter {
     // no cap. See videoQualityProfiles.js + RemoteMediaManager.setLayerCeiling.
     this.layerCeiling = { maxSpatialLayer: null, maxTemporalLayer: null };
 
+    // Active send bitrate cap (bps) from the data-saver profile, or 0 when
+    // uncapped. QualityMonitor reads this so it can ignore Chrome's BWE
+    // "available upload" floor while we're INTENTIONALLY sending low — a low
+    // estimate then means "no demand to probe higher", not "bad network".
+    this.sendBitrateCap = 0;
+
     // Initialize stats collector
     this.statsCollector = new StatsCollector(this.logger);
     this.virtualBackgroundStore = null; // Will be set externally
@@ -674,27 +680,40 @@ 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);
+        // Remember the active send cap so QualityMonitor can discount the BWE
+        // floor while we're intentionally throttled (data saver).
+        this.sendBitrateCap = maxBitrate;
+        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`,
             ),
           });
@@ -1091,6 +1110,21 @@ export class MediasoupManager extends EventEmitter {
     return this.producers.get("video") || this.producers.get("camera") || null;
   }
 
+  /**
+   * Set/clear the active send bitrate cap (bps; 0 = uncapped). Lets the
+   * mid-call data-saver path (setParameters, no re-produce) keep
+   * sendBitrateCap in sync so QualityMonitor discounts the BWE floor.
+   * @param {number} bps
+   */
+  setSendBitrateCap(bps) {
+    this.sendBitrateCap = Number(bps) || 0;
+  }
+
+  /** @returns {number} active send bitrate cap in bps (0 = uncapped) */
+  getSendBitrateCap() {
+    return this.sendBitrateCap || 0;
+  }
+
   /**
    * Ask the SFU to forward a lower simulcast layer of the given peer's
    * video producer to us. spatialLayer 0=low, 1=mid, 2=high.

package/managers/QualityMonitor.js

@@ -423,15 +423,27 @@ export class QualityMonitor {
     // counting that as a bad network wrongly marks audio-only participants
     // "poor" and triggers a disable-camera suggestion for a camera that's
     // already off. RTT + loss remain valid either way.
-    // Only count availMbps once we've seen a real reading (>0); some
-    // browsers report 0 transiently at session start.
+    //
+    // The SAME artifact happens under data saver: when we deliberately cap the
+    // send to e.g. 600kbps and a low-motion scene only uses ~30kbps, the BWE
+    // collapses toward what we're actually sending (no demand to probe higher),
+    // so availMbps reads ~0.1 even on a perfectly healthy link. So when a send
+    // cap is active we IGNORE the availMbps floor entirely and rely only on the
+    // encoder-bandwidth-limited ratio, which genuinely means "the encoder wants
+    // more bits than the link will give" — the real signal that survives a cap.
+    const sendCapped =
+      typeof this.mediasoupManager?.getSendBitrateCap === "function" &&
+      this.mediasoupManager.getSendBitrateCap() > 0;
+    const useAvailFloor = this._isSendingVideo() && !sendCapped;
     const bandwidthSeverity = !this._isSendingVideo()
       ? 0
-      : availMbps > 0 && availMbps <= this.thresholds.availMbpsCrit
+      : useAvailFloor && availMbps > 0 && availMbps <= this.thresholds.availMbpsCrit
         ? 2
         : bwLimitedRatio >= this.thresholds.encoderBwLimitedCritRatio
           ? 2
-          : availMbps > 0 && availMbps <= this.thresholds.availMbpsWarn
+          : useAvailFloor &&
+              availMbps > 0 &&
+              availMbps <= this.thresholds.availMbpsWarn
             ? 1
             : bwLimitedRatio >= this.thresholds.encoderBwLimitedWarnRatio
               ? 1

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.12",
 	"description": "Framework-agnostic WebRTC video meeting SDK powered by mediasoup",
 	"type": "module",
 	"main": "index.js",