fix initial bitrate selection

Author: summeroff

obs-studio-server/source/nodeobs_autoconfig.cpp

@@ -17,6 +17,7 @@
 ******************************************************************************/
 
 #include "nodeobs_autoconfig.h"
+#include <algorithm>
 #include <array>
 #include <future>
 #include <set>
@@ -558,7 +559,34 @@ void autoConfig::TestBandwidthThreadV2(void)
 				type = "rtmp_output";
 			std::string outputName = "autoconfig_bw_" + std::to_string(i);
 			targets[i]->CreateOutput(type, outputName);
-			targets[i]->testBandwidth(gotError);
+
+			// Pick a high test bitrate so the measurement reflects the link's
+			// real ceiling rather than whatever low value the user has set.
+			//   - user's current bitrate (might already be high)
+			//   - platform cap probed via obs_service_apply_encoder_settings
+			//     (Twitch returns 6000 for non-partners; partners higher)
+			//   - 6000 fallback when no platform hook exists (custom RTMP, etc.)
+			int userBitrate = 0;
+			if (targets[i]->videoEncoder) {
+				obs_data_t *s = obs_encoder_get_settings(targets[i]->videoEncoder);
+				userBitrate = (int)obs_data_get_int(s, "bitrate");
+				obs_data_release(s);
+			}
+			int platformCap = 0;
+			if (targets[i]->service) {
+				obs_data_t *probe = obs_data_create();
+				obs_data_set_int(probe, "bitrate", 50000);
+				obs_service_apply_encoder_settings(targets[i]->service, probe, nullptr);
+				int capped = (int)obs_data_get_int(probe, "bitrate");
+				if (capped > 0 && capped < 50000)
+					platformCap = capped;
+				obs_data_release(probe);
+			}
+			int testBitrate = std::max({userBitrate, platformCap, 6000});
+			blog(LOG_INFO, "TestBandwidthV2: target %zu test bitrate %d (user=%d, platformCap=%d)", i, testBitrate, userBitrate,
+			     platformCap);
+
+			targets[i]->testBandwidth(gotError, testBitrate);
 
 			if (!gotError && targets[i]->GetOutput()) {
 				testingServices.push_back(targets[i]);
@@ -647,11 +675,24 @@ void autoConfig::TestBandwidthThreadV2(void)
 							result.ms = elapsedMs;
 							result.targetIndex = testingServiceTargetIdx[si];
 
-							if (droppedFrames > 0 || (int)bitrate < (runContext.startingBitrate * 75 / 100)) {
-								result.bitrate = (int)bitrate * 70 / 100;
-							} else {
-								result.bitrate = runContext.startingBitrate;
-							}
+							// Use the per-target test bitrate (still active on the encoder
+						// until CleanTestMode runs below) as the reference, not the
+						// global runContext.startingBitrate which doesn't reflect the
+						// per-target ceiling-search override.
+						int testBitrateRef = 0;
+						if (streaming->videoEncoder) {
+							obs_data_t *encSettings = obs_encoder_get_settings(streaming->videoEncoder);
+							testBitrateRef = (int)obs_data_get_int(encSettings, "bitrate");
+							obs_data_release(encSettings);
+						}
+						if (testBitrateRef <= 0)
+							testBitrateRef = runContext.startingBitrate;
+
+						if (droppedFrames > 0 || (int)bitrate < (testBitrateRef * 75 / 100)) {
+							result.bitrate = (int)bitrate * 70 / 100;
+						} else {
+							result.bitrate = testBitrateRef;
+						}
 
 							testResults.push_back(result);
 						}
@@ -1732,8 +1773,8 @@ static void applyResults()
 		v.output_width = ((uint32_t)runContext.idealResolutionCX) & 0xFFFFFFFC;
 		v.output_height = ((uint32_t)runContext.idealResolutionCY) & 0xFFFFFFFE;
 
