Fix Auto Optimizer custom-aspect recommendations and bounded fallbacks (#1800)

* Fix Auto Optimizer custom-aspect recommendations and bounded fallbacks

* Match Auto Optimizer validation to Twitch vertical limits

Author: aleksandr-voitenko

js/module.ts

@@ -2160,17 +2160,18 @@ interface IAutoOptimizerLimits {
     maxBitrateKbps?: number;
     /**
      * Maximum resolution OSN may test for this run without changing persistent
-     * video settings. Supply `maxWidth` and `maxHeight` together. OSN tests only
-     * the supported 2560x1440, 1920x1080, 1280x720, and 960x540 tiers, or their portrait
-     * equivalents, up to this limit. It promotes only 16:9 or 9:16 output; a
-     * custom aspect ratio keeps its current resolution and frame rate. The
-     * caller remains responsible for applying a recommended Base Canvas resize
-     * safely.
+     * video settings. Supply `maxWidth` and `maxHeight` together as a bounding
+     * box. Standard-aspect outputs use the 2560x1440, 1920x1080, 1280x720, and
+     * 960x540 tiers, or their portrait equivalents. Custom outputs, including
+     * ultrawide, preserve their configured output aspect, reduced to fit the
+     * limits with even-pixel rounding. The base canvas aspect is not substituted.
+     * Estimated results never increase saved dimensions or frame rate. The
+     * caller remains responsible for applying any Base Canvas resize safely.
      * Horizontal 1440p testing is available only when every destination in the
      * request is Twitch. Other streams are limited to 1080p. Vertical testing
      * remains limited to 1080x1920, including Twitch Enhanced Broadcasting's
      * paired 1440p horizontal / 1080p vertical workload. Ordinary Twitch 1440p
-     * requests use an experimental 8000 Kbps limit instead of the service's
+     * requests use an experimental 7500 Kbps limit instead of the service's
      * 6000 Kbps default; the caller must apply that tested bitrate without
      * reapplying the lower service bitrate limit.
      */

obs-studio-client/source/auto-optimizer-client-contract.cpp

@@ -664,19 +664,25 @@ bool parseRecommendation(const json &value, const OutputContext &output, const s
 		const auto &additionalContext = *output.additionalVideo;
 		if (!tupleWithinLimits(additional["width"], additional["height"], additional["fpsNum"], additional["fpsDen"], additionalContext.limits))
 			return false;
-		// Only measured results must match Twitch's tested pair. Estimates retain
-		// the saved vertical settings, which may differ in resolution or cadence.
+		// Only measured results must match Twitch's tested pair. Estimates may
+		// reduce saved vertical settings to caller/platform limits, but not promote.
 		if (measurementMode == "active") {
+			// Mirror the server's vertical platform caps while preserving tighter caller limits.
 			const auto paired = enhancedBroadcastingPolicy::pairedVerticalCandidate(
-				{(uint32_t)result.width, (uint32_t)result.height, (uint32_t)result.fpsNum, (uint32_t)result.fpsDen});
+				{(uint32_t)result.width, (uint32_t)result.height, (uint32_t)result.fpsNum, (uint32_t)result.fpsDen},
+				{output.current.width, output.current.height, output.current.fpsNum, output.current.fpsDen},
+				{additionalContext.current.width, additionalContext.current.height, additionalContext.current.fpsNum,
+				 additionalContext.current.fpsDen},
+				std::min(additionalContext.limits.maxWidth.value_or(1080), 1080),
+				std::min(additionalContext.limits.maxHeight.value_or(1920), 1920));
 			if (additional["width"] != paired.width || additional["height"] != paired.height ||
 			    static_cast<int64_t>(additional["fpsNum"].get<int>()) * result.fpsDen !=
 				    static_cast<int64_t>(result.fpsNum) * additional["fpsDen"].get<int>())
 				return false;
 		}
 		if (measurementMode == "estimated" &&
-		    (additional["width"] != additionalContext.current.width || additional["height"] != additionalContext.current.height ||
-		     static_cast<int64_t>(additional["fpsNum"].get<int>()) * additionalContext.current.fpsDen !=
+		    (additional["width"] > additionalContext.current.width || additional["height"] > additionalContext.current.height ||
+		     static_cast<int64_t>(additional["fpsNum"].get<int>()) * additionalContext.current.fpsDen >
 			     static_cast<int64_t>(additionalContext.current.fpsNum) * additional["fpsDen"].get<int>()))
 			return false;
 	}

obs-studio-client/tests/auto-optimizer-client-contract-test.cpp

@@ -642,17 +642,90 @@ TEST_CASE("Auto Optimizer client preserves saved Dual Format estimates without m
 	CHECK(projected["videos"][1] == vertical);
 	CHECK_FALSE(projected.contains("encoding"));
 	checkInvalidResultMutations(
-		fixture, {{"changed saved vertical size",
-			   [](json &value) {
-				   value["legs"][0]["recommendation"]["additionalVideo"]["width"] = 1080;
-				   value["legs"][0]["recommendation"]["additionalVideo"]["height"] = 1920;
-			   }},
+		fixture, {{"unmeasured vertical promotion", [](json &value) { value["legs"][0]["recommendation"]["additionalVideo"]["width"] = 1442; }},
 			  {"changed saved vertical cadence", [](json &value) { value["legs"][0]["recommendation"]["additionalVideo"]["fpsNum"] = 60; }},
 			  {"unmeasured primary promotion", [](json &value) { value["legs"][0]["recommendation"]["fpsNum"] = 120; }}});
 	auto limited = prepared.context;
 	limited.outputs[0].additionalVideo->limits.maxWidth = 1080;
 	limited.outputs[0].additionalVideo->limits.maxHeight = 1920;
 	CHECK_FALSE(contract::projectResult(fixture.result.dump(), "run", limited).valid);
+	fixture.result["legs"][0]["recommendation"]["additionalVideo"]["width"] = 1080;
+	fixture.result["legs"][0]["recommendation"]["additionalVideo"]["height"] = 1920;
+	CHECK(contract::projectResult(fixture.result.dump(), "run", limited).valid);
+}
+
+TEST_CASE("Auto Optimizer client requires exact measured proof for independently shaped Dual Format outputs")
+{
+	json output = enhancedBroadcastingOutput();
+	output["current"] = current(3440, 1440, 6000, 1);
+	output["limits"] = {{"maxWidth", 1920}, {"maxHeight", 1080}};
+	const auto prepared = prepare({{"streamSetup", "enhanced-broadcasting"}, {"outputs", json::array({output})}});
+	json returned = returnedEnhancedBroadcastingOutput();
+	returned["recommendation"]["height"] = 802;
+	returned["measurement"]["probes"][0]["testedHeight"] = 802;
+	ResultFixture fixture{prepared, {{"schemaVersion", 1}, {"sessionId", "run"}, {"status", "complete"}, {"legs", json::array({returned})}}};
+	REQUIRE(contract::projectResult(fixture.result.dump(), "run", prepared.context).valid);
+	checkInvalidResultMutations(
+		fixture, {
+				 {"unproven custom primary", [](json &value) { value["legs"][0]["measurement"]["probes"][0]["testedHeight"] = 1080; }},
+				 {"rotated ultrawide must not replace vertical output",
+				  [](json &value) {
+					  auto &leg = value["legs"][0];
+					  leg["recommendation"]["additionalVideo"]["width"] = 802;
+					  leg["measurement"]["probes"][0]["testedAdditionalVideo"] = leg["recommendation"]["additionalVideo"];
+				  }},
+			 });
+}
+
+TEST_CASE("Auto Optimizer client caps custom Dual Format validation to Twitch limits")
+{
+	struct Example {
+		int width, height, maxWidth, maxHeight, expectedWidth, expectedHeight;
+	};
+	const auto example = GENERATE(Example{1200, 1600, 1200, 1600, 1080, 1440}, Example{1000, 2400, 1000, 2400, 800, 1920},
+				      Example{1200, 1600, 720, 1280, 720, 960}, Example{1200, 1600, 1080, 1920, 1080, 1440},
+				      Example{1200, 1600, 0, 0, 1080, 1440});
+	CAPTURE(example.width, example.height, example.maxWidth, example.maxHeight);
+	json output = enhancedBroadcastingOutput();
+	output["additionalVideo"]["current"] = current(example.width, example.height, 6000, 2);
+	if (example.maxWidth)
+		output["additionalVideo"]["limits"] = {{"maxWidth", example.maxWidth}, {"maxHeight", example.maxHeight}};
+	const auto prepared = prepare({{"streamSetup", "enhanced-broadcasting"}, {"outputs", json::array({output})}});
+	json returned = returnedEnhancedBroadcastingOutput();
+	auto &additional = returned["recommendation"]["additionalVideo"];
+	additional["width"] = example.expectedWidth;
+	additional["height"] = example.expectedHeight;
+	returned["measurement"]["probes"][0]["testedAdditionalVideo"] = additional;
+	ResultFixture fixture{prepared, {{"schemaVersion", 1}, {"sessionId", "run"}, {"status", "complete"}, {"legs", json::array({returned})}}};
+	const auto projected = contract::projectResult(fixture.result.dump(), "run", prepared.context);
+	REQUIRE(projected.valid);
+	CHECK(json::parse(projected.json)["outputs"][0]["videos"][1] == additional);
+	checkInvalidResultMutations(fixture, {{"mismatched measured vertical dimensions",
+					       [](json &value) { value["legs"][0]["measurement"]["probes"][0]["testedAdditionalVideo"]["width"] = 2; }},
+					      {"uncapped vertical result despite matching proof", [&](json &value) {
+						       auto &leg = value["legs"][0];
+						       auto &video = leg["recommendation"]["additionalVideo"];
+						       video["width"] = example.width;
+						       video["height"] = example.height;
+						       leg["measurement"]["probes"][0]["testedAdditionalVideo"] = video;
+					       }}});
+}
+
+TEST_CASE("Auto Optimizer client accepts bounded ultrawide results but rejects oversized active and estimated tuples")
+{
+	const int width = GENERATE(3340, 3440);
+	const bool measured = GENERATE(false, true);
+	json output = standardOutput("primary", "horizontal", "twitch", twitchProbe());
+	output["current"] = current(width, 1440, 6000);
+	const auto prepared = prepare({{"streamSetup", "direct-single"}, {"outputs", json::array({output})}});
+	json returned = returnedStandardOutput("primary", "horizontal", "twitch", "twitch", "twitch-bandwidth-test", 6000, 6000);
+	returned["recommendation"] = recommendation(1920, width == 3440 ? 802 : 826, 6000);
+	returned["measurement"]["mode"] = measured ? "active" : "estimated";
+	returned["measurement"]["probes"][0]["success"] = measured;
+	json result = {{"schemaVersion", 1}, {"sessionId", "run"}, {"status", "complete"}, {"legs", json::array({returned})}};
+	CHECK(contract::projectResult(result.dump(), "run", prepared.context).valid);
+	result["legs"][0]["recommendation"] = recommendation(width, 1440, 6000);
+	CHECK_FALSE(contract::projectResult(result.dump(), "run", prepared.context).valid);
 }
 
 TEST_CASE("Auto Optimizer client preserves measured Enhanced Broadcasting fallback explanations")

obs-studio-client/tests/auto-optimizer-enhanced-broadcasting-policy-test.cpp

@@ -4,6 +4,36 @@
 
 namespace policy = autoOptimizer::enhancedBroadcastingPolicy;
 
+TEST_CASE("Enhanced Broadcasting tests the configured custom output aspect, not a 16:9 replacement")
+{
+	for (const auto current :
+	     std::vector<autoOptimizer::qualityPolicy::VideoTuple>{{3440, 1440, 60, 1}, {3340, 1440, 30, 1}, {2560, 1600, 30, 1}, {1600, 1200, 30, 1}}) {
+		const auto expected = autoOptimizer::qualityPolicy::boundCurrentToSupportedTier(current, 1920, 1080);
+		const auto result = policy::candidatesForOutput(current, 1920, 1080, 60, 1);
+		REQUIRE(result.size() == 1);
+		CHECK(result[0].width == expected.width);
+		CHECK(result[0].height == expected.height);
+		CHECK(result[0].fpsNum == current.fpsNum);
+	}
+	const auto capped = policy::candidatesForOutput({3440, 1440, 60, 1}, 1920, 1080, 30, 1);
+	CHECK(capped[0].fpsNum == 30);
+	CHECK(policy::candidatesForOutput({1920, 1080, 30, 1}, 2560, 1440, 60, 1).size() == 7);
+}
+
+TEST_CASE("Enhanced Broadcasting keeps independently configured custom Dual Format aspects")
+{
+	const auto vertical = policy::pairedVerticalCandidate({1920, 802, 60, 1}, {3440, 1440, 60, 1}, {1080, 1920, 60, 1}, 1080, 1920);
+	CHECK(vertical.width == 1080);
+	CHECK(vertical.height == 1920);
+	const auto customVertical = policy::pairedVerticalCandidate({1920, 1080, 60, 1}, {1920, 1080, 60, 1}, {1200, 1600, 60, 1}, 1080, 1920);
+	CHECK(customVertical.width == 1080);
+	CHECK(customVertical.height == 1440);
+	CHECK(customVertical.fpsNum == 60);
+	const auto canonical = policy::pairedVerticalCandidate({2560, 1440, 60, 1}, {1920, 1080, 60, 1}, {720, 1280, 60, 1}, 1080, 1920);
+	CHECK(canonical.width == 1080);
+	CHECK(canonical.height == 1920);
+}
+
 TEST_CASE("Enhanced Broadcasting probes preserve discovered H.264 and HEVC independently of resolution")
 {
 	std::unordered_set<std::string> codecs{"h264", "h265", "av1", "vp9"};

obs-studio-client/tests/auto-optimizer-quality-policy-test.cpp

@@ -1,4 +1,5 @@
 #include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators.hpp>
 
 #include <initializer_list>
 #include <limits>
@@ -265,15 +266,15 @@ TEST_CASE("Auto Optimizer hardware tests high frame rates in product-priority or
 	CHECK(result[1].fpsNum == 30);
 }
 
-TEST_CASE("Auto Optimizer permits Twitch-only 1440p with an experimental measured 8 Mbps budget")
+TEST_CASE("Auto Optimizer permits Twitch-only 1440p with an experimental measured 7.5 Mbps budget")
 {
 	CHECK(policy::isTwitchOnlyStream({"twitch", "twitch"}));
 	CHECK_FALSE(policy::isTwitchOnlyStream({"twitch", "youtube"}));
 	CHECK_FALSE(policy::isTwitchOnlyStream({"twitch", "custom"}));
 	CHECK_FALSE(policy::isTwitchOnlyStream({}));
 	const policy::VideoTuple ceiling{2560, 1440, 60, 1};
-	CHECK(policy::select(ceiling, 8000, "nvenc", policy::QualityProfile::Twitch).video.width == 2560);
-	CHECK(policy::select(ceiling, 7950, "nvenc", policy::QualityProfile::Twitch).video.width == 1920);
+	CHECK(policy::select(ceiling, 7500, "nvenc", policy::QualityProfile::Twitch).video.width == 2560);
+	CHECK(policy::select(ceiling, 7499, "nvenc", policy::QualityProfile::Twitch).video.width == 1920);
 	CHECK(policy::select(ceiling, 6000, "nvenc", policy::QualityProfile::Twitch).video.width == 1920);
 	CHECK(policy::benchmarkCeiling({1280, 720, 30, 1}, 2560, 1440, 60, 1).width == 2560);
 }
@@ -525,16 +526,41 @@ TEST_CASE("Auto Optimizer benchmark ceiling preserves portrait orientation")
 	CHECK(policy::select(promoted, 6000, "obs_nvenc_h264_tex").video.height == 1920);
 }
 
-TEST_CASE("Auto Optimizer promotes only supported 16:9 and 9:16 aspect ratios")
+TEST_CASE("Auto Optimizer preserves ultrawide outputs within active and estimated limits")
+{
+	const int width = GENERATE(3340, 3440);
+	const policy::VideoTuple current{width, 1440, 60, 1};
+	for (const auto maximum : {policy::VideoTuple{2560, 1440, 60, 1}, policy::VideoTuple{1920, 1080, 60, 1}}) {
+		const policy::VideoTuple expected{maximum.width, (1440 * maximum.width / width / 2) * 2, 60, 1};
+		const auto bounded = policy::boundCurrentToSupportedTier(current, maximum.width, maximum.height);
+		CHECK(policy::sameVideo(bounded, expected));
+		const auto tested = policy::benchmarkCeiling(current, maximum.width, maximum.height, 60, 1);
+		CHECK(policy::sameVideo(tested, expected));
+		CHECK(policy::sameVideo(policy::select(tested, maximum.height == 1440 ? 7500 : 6000, "nvenc", policy::QualityProfile::Twitch).video, expected));
+		for (const auto &candidate : policy::candidates(tested)) {
+			CHECK(candidate.width <= maximum.width);
+			CHECK(candidate.height <= maximum.height);
+			CHECK(policy::sameVideo(candidate, expected));
+		}
+		CHECK(policy::sameVideo(policy::recommendationCeiling(tested, bounded, false), expected));
+	}
+	const auto preScaled = policy::boundCurrentToSupportedTier({1920, 802, 30, 1}, 2560, 1440);
+	CHECK(policy::sameVideo(preScaled, {1920, 802, 30, 1}));
+	CHECK(policy::sameVideo(policy::benchmarkCeiling({1920, 802, 30, 1}, 2560, 1440, 60, 1), preScaled));
+}
+
+TEST_CASE("Auto Optimizer preserves other custom aspects within caller limits")
 {
 	const std::vector<policy::VideoTuple> custom = {
 		{1600, 1000, 30, 1}, // 16:10
 		{1024, 768, 30, 1},  // 4:3
-		{2560, 1080, 30, 1}, // ultrawide
 	};
 	for (const auto &current : custom) {
 		CAPTURE(current.width, current.height);
-		CHECK(policy::sameVideo(policy::boundCurrentToSupportedTier(current, 640, 360), current));
+		const auto bounded = policy::boundCurrentToSupportedTier(current, 640, 360);
+		CHECK(bounded.width <= 640);
+		CHECK(bounded.height <= 360);
+		CHECK(bounded.fpsNum == current.fpsNum);
 		const auto ceiling = policy::benchmarkCeiling(current, 1920, 1080, 60, 1);
 		CHECK(policy::sameVideo(ceiling, current));
 		const auto options = policy::candidates(ceiling);