-		blog(LOG_INFO, "applyResults: ctx=%p current=%ux%u@%u/%u requested=%ux%u@%u/%u", video, video->output_width,
-		     video->output_height, video->fps_num, video->fps_den, v.output_width, v.output_height, v.fps_num, v.fps_den);
+		blog(LOG_INFO, "applyResults: ctx=%p current=%ux%u@%u/%u requested=%ux%u@%u/%u", video, video->output_width, video->output_height,
+		     video->fps_num, video->fps_den, v.output_width, v.output_height, v.fps_num, v.fps_den);
 
 		// Skip the libobs call when nothing changes — the common case where
 		// autoconfig picks the resolution/FPS the canvas is already running at.
@@ -1775,33 +1816,49 @@ static void applyResults()
 			blog(LOG_INFO, "applyResults: target %llu: applied service server '%s'", st.id, targetServer.c_str());
 		}
 
-		// Streaming bitrate — three caps applied in order:
-		//   a) EstimateUpperBitrate: theoretical max for the chosen res/FPS
-		//   b) Hardware encoder headroom: 14% multiplier
-		//   c) Platform cap via obs_service_apply_encoder_settings (per-target)
+		// Streaming bitrate selection (Option 2 — heuristic as floor, not ceiling):
+		//   1. Read user's current bitrate (CleanTestMode restored it before this).
+		//   2. Compute OBS quality heuristic for the chosen res/FPS.
+		//   3. Pick max(user, heuristic) — respect user when above the heuristic;
+		//      otherwise use the heuristic as the recommendation.
+		//   4. Cap by what the bandwidth test actually delivered (targetBitrate).
+		//   5. Cap by the per-platform service cap (Twitch etc.).
 		if (st.streaming->videoEncoder && targetBitrate > 0) {
+			int userBitrate = 0;
+			{
+				obs_data_t *s = obs_encoder_get_settings(st.streaming->videoEncoder);
+				userBitrate = (int)obs_data_get_int(s, "bitrate");
+				obs_data_release(s);
+			}
+
 			long double upperBitrate_d = EstimateUpperBitrate((int)runContext.idealResolutionCX, (int)runContext.idealResolutionCY,
 									  runContext.idealFPSNum, runContext.idealFPSDen ? runContext.idealFPSDen : 1);
-			uint64_t upperBitrate = (uint64_t)(std::floor(upperBitrate_d / 50.0L) * 50.0L);
-			if (runContext.streamingEncoder != Encoder::x264 && upperBitrate > 0) {
-				upperBitrate = upperBitrate * 114ULL / 100ULL;
+			uint64_t heuristic = (uint64_t)(std::floor(upperBitrate_d / 50.0L) * 50.0L);
+			if (runContext.streamingEncoder != Encoder::x264 && heuristic > 0) {
+				heuristic = heuristic * 114ULL / 100ULL;
 			}
-			uint64_t finalBitrate = targetBitrate;
-			if (upperBitrate > 0 && finalBitrate > upperBitrate)
-				finalBitrate = upperBitrate;
 
+			uint64_t finalBitrate = ((uint64_t)userBitrate > heuristic) ? (uint64_t)userBitrate : heuristic;
+			uint64_t preMeasured = finalBitrate;
+			if (finalBitrate > targetBitrate)
+				finalBitrate = targetBitrate;
+
+			uint64_t platformCapped = 0;
 			if (st.streaming->service) {
 				obs_data_t *capSettings = obs_data_create();
 				obs_data_set_int(capSettings, "bitrate", (long long)finalBitrate);
 				obs_service_apply_encoder_settings(st.streaming->service, capSettings, nullptr);
-				uint64_t platformCapped = (uint64_t)obs_data_get_int(capSettings, "bitrate");
+				platformCapped = (uint64_t)obs_data_get_int(capSettings, "bitrate");
 				if (platformCapped > 0 && platformCapped < finalBitrate) {
-					blog(LOG_INFO, "applyResults: platform cap reduced bitrate from %llu to %llu", finalBitrate, platformCapped);
 					finalBitrate = platformCapped;
 				}
 				obs_data_release(capSettings);
 			}
 
+			blog(LOG_INFO,
+			     "applyResults: target %llu picked %llu (user=%d heuristic=%llu choseBeforeCaps=%llu measured=%llu platformCap=%llu)",
+			     st.id, finalBitrate, userBitrate, heuristic, preMeasured, targetBitrate, platformCapped);
+
 			obs_data_t *encSettings = obs_data_create();
 			obs_data_set_int(encSettings, "bitrate", (long long)finalBitrate);
 			obs_encoder_update(st.streaming->videoEncoder, encSettings);

obs-studio-server/source/osn-streaming.cpp

@@ -40,13 +40,27 @@ osn::Streaming::~Streaming()
 	}
 }
 
-void osn::Streaming::testBandwidth(bool &gotError)
+void osn::Streaming::testBandwidth(bool &gotError, int testBitrate)
 {
 	if (!service || !GetOutput()) {
 		gotError = true;
 		return;
 	}
 
+	// Override the user's encoder bitrate with the ceiling-search target so the
+	// bandwidth measurement isn't capped by whatever the user happens to have
+	// set (often 2500). Restored in CleanTestMode().
+	if (testBitrate > 0 && videoEncoder) {
+		obs_data_t *encSettings = obs_encoder_get_settings(videoEncoder);
+		originalEncoderBitrate = (int)obs_data_get_int(encSettings, "bitrate");
+		obs_data_release(encSettings);
+
+		obs_data_t *override = obs_data_create();
+		obs_data_set_int(override, "bitrate", (long long)testBitrate);
+		obs_encoder_update(videoEncoder, override);
+		obs_data_release(override);
+	}
+
 	if (originalServiceSettings) {
 		obs_data_release(originalServiceSettings);
 	}
@@ -101,6 +115,14 @@ void osn::Streaming::CleanTestMode()
 		originalServiceSettings = nullptr;
 	}
 
+	if (videoEncoder && originalEncoderBitrate > 0) {
+		obs_data_t *restore = obs_data_create();
+		obs_data_set_int(restore, "bitrate", (long long)originalEncoderBitrate);
+		obs_encoder_update(videoEncoder, restore);
+		obs_data_release(restore);
+		originalEncoderBitrate = 0;
+	}
+
 	testMode = false;
 }
 

obs-studio-server/source/osn-streaming.hpp

@@ -52,6 +52,7 @@ class Streaming : public Output {
 		simple = true;
 		testMode = false;
 		originalServiceSettings = nullptr;
+		originalEncoderBitrate = 0;
 	}
 	virtual ~Streaming();
 
@@ -74,6 +75,10 @@ class Streaming : public Output {
 	bool simple;
 	bool testMode;
 	obs_data_t *originalServiceSettings;
+	// Bitrate the user had on videoEncoder before testBandwidth() bumped it for
+	// the ceiling-search measurement. Restored in CleanTestMode(). 0 = nothing
+	// to restore.
+	int originalEncoderBitrate;
 
 	bool isTwitchVODSupported();
 	bool ApplyOutputSettings(obs_output_t *output, std::string &errorMessage);
@@ -89,7 +94,10 @@ class Streaming : public Output {
 	// pipelines for simple/advanced); testBandwidth() and CleanTestMode() are shared.
 	virtual void start() {}
 	virtual void checkOutput() {}
-	void testBandwidth(bool &gotError);
+	// testBitrate: bitrate to override videoEncoder with for the duration of the
+	// measurement. The user's original bitrate is restored by CleanTestMode().
+	// Pass 0 to leave the encoder untouched.
+	void testBandwidth(bool &gotError, int testBitrate = 0);
 	void CleanTestMode();
 };