From 54999d15077b986bd993a02fb19a82525ffbd224 Mon Sep 17 00:00:00 2001
From: BehroozRezvani <brezvani@outlook.com>
Date: Sun, 22 Mar 2026 04:37:20 +0000
Subject: [PATCH 01/98] Add Zed config files to gitignore

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 4688d5fa52..a3911be3a0 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,6 +69,9 @@ CMakeSettings.json
 *PVS-Studio*
 PVS/*
 
+# Zed Editor files
+.zed/*
+
 # Ignore other system generated files
 x64/*
 rpcs3/x64/*

From e5840ab8680f896084d766a92f6e20d6c4b12c6a Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 22 Mar 2026 13:29:58 +0100
Subject: [PATCH 02/98] Qt: fix audio timer loop

---
 rpcs3/rpcs3qt/game_list_grid_item.cpp | 1 +
 rpcs3/rpcs3qt/qt_video_source.cpp     | 1 +
 2 files changed, 2 insertions(+)

diff --git a/rpcs3/rpcs3qt/game_list_grid_item.cpp b/rpcs3/rpcs3qt/game_list_grid_item.cpp
index 928a5fa264..a3952a264a 100644
--- a/rpcs3/rpcs3qt/game_list_grid_item.cpp
+++ b/rpcs3/rpcs3qt/game_list_grid_item.cpp
@@ -77,6 +77,7 @@ bool game_list_grid_item::event(QEvent* event)
 		set_active(true);
 		break;
 	case QEvent::HoverLeave:
+	case QEvent::FocusOut:
 		set_active(false);
 		break;
 	default:
diff --git a/rpcs3/rpcs3qt/qt_video_source.cpp b/rpcs3/rpcs3qt/qt_video_source.cpp
index e05b997565..1f60800752 100644
--- a/rpcs3/rpcs3qt/qt_video_source.cpp
+++ b/rpcs3/rpcs3qt/qt_video_source.cpp
@@ -199,6 +199,7 @@ void qt_video_source::start_movie_timer()
 	if (!m_video_timer)
 	{
 		m_video_timer = std::make_unique<QTimer>();
+		m_video_timer->setSingleShot(true);
 		QObject::connect(m_video_timer.get(), &QTimer::timeout, m_video_timer.get(), [this]()
 		{
 			if (!m_active) return;

From 1eb72e4b717af63b599fbca00aeada0b81f18ae7 Mon Sep 17 00:00:00 2001
From: Ani <ani-leo@outlook.com>
Date: Sun, 22 Mar 2026 14:58:21 +0100
Subject: [PATCH 03/98] rpcs3: Add missing #include <climits>, fix gcc-16
 compilation

---
 rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp | 1 +
 rpcs3/util/atomic.cpp                   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
index 91ee7e2426..b8d9ba75b0 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
@@ -10,6 +10,7 @@
 
 #include "cellDmuxPamf.h"
 #include <ranges>
+#include <climits>
 
 vm::gvar<CellDmuxCoreOps> g_cell_dmux_core_ops_pamf;
 vm::gvar<CellDmuxCoreOps> g_cell_dmux_core_ops_raw_es;
diff --git a/rpcs3/util/atomic.cpp b/rpcs3/util/atomic.cpp
index 595162cd04..59f0eebe49 100644
--- a/rpcs3/util/atomic.cpp
+++ b/rpcs3/util/atomic.cpp
@@ -49,6 +49,7 @@ static bool has_waitv()
 #include <cstdint>
 #include <array>
 #include <random>
+#include <climits>
 
 #include "asm.hpp"
 #include "endian.hpp"

From b607993b7b5ba79d6e253aa566766167e19eb154 Mon Sep 17 00:00:00 2001
From: Ani <ani-leo@outlook.com>
Date: Sun, 22 Mar 2026 15:11:30 +0100
Subject: [PATCH 04/98] overlay: Remove redundant redeclaration

Fixes one gcc compilation warning
---
 rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.h b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.h
index 13f47eb41e..ba8b730d44 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.h
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.h
@@ -10,8 +10,6 @@ namespace rsx
 {
 	namespace overlays
 	{
-		void play_sound(sound_effect sound, std::optional<f32> volume);
-
 		struct home_menu_settings : public home_menu_page
 		{
 		public:

From a0c91bf96a235e84de4ae834e6db659077e42a6e Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 21 Mar 2026 23:11:41 +0300
Subject: [PATCH 05/98] overlays: Use SDF equations to represent curved shapes

---
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp   | 113 +++++++-----------
 rpcs3/Emu/RSX/Overlays/overlay_controls.h     |  36 +++++-
 .../Program/GLSLSnippets/OverlayRenderFS.glsl |  74 ++++++++++++
 rpcs3/Emu/RSX/Program/RSXOverlay.h            |  17 ++-
 4 files changed, 167 insertions(+), 73 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index 02b0ff5a68..0a1af3c6c5 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -585,6 +585,18 @@ namespace rsx
 			return result;
 		}
 
+		void overlay_element::configure_sdf(compiled_resource::command_config& config, sdf_function func)
+		{
+			config.sdf_config.func = func;
+			config.sdf_config.cx = margin_left + x + (w / 2.f);
+			config.sdf_config.cy = margin_top + y + (h / 2.f);
+			config.sdf_config.hx = w / 2.f;
+			config.sdf_config.hy = h / 2.f;
+			config.sdf_config.br = 0.f;
+			config.sdf_config.bw = border_size;
+			config.sdf_config.border_color = border_color;
+		}
+
 		compiled_resource& overlay_element::get_compiled()
 		{
 			if (is_compiled())
@@ -609,6 +621,14 @@ namespace rsx
 			config.pulse_sinus_offset = pulse_sinus_offset;
 			config.pulse_speed_modifier = pulse_speed_modifier;
 
+			if (border_size != 0 &&
+				border_color.a > 0.f &&
+				w > border_size &&
+				h > border_size)
+			{
+				configure_sdf(config, sdf_function::box);
+			}
+
 			auto& verts = compiled_resources_temp.draw_commands.front().verts;
 			verts.resize(4);
 
@@ -1095,82 +1115,33 @@ namespace rsx
 				return compiled_resources;
 			}
 
-#ifdef __APPLE__
-			if (true)
-#else
-			if (radius == 0 || radius > (w / 2))
-#endif
+			overlay_element::get_compiled();
+			auto& config = compiled_resources.draw_commands.front().config;
+			configure_sdf(config, sdf_function::rounded_box);
+			config.sdf_config.br = radius;
+
+			m_is_compiled = true;
+			return compiled_resources;
+		}
+
+		compiled_resource& ellipse::get_compiled()
+		{
+			if (is_compiled())
+			{
+				return compiled_resources;
+			}
+
+			compiled_resources.clear();
+
+			if (!is_visible())
 			{
-				// Invalid radius
-				compiled_resources = overlay_element::get_compiled();
 				m_is_compiled = true;
 				return compiled_resources;
 			}
 
-			compiled_resource compiled_resources_temp = {};
-			compiled_resources_temp.append({}); // Bg horizontal mid
-			compiled_resources_temp.append({}); // Bg horizontal top
-			compiled_resources_temp.append({}); // Bg horizontal bottom
-			compiled_resources_temp.append({}); // Bg upper-left
-			compiled_resources_temp.append({}); // Bg lower-left
-			compiled_resources_temp.append({}); // Bg upper-right
-			compiled_resources_temp.append({}); // Bg lower-right
-
-			for (auto& draw_cmd : compiled_resources_temp.draw_commands)
-			{
-				auto& config = draw_cmd.config;
-				config.color = back_color;
-				config.disable_vertex_snap = true;
-				config.pulse_glow = pulse_effect_enabled;
-				config.pulse_sinus_offset = pulse_sinus_offset;
-				config.pulse_speed_modifier = pulse_speed_modifier;
-			}
-
-			auto& bg0 = compiled_resources_temp.draw_commands[0];
-			auto& bg1 = compiled_resources_temp.draw_commands[1];
-			auto& bg2 = compiled_resources_temp.draw_commands[2];
-
-			bg0.verts.emplace_back(f32(x), f32(y + radius), 0.f, 0.f);
-			bg0.verts.emplace_back(f32(x + w), f32(y + radius), 0.f, 0.f);
-			bg0.verts.emplace_back(f32(x), f32(y + h) - radius, 0.f, 0.f);
-			bg0.verts.emplace_back(f32(x + w), f32(y + h) - radius, 0.f, 0.f);
-
-			bg1.verts.emplace_back(f32(x + radius), f32(y), 0.f, 0.f);
-			bg1.verts.emplace_back(f32(x + w) - radius, f32(y), 0.f, 0.f);
-			bg1.verts.emplace_back(f32(x + radius), f32(y + radius), 0.f, 0.f);
-			bg1.verts.emplace_back(f32(x + w) - radius, f32(y + radius), 0.f, 0.f);
-
-			bg2.verts.emplace_back(f32(x + radius), f32(y + h) - radius, 0.f, 0.f);
-			bg2.verts.emplace_back(f32(x + w) - radius, f32(y + h) - radius, 0.f, 0.f);
-			bg2.verts.emplace_back(f32(x + radius), f32(y + h), 0.f, 0.f);
-			bg2.verts.emplace_back(f32(x + w) - radius, f32(y + h), 0.f, 0.f);
-
-			// Generate the quadrants
-			const f32 corners[4][2] =
-			{
-				{ f32(x + radius), f32(y + radius) },
-				{ f32(x + radius), f32(y + h) - radius },
-				{ f32(x + w) - radius, f32(y + radius) },
-				{ f32(x + w) - radius, f32(y + h) - radius }
-			};
-
-			const f32 radius_f = static_cast<f32>(radius);
-			const f32 scale[4][2] =
-			{
-				{ -radius_f, -radius_f },
-				{ -radius_f, +radius_f },
-				{ +radius_f, -radius_f },
-				{ +radius_f, +radius_f }
-			};
-
-			for (int i = 0; i < 4; ++i)
-			{
-				auto& command = compiled_resources_temp.draw_commands[i + 3];
-				command.config.primitives = rsx::overlays::primitive_type::triangle_fan;
-				command.verts = generate_unit_quadrant(num_control_points, corners[i], scale[i]);
-			}
-
-			compiled_resources.add(std::move(compiled_resources_temp), margin_left, margin_top);
+			rounded_rect::get_compiled();
+			auto& config = compiled_resources.draw_commands.front().config;
+			configure_sdf(config, sdf_function::ellipse);
 
 			m_is_compiled = true;
 			return compiled_resources;
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.h b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
index dcfe33b199..0932eaa9ed 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
@@ -31,6 +31,14 @@ namespace rsx
 			triangle_fan = 4
 		};
 
+		enum class sdf_function : u8
+		{
+			none = 0,
+			ellipse,
+			box,
+			rounded_box,
+		};
+
 		struct image_info_base
 		{
 			int w = 0, h = 0, channels = 0;
@@ -95,6 +103,20 @@ namespace rsx
 
 		struct compiled_resource
 		{
+			struct sdf_config_t
+			{
+				sdf_function func = sdf_function::none;
+
+				f32 cx; // Center x
+				f32 cy; // Center y
+				f32 hx; // Half-size in X
+				f32 hy; // Half-size in Y
+				f32 br; // Border radius
+				f32 bw; // Border width
+
+				color4f border_color;
+			};
+
 			struct command_config
 			{
 				primitive_type primitives = primitive_type::quad_list;
@@ -105,6 +127,8 @@ namespace rsx
 				f32 pulse_sinus_offset = 0.0f; // The current pulse offset
 				f32 pulse_speed_modifier = 0.005f;
 
+				sdf_config_t sdf_config;
+
 				areaf clip_rect = {};
 				bool clip_region = false;
 
@@ -171,6 +195,9 @@ namespace rsx
 			f32 pulse_sinus_offset = 0.0f; // The current pulse offset
 			f32 pulse_speed_modifier = 0.005f;
 
+			u8 border_size = 0;
+			color4f border_color = { 0.f, 0.f, 0.f, 1.f };
+
 			// Analog to command_config::get_sinus_value
 			// Apply modifier for sinus pulse. Resets the pulse. For example:
 			//     0 -> reset to 0.5 rising
@@ -237,6 +264,8 @@ namespace rsx
 
 		protected:
 			bool m_is_compiled = false; // Only use m_is_compiled as a getter in is_compiled() if possible
+
+			void configure_sdf(compiled_resource::command_config& config, sdf_function func);
 		};
 
 		struct layout_container : public overlay_element
@@ -317,12 +346,17 @@ namespace rsx
 		struct rounded_rect : public overlay_element
 		{
 			u8 radius = 5;
-			u8 num_control_points = 8; // Smoothness control
 
 			using overlay_element::overlay_element;
 			compiled_resource& get_compiled() override;
 		};
 
+		struct ellipse : public rounded_rect
+		{
+			using rounded_rect::rounded_rect;
+			compiled_resource& get_compiled() override;
+		};
+
 		struct image_view : public overlay_element
 		{
 		protected:
diff --git a/rpcs3/Emu/RSX/Program/GLSLSnippets/OverlayRenderFS.glsl b/rpcs3/Emu/RSX/Program/GLSLSnippets/OverlayRenderFS.glsl
index 84fdfdb8b7..6bf8b07bee 100644
--- a/rpcs3/Emu/RSX/Program/GLSLSnippets/OverlayRenderFS.glsl
+++ b/rpcs3/Emu/RSX/Program/GLSLSnippets/OverlayRenderFS.glsl
@@ -13,6 +13,11 @@ R"(
 #define SAMPLER_MODE_FONT3D    2
 #define SAMPLER_MODE_TEXTURE2D 3
 
+#define SDF_DISABLED  0
+#define SDF_ELLIPSE   1
+#define SDF_BOX       2
+#define SDF_ROUND_BOX 3
+
 #ifdef VULKAN
 	layout(set=0, binding=0) uniform sampler2D fs0;
 	layout(set=0, binding=1) uniform sampler2DArray fs1;
@@ -34,11 +39,17 @@ layout(%push_block) uniform FragmentConfiguration
 	uint fragment_config;
 	float timestamp;
 	float blur_intensity;
+	vec4 sdf_params;
+	vec4 sdf_origin;
+	vec4 sdf_border_color;
 };
 #else
 	uniform uint fragment_config;
 	uniform float timestamp;
 	uniform float blur_intensity;
+	uniform vec4 sdf_params;
+	uniform vec2 sdf_origin;
+	uniform vec4 sdf_border_color;
 #endif
 
 struct config_t
@@ -46,6 +57,7 @@ struct config_t
 	bool clip_fragments;
 	bool use_pulse_glow;
 	uint sampler_mode;
+	uint sdf;
 };
 
 config_t unpack_fragment_options()
@@ -54,9 +66,64 @@ config_t unpack_fragment_options()
 	result.clip_fragments = bitfieldExtract(fragment_config, 0, 1) != 0;
 	result.use_pulse_glow = bitfieldExtract(fragment_config, 1, 1) != 0;
 	result.sampler_mode = bitfieldExtract(fragment_config, 2, 2);
+	result.sdf = bitfieldExtract(fragment_config, 4, 2);
 	return result;
 }
 
+vec4 SDF_blend(
+	const in float sd,
+	const in float border_width,
+	const in vec4 inner_color,
+	const in vec4 border_color,
+	const in vec4 outer_color)
+{
+	// Crucially, we need to get the derivative without subracting the border width.
+	// Subtracting the border width makes the function non-continuous and makes the jaggies hard to get rid of.
+	float fw = fwidth(sd);
+
+	// Compute the two transition points. The inner edge is of course biased by the border amount as the clamping point
+	// Treat smoothstep as fancy clamp where e0 < x < e1
+	float a = smoothstep(-border_width + fw, -border_width - fw, sd); // inner edge transition
+	float b = smoothstep(fw, -fw, sd);                                // outer edge transition
+
+	// Mix the 3 colors with the transition values.
+	vec4 color = mix(outer_color, border_color, b);
+	color      = mix(color, inner_color, a);
+	return color;
+}
+
+float SDF_fn(const in uint sdf)
+{
+	const vec2 p = floor(gl_FragCoord.xy) - sdf_origin.xy;   // Screen-spac distance
+	const vec2 hs = sdf_params.xy;                           // Half size
+	const float r = sdf_params.z;                            // Radius (for round box, ellipses use half size instead)
+	vec2 v;                                                  // Scratch
+	float d;                                                 // Distance calculated
+
+	switch (sdf)
+	{
+	case SDF_ELLIPSE:
+		// Slightly inaccurate hack, but good enough for classification and allows oval shapes
+		d = length(p / hs) - 1.f;
+		// Now we need to correct for the border because the circle was scaled down to a unit
+		return d * length(hs);
+	case SDF_BOX:
+		// Insanity, reduced junction of 3 functions
+		// If for each axis the axis-aligned distance = D then you can select/clamp each axis separately by doing a max(D, 0) on all dimensions
+		// Length then does the squareroot transformation.
+		// The second term is to add back the inner distance which is useful for rendering borders
+		v = abs(p) - hs;
+		return length(max(v, 0.f)) + min(max(v.x, v.y), 0.0);
+	case SDF_ROUND_BOX:
+		// Modified BOX SDF.
+		// The half box size is shrunk by R in it's diagonal, but we add radius back into the output to bias the output again
+		v = abs(p) - (hs - r);
+		return length(max(v, 0.f)) + min(max(v.x, v.y), 0.0) - r;
+	default:
+		return -1.f;
+	}
+}
+
 vec4 blur_sample(sampler2D tex, vec2 coord, vec2 tex_offset)
 {
 	vec2 coords[9];
@@ -125,6 +192,13 @@ void main()
 		diff_color.a *= (sin(timestamp) + 1.f) * 0.5f;
 	}
 
+	if (config.sdf != SDF_DISABLED)
+	{
+		const float border_w = sdf_params.w; // Border width
+		const float d = SDF_fn(config.sdf);
+		diff_color = SDF_blend(d, border_w, diff_color, sdf_border_color, vec4(0.));
+	}
+
 	switch (config.sampler_mode)
 	{
 	default:
diff --git a/rpcs3/Emu/RSX/Program/RSXOverlay.h b/rpcs3/Emu/RSX/Program/RSXOverlay.h
index ebb2071a8b..42ee92823d 100644
--- a/rpcs3/Emu/RSX/Program/RSXOverlay.h
+++ b/rpcs3/Emu/RSX/Program/RSXOverlay.h
@@ -23,7 +23,8 @@ namespace rsx
 			{
 				fragment_clip_bit = 0,
 				pulse_glow_bit = 1,
-				sampling_mode_bit = 2
+				sampling_mode_bit = 2,
+				sdf_func_offset_bit = 4
 			};
 
 		public:
@@ -51,6 +52,13 @@ namespace rsx
 				return *this;
 			}
 
+			fragment_options& set_sdf(sdf_function func)
+			{
+				value &= ~(0x3 << e_offsets::sdf_func_offset_bit);
+				value |= (static_cast<u32>(func) << e_offsets::sdf_func_offset_bit);
+				return *this;
+			}
+
 			u32 get() const
 			{
 				return value;
@@ -74,6 +82,13 @@ namespace rsx
 				}
 			}
 
+			void set_bits(u32 offset, u32 count, u32 set)
+			{
+				const u32 mask = (0xffffffffu >> (32 - count)) << offset;
+				value &= ~mask;
+				value |= set;
+			}
+
 		public:
 			vertex_options& disable_vertex_snap(bool enable)
 			{

From 45bae0046a3e792ae20c572c863a5347d8ac594b Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 21 Mar 2026 23:14:34 +0300
Subject: [PATCH 06/98] vk: Add support for basic SDF rendering

- Does not support scaled coordinates yet
---
 rpcs3/Emu/RSX/VK/VKOverlays.cpp | 21 +++++++++++++++++++--
 rpcs3/Emu/RSX/VK/VKOverlays.h   |  2 ++
 2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/RSX/VK/VKOverlays.cpp b/rpcs3/Emu/RSX/VK/VKOverlays.cpp
index 55daab4a90..c555e7a341 100644
--- a/rpcs3/Emu/RSX/VK/VKOverlays.cpp
+++ b/rpcs3/Emu/RSX/VK/VKOverlays.cpp
@@ -510,7 +510,7 @@ namespace vk
 				glsl::input_type_push_constant,
 				0,
 				0,
-				glsl::push_constant_ref {.offset = 68, .size = 12 }
+				glsl::push_constant_ref {.offset = 68, .size = 60 }
 			)
 		);
 		return result;
@@ -527,6 +527,10 @@ namespace vk
 		// 68: uint fragment_config;
 		// 72: float timestamp;
 		// 76: float blur_intensity;
+		// 80: vec4 sdf_params;
+		// 96: vec2 sdf_origin;
+		// 104: vec2 reserved;
+		// 112: vec4 sdf_border_color;
 
 		f32 push_buf[32];
 		// 1. Vertex config (00 - 63)
@@ -557,13 +561,24 @@ namespace vk
 			.texture_mode(m_texture_type)
 			.clip_fragments(m_clip_enabled)
 			.pulse_glow(m_pulse_glow)
+			.set_sdf(m_sdf_config.func)
 			.get();
 
 		push_buf[0] = std::bit_cast<f32>(frag_config);
 		push_buf[1] = m_time;
 		push_buf[2] = m_blur_strength;
+		push_buf[3] = m_sdf_config.hx;
+		push_buf[4] = m_sdf_config.hy;
+		push_buf[5] = m_sdf_config.br;
+		push_buf[6] = m_sdf_config.bw;
+		push_buf[7] = m_sdf_config.cx;
+		push_buf[8] = m_sdf_config.cy;
+		push_buf[9] = 0.f;
+		push_buf[10] = 0.f;
 
-		vkCmdPushConstants(cmd, program->layout(), VK_SHADER_STAGE_FRAGMENT_BIT, 68, 12, push_buf);
+		std::memcpy(push_buf + 11, m_sdf_config.border_color.rgba, 16);
+
+		vkCmdPushConstants(cmd, program->layout(), VK_SHADER_STAGE_FRAGMENT_BIT, 68, 60, push_buf);
 	}
 
 	void ui_overlay_renderer::set_primitive_type(rsx::overlays::primitive_type type)
@@ -644,6 +659,8 @@ namespace vk
 			m_clip_region = command.config.clip_rect;
 			m_disable_vertex_snap = command.config.disable_vertex_snap;
 
+			m_sdf_config = command.config.sdf_config;
+
 			vk::image_view* src = nullptr;
 			switch (command.config.texture_ref)
 			{
diff --git a/rpcs3/Emu/RSX/VK/VKOverlays.h b/rpcs3/Emu/RSX/VK/VKOverlays.h
index 414c7c4945..de2c218ebe 100644
--- a/rpcs3/Emu/RSX/VK/VKOverlays.h
+++ b/rpcs3/Emu/RSX/VK/VKOverlays.h
@@ -132,6 +132,8 @@ namespace vk
 		areaf m_clip_region;
 		coordf m_viewport;
 
+		rsx::overlays::compiled_resource::sdf_config_t m_sdf_config{};
+
 		std::vector<std::unique_ptr<vk::image>> resources;
 		std::unordered_map<u64, std::unique_ptr<vk::image>> font_cache;
 		std::unordered_map<u64, std::unique_ptr<vk::image_view>> view_cache;

From 57e37862f44292b73540e8d8939a71ac9d953d81 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 21 Mar 2026 23:18:36 +0300
Subject: [PATCH 07/98] overlays: Use ellipse SDF for circles

---
 rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp | 2 +-
 rpcs3/Emu/RSX/Overlays/overlay_slider.cpp   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
index f7cb19237e..d3199f0866 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
@@ -99,7 +99,7 @@ namespace rsx::overlays
 		}
 
 		auto ellipse_part = std::make_unique<rounded_rect>();
-		auto circle_part = std::make_unique<rounded_rect>();
+		auto circle_part = std::make_unique<ellipse>();
 
 		ellipse_part->set_size(dim * 2, dim / 2);
 		ellipse_part->set_pos(0, dim / 4);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
index bf00563ef5..0040d5b20d 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
@@ -29,7 +29,7 @@ namespace rsx::overlays
 		// Base components
 		auto background = std::make_unique<rounded_rect>();
 		auto foreground = std::make_unique<rounded_rect>();
-		auto indicator = std::make_unique<rounded_rect>();
+		auto indicator = std::make_unique<ellipse>();
 		auto value_label = std::make_unique<label>();
 		auto min_label = std::make_unique<label>();
 		auto max_label = std::make_unique<label>();

From 5a94adcf2692b6d02d929d62823123d33c4f4bfd Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 15:54:29 +0300
Subject: [PATCH 08/98] overlays: Implement SDF config transforms

---
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp | 34 +++++++++++++++++++++
 rpcs3/Emu/RSX/Overlays/overlay_controls.h   |  5 +++
 rpcs3/Emu/RSX/VK/VKOverlays.cpp             |  1 +
 3 files changed, 40 insertions(+)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index 0a1af3c6c5..67c9fdf36f 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -54,6 +54,40 @@ namespace rsx
 			return result;
 		}
 
+		void compiled_resource::sdf_config_t::transform(const areaf& target_viewport, const sizef& virtual_viewport)
+		{
+			const f32 scale_x = target_viewport.width() / virtual_viewport.width;
+			const f32 scale_y = target_viewport.height() / virtual_viewport.height;
+
+			// Ideally the average should match the x and y scaling but arithmetic drift shifts the values around a bit.
+			// Also we need a way to define perfect circles when the aspect ratio is not respected.
+			const f32 scale_av = (scale_x + scale_y) / 2;
+
+			hx *= scale_x;
+			hy *= scale_y;
+			br *= scale_av;
+			bw *= scale_av;
+
+			// Account for flipped viewport
+			if (target_viewport.x2 < target_viewport.x1)
+			{
+				cx = target_viewport.width() -  (cx * scale_x) + target_viewport.x2;
+			}
+			else
+			{
+				cx = cx * scale_x + target_viewport.x1;
+			}
+
+			if (target_viewport.y2 < target_viewport.y1)
+			{
+				cy = target_viewport.height() - (cy * scale_y) + target_viewport.y2;
+			}
+			else
+			{
+				cy = cy * scale_y + target_viewport.y1;
+			}
+		}
+
 		image_info::image_info(const std::string& filename, bool grayscaled)
 		{
 			fs::file f(filename, fs::read + fs::isfile);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.h b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
index 0932eaa9ed..7b88af2e12 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
@@ -115,6 +115,11 @@ namespace rsx
 				f32 bw; // Border width
 
 				color4f border_color;
+
+				// Transform a SDF definition from one reference frame to another
+				// Target viewport - your actual render area
+				// Virtual viewport - the internal design viewport
+				void transform(const areaf& target_viewport, const sizef& virtual_viewport);
 			};
 
 			struct command_config
diff --git a/rpcs3/Emu/RSX/VK/VKOverlays.cpp b/rpcs3/Emu/RSX/VK/VKOverlays.cpp
index c555e7a341..0436ab527d 100644
--- a/rpcs3/Emu/RSX/VK/VKOverlays.cpp
+++ b/rpcs3/Emu/RSX/VK/VKOverlays.cpp
@@ -660,6 +660,7 @@ namespace vk
 			m_disable_vertex_snap = command.config.disable_vertex_snap;
 
 			m_sdf_config = command.config.sdf_config;
+			m_sdf_config.transform(static_cast<areaf>(viewport), { m_scale_offset.x, m_scale_offset.y });
 
 			vk::image_view* src = nullptr;
 			switch (command.config.texture_ref)

From 2bad4f47f1f668d239bec2e9c5a92329732b0386 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 16:22:02 +0300
Subject: [PATCH 09/98] gl: Integrate SDF rendering functionality

---
 rpcs3/Emu/RSX/GL/GLOverlays.cpp | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/RSX/GL/GLOverlays.cpp b/rpcs3/Emu/RSX/GL/GLOverlays.cpp
index 9e588d5df2..38f66c1edf 100644
--- a/rpcs3/Emu/RSX/GL/GLOverlays.cpp
+++ b/rpcs3/Emu/RSX/GL/GLOverlays.cpp
@@ -399,8 +399,11 @@ namespace gl
 
 	void ui_overlay_renderer::run(gl::command_context& cmd_, const areau& viewport, GLuint target, rsx::overlays::overlay& ui, bool flip_vertically)
 	{
-		program_handle.uniforms["viewport"] = color4f(static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()), static_cast<f32>(viewport.x1), static_cast<f32>(viewport.y1));
-		program_handle.uniforms["ui_scale"] = color4f(static_cast<f32>(ui.virtual_width), static_cast<f32>(ui.virtual_height), 1.f, 1.f);
+		const auto ui_scale = color4f(static_cast<f32>(ui.virtual_width), static_cast<f32>(ui.virtual_height), 1.f, 1.f);
+		const auto ui_viewport = color4f(static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()), static_cast<f32>(viewport.x1), static_cast<f32>(viewport.y1));
+
+		program_handle.uniforms["viewport"] = ui_viewport;
+		program_handle.uniforms["ui_scale"] = ui_scale;
 
 		saved_sampler_state save_30(30, m_sampler);
 		saved_sampler_state save_31(31, m_sampler);
@@ -458,12 +461,24 @@ namespace gl
 				.texture_mode(texture_mode)
 				.clip_fragments(cmd.config.clip_region)
 				.pulse_glow(cmd.config.pulse_glow)
+				.set_sdf(cmd.config.sdf_config.func)
 				.get();
 
 			program_handle.uniforms["timestamp"] = cmd.config.get_sinus_value();
 			program_handle.uniforms["albedo"] = cmd.config.color;
 			program_handle.uniforms["clip_bounds"] = cmd.config.clip_rect;
 			program_handle.uniforms["blur_intensity"] = static_cast<f32>(cmd.config.blur_strength);
+
+			if (cmd.config.sdf_config.func != rsx::overlays::sdf_function::none)
+			{
+				auto sdf_config = cmd.config.sdf_config;
+				sdf_config.transform(static_cast<areaf>(viewport).flipped_vertical(), {ui_scale.x, ui_scale.y});
+
+				program_handle.uniforms["sdf_params"] = color4f(sdf_config.hx, sdf_config.hy, sdf_config.br, sdf_config.bw);
+				program_handle.uniforms["sdf_origin"] = color2f(sdf_config.cx, sdf_config.cy);
+				program_handle.uniforms["sdf_border_color"] = sdf_config.border_color;
+			}
+
 			overlay_pass::run(cmd_, viewport, target, gl::image_aspect::color, true);
 		}
 

From 61b1bd7ead64b85658b653ccd8ff61917aa12fda Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 16:36:02 +0300
Subject: [PATCH 10/98] overlays/sdf: Take element padding into account

- Helps to smooth out the outer edges of ellipses and circles
---
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp | 13 +++++++++----
 rpcs3/Emu/RSX/Overlays/overlay_slider.cpp   |  1 +
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index 67c9fdf36f..b311dff7fb 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -621,11 +621,16 @@ namespace rsx
 
 		void overlay_element::configure_sdf(compiled_resource::command_config& config, sdf_function func)
 		{
+			const f32 rx = padding_left + static_cast<f32>(x);
+			const f32 rw = static_cast<f32>(w) - (padding_left + padding_right);
+			const f32 ry = padding_top + static_cast<f32>(y);
+			const f32 rh = static_cast<f32>(h) - (padding_top + padding_bottom);
+
 			config.sdf_config.func = func;
-			config.sdf_config.cx = margin_left + x + (w / 2.f);
-			config.sdf_config.cy = margin_top + y + (h / 2.f);
-			config.sdf_config.hx = w / 2.f;
-			config.sdf_config.hy = h / 2.f;
+			config.sdf_config.cx = margin_left + rx + (rw / 2.f);
+			config.sdf_config.cy = margin_top + ry + (rh / 2.f);
+			config.sdf_config.hx = rw / 2.f;
+			config.sdf_config.hy = rh / 2.f;
 			config.sdf_config.br = 0.f;
 			config.sdf_config.bw = border_size;
 			config.sdf_config.border_color = border_color;
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
index 0040d5b20d..c0be8cb275 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
@@ -36,6 +36,7 @@ namespace rsx::overlays
 
 		indicator->radius = slider_indicator_radius;
 		indicator->set_size(slider_indicator_dia, slider_indicator_dia);
+		indicator->set_padding(2);
 		indicator->back_color = color4f(1.f);
 
 		background->radius = slider_rail_thickness / 2;

From 35907bcfc8e523743ae8ee1325c2c616cc6792d6 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 17:01:17 +0300
Subject: [PATCH 11/98] overlays: Redesign switches

---
 rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp | 25 +++++++++++----------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
index d3199f0866..aa7d77cc1a 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
@@ -84,7 +84,7 @@ namespace rsx::overlays
 
 	void switchbox::set_size(u16 w, u16 h)
 	{
-		const u16 dim = std::min(w, h);
+		const u16 dim = std::max<u16>(std::min(w, h), 15);
 		box_layout::set_size(w, h);
 
 		clear_items();
@@ -93,21 +93,17 @@ namespace rsx::overlays
 		m_back_ellipse = nullptr;
 		m_front_circle = nullptr;
 
-		if (dim < 4)
-		{
-			return;
-		}
-
 		auto ellipse_part = std::make_unique<rounded_rect>();
 		auto circle_part = std::make_unique<ellipse>();
 
-		ellipse_part->set_size(dim * 2, dim / 2);
-		ellipse_part->set_pos(0, dim / 4);
-		ellipse_part->radius = dim / 4;
+		ellipse_part->set_size(dim * 2, dim);
+		ellipse_part->set_padding(1);
+		ellipse_part->set_pos(0, 0);
+		ellipse_part->radius = (dim - 2) / 2;
 
 		circle_part->set_size(dim, dim);
+		circle_part->set_padding(4);
 		circle_part->set_pos(0, 0);
-		circle_part->radius = dim / 2;
 
 		m_back_ellipse = add_element(ellipse_part);
 		m_front_circle = add_element(circle_part);
@@ -130,13 +126,18 @@ namespace rsx::overlays
 
 		if (m_is_checked)
 		{
-			m_back_ellipse->back_color = this->fore_color * 0.5f;
+			m_back_ellipse->border_color.a = 0.f;
+			m_back_ellipse->border_size = 0;
+			m_back_ellipse->back_color = this->fore_color * 0.75f;
 			m_back_ellipse->back_color.a = 1.f;
-			m_front_circle->back_color = this->fore_color;
+			m_front_circle->back_color = color4f(1.f);
 			m_front_circle->set_pos(this->x + m_front_circle->w, this->y);
 		}
 		else
 		{
+			m_back_ellipse->border_color = this->back_color * 0.75f;
+			m_back_ellipse->border_color.a = 1.f;
+			m_back_ellipse->border_size = 1;
 			m_back_ellipse->back_color = this->back_color * 0.5f;
 			m_back_ellipse->back_color.a = 1.f;
 			m_front_circle->back_color = this->back_color;

From 04f7dd02fd4f9f85ceb8a7294f35c138987ff58e Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 17:25:31 +0300
Subject: [PATCH 12/98] overlays: Fix SDF rendering when scrolling is involved

---
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index b311dff7fb..a3ab1239af 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -293,6 +293,12 @@ namespace rsx
 				{
 					v += vertex(x_offset, y_offset, 0.f, 0.f);
 				}
+
+				if (draw_commands[n].config.sdf_config.func != sdf_function::none)
+				{
+					draw_commands[n].config.sdf_config.cx += x_offset;
+					draw_commands[n].config.sdf_config.cy += y_offset;
+				}
 			}
 		}
 
@@ -309,6 +315,12 @@ namespace rsx
 					v += vertex(x_offset, y_offset, 0.f, 0.f);
 				}
 
+				if (draw_commands[n].config.sdf_config.func != sdf_function::none)
+				{
+					draw_commands[n].config.sdf_config.cx += x_offset;
+					draw_commands[n].config.sdf_config.cy += y_offset;
+				}
+
 				draw_commands[n].config.clip_rect = clip_rect;
 				draw_commands[n].config.clip_region = true;
 			}
@@ -621,14 +633,14 @@ namespace rsx
 
 		void overlay_element::configure_sdf(compiled_resource::command_config& config, sdf_function func)
 		{
-			const f32 rx = padding_left + static_cast<f32>(x);
+			const f32 rx = static_cast<f32>(x) + padding_left;
 			const f32 rw = static_cast<f32>(w) - (padding_left + padding_right);
-			const f32 ry = padding_top + static_cast<f32>(y);
+			const f32 ry = static_cast<f32>(y) + padding_top;
 			const f32 rh = static_cast<f32>(h) - (padding_top + padding_bottom);
 
 			config.sdf_config.func = func;
-			config.sdf_config.cx = margin_left + rx + (rw / 2.f);
-			config.sdf_config.cy = margin_top + ry + (rh / 2.f);
+			config.sdf_config.cx = rx + (rw / 2.f);
+			config.sdf_config.cy = ry + (rh / 2.f);
 			config.sdf_config.hx = rw / 2.f;
 			config.sdf_config.hy = rh / 2.f;
 			config.sdf_config.br = 0.f;

From 32c9c6f515607a206d529822c9e7100888a908bc Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 17:40:26 +0300
Subject: [PATCH 13/98] overlays: Fixups for switch rendering

- Disallow odd numbers for the primary dimension
- Increase the size slightly in home menus
- Disable vertex snapping when rendering SDFs
---
 rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_components.h | 2 +-
 rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp                    | 2 +-
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp                    | 2 ++
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_components.h b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_components.h
index bd9b0e1068..88e1c53324 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_components.h
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_components.h
@@ -16,7 +16,7 @@ namespace rsx
 	{
 		static constexpr u16 menu_entry_height = 40;
 		static constexpr u16 menu_entry_margin = 30;
-		static constexpr u16 menu_checkbox_size = 20;
+		static constexpr u16 menu_checkbox_size = 24;
 		static constexpr u16 element_height = 25;
 
 		enum class page_navigation
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
index aa7d77cc1a..e3cc2689ed 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
@@ -84,7 +84,7 @@ namespace rsx::overlays
 
 	void switchbox::set_size(u16 w, u16 h)
 	{
-		const u16 dim = std::max<u16>(std::min(w, h), 15);
+		const u16 dim = std::max<u16>(std::min(w, h), 14) & ~1u;
 		box_layout::set_size(w, h);
 
 		clear_items();
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index a3ab1239af..e6643915cd 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -646,6 +646,8 @@ namespace rsx
 			config.sdf_config.br = 0.f;
 			config.sdf_config.bw = border_size;
 			config.sdf_config.border_color = border_color;
+
+			config.disable_vertex_snap = true;
 		}
 
 		compiled_resource& overlay_element::get_compiled()

From a2eb4fec535f94daec91e4c00cc3ab5e6c8d5627 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 18:09:17 +0300
Subject: [PATCH 14/98] overlays: Restore slider handles to previous size

- Added padding to smooth out the outer edge transition made the circle too small
---
 rpcs3/Emu/RSX/Overlays/overlay_slider.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
index c0be8cb275..ff09af7994 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
@@ -35,8 +35,9 @@ namespace rsx::overlays
 		auto max_label = std::make_unique<label>();
 
 		indicator->radius = slider_indicator_radius;
-		indicator->set_size(slider_indicator_dia, slider_indicator_dia);
+		indicator->set_size(slider_indicator_dia + 2, slider_indicator_dia + 2);
 		indicator->set_padding(2);
+		indicator->set_pos(0, -2);
 		indicator->back_color = color4f(1.f);
 
 		background->radius = slider_rail_thickness / 2;

From bc6e01c42280896a639932bb94e3f3eca9c11a04 Mon Sep 17 00:00:00 2001
From: schm1dtmac <danonmac@icloud.com>
Date: Sun, 22 Mar 2026 19:00:21 +0000
Subject: [PATCH 15/98] Fix GH & brew breaking macOS builds again

---
 .ci/build-mac.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.ci/build-mac.sh b/.ci/build-mac.sh
index 8e33a09d72..9e16fce4ec 100755
--- a/.ci/build-mac.sh
+++ b/.ci/build-mac.sh
@@ -13,6 +13,7 @@ export HOMEBREW_NO_AUTO_UPDATE=1
 export HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK=1
 export HOMEBREW_NO_ENV_HINTS=1
 export HOMEBREW_NO_INSTALL_CLEANUP=1
+brew update
 brew install -f --overwrite --quiet ccache "llvm@$LLVM_COMPILER_VER"
 brew link -f --overwrite --quiet "llvm@$LLVM_COMPILER_VER"
 if [ "$AARCH64" -eq 1 ]; then

From 5acc263b73b5db50684f357a5f03c7366fa0bf51 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 22 Mar 2026 22:06:44 +0300
Subject: [PATCH 16/98] gl: Properly initialize memory layout definition
 structs

- Also refactors the upload_texture function to be a bit more readable
---
 rpcs3/Emu/RSX/GL/GLTexture.cpp | 285 ++++++++++++++++-----------------
 rpcs3/Emu/RSX/GL/GLTexture.h   |  18 +--
 2 files changed, 151 insertions(+), 152 deletions(-)

diff --git a/rpcs3/Emu/RSX/GL/GLTexture.cpp b/rpcs3/Emu/RSX/GL/GLTexture.cpp
index 64e451e579..6f566b9a82 100644
--- a/rpcs3/Emu/RSX/GL/GLTexture.cpp
+++ b/rpcs3/Emu/RSX/GL/GLTexture.cpp
@@ -717,169 +717,168 @@ namespace gl
 				}
 				}
 			}
+
+			return;
 		}
-		else
+
+		std::pair<void*, u32> upload_scratch_mem = {}, compute_scratch_mem = {};
+		image_memory_requirements mem_info;
+		pixel_buffer_layout mem_layout;
+
+		std::span<std::byte> dst_buffer = staging_buffer;
+		u8 block_size_in_bytes = rsx::get_format_block_size_in_bytes(format);
+		u64 image_linear_size = staging_buffer.size();
+
+		const auto min_required_buffer_size = std::max<u64>(utils::align(image_linear_size * 4, 0x100000), 16 * 0x100000);
+
+		if (driver_caps.ARB_compute_shader_supported)
 		{
-			std::pair<void*, u32> upload_scratch_mem = {}, compute_scratch_mem = {};
-			image_memory_requirements mem_info;
-			pixel_buffer_layout mem_layout;
-
-			std::span<std::byte> dst_buffer = staging_buffer;
-			u8 block_size_in_bytes = rsx::get_format_block_size_in_bytes(format);
-			u64 image_linear_size = staging_buffer.size();
-
-			const auto min_required_buffer_size = std::max<u64>(utils::align(image_linear_size * 4, 0x100000), 16 * 0x100000);
-
-			if (driver_caps.ARB_compute_shader_supported)
+			if (g_upload_transfer_buffer.size() < static_cast<GLsizeiptr>(min_required_buffer_size))
 			{
-				if (g_upload_transfer_buffer.size() < static_cast<GLsizeiptr>(min_required_buffer_size))
-				{
-					g_upload_transfer_buffer.remove();
-					g_upload_transfer_buffer.create(gl::buffer::target::pixel_unpack, min_required_buffer_size);
-				}
-
-				if (g_compute_decode_buffer.size() < min_required_buffer_size)
-				{
-					g_compute_decode_buffer.remove();
-					g_compute_decode_buffer.create(gl::buffer::target::ssbo, min_required_buffer_size);
-				}
+				g_upload_transfer_buffer.remove();
+				g_upload_transfer_buffer.create(gl::buffer::target::pixel_unpack, min_required_buffer_size);
 			}
 
-			for (const rsx::subresource_layout& layout : input_layouts)
+			if (g_compute_decode_buffer.size() < min_required_buffer_size)
 			{
-				if (driver_caps.ARB_compute_shader_supported)
+				g_compute_decode_buffer.remove();
+				g_compute_decode_buffer.create(gl::buffer::target::ssbo, min_required_buffer_size);
+			}
+		}
+
+		for (const rsx::subresource_layout& layout : input_layouts)
+		{
+			if (driver_caps.ARB_compute_shader_supported)
+			{
+				u64 row_pitch = rsx::align2<u64, u64>(layout.width_in_block * block_size_in_bytes, caps.alignment);
+
+				// We're in the "else" branch, so "is_compressed_host_format()" is always false.
+				// Handle emulated compressed formats with host unpack (R8G8 compressed)
+				row_pitch = std::max<u64>(row_pitch, dst->pitch());
+
+				// FIXME: Double-check this logic; it seems like we should always use texels both here and for row_pitch.
+				image_linear_size = row_pitch * layout.height_in_texel * layout.depth;
+
+				compute_scratch_mem = { nullptr, g_compute_decode_buffer.alloc(static_cast<u32>(image_linear_size), 256) };
+				compute_scratch_mem.first = reinterpret_cast<void*>(static_cast<uintptr_t>(compute_scratch_mem.second));
+
+				g_upload_transfer_buffer.reserve_storage_on_heap(static_cast<u32>(image_linear_size));
+				upload_scratch_mem = g_upload_transfer_buffer.alloc_from_heap(static_cast<u32>(image_linear_size), 256);
+				dst_buffer = { reinterpret_cast<std::byte*>(upload_scratch_mem.first), image_linear_size };
+			}
+
+			rsx::io_buffer io_buf = dst_buffer;
+			caps.supports_hw_deswizzle = (is_swizzled && driver_caps.ARB_compute_shader_supported && image_linear_size > 1024);
+			auto op = upload_texture_subresource(io_buf, layout, format, is_swizzled, caps);
+
+			// Define upload region
+			coord3u region;
+			region.x = 0;
+			region.y = 0;
+			region.z = layout.layer;
+			region.width = layout.width_in_texel;
+			region.height = layout.height_in_texel;
+			region.depth = layout.depth;
+
+			if (!driver_caps.ARB_compute_shader_supported)
+			{
+				unpack_settings.swap_bytes(op.require_swap);
+				dst->copy_from(staging_buffer, static_cast<texture::format>(gl_format), static_cast<texture::type>(gl_type), layout.level, region, unpack_settings);
+				continue;
+			}
+
+			// 0. Preconf
+			mem_layout.alignment = static_cast<u8>(caps.alignment);
+			mem_layout.swap_bytes = op.require_swap;
+			mem_layout.format = gl_format;
+			mem_layout.type = gl_type;
+			mem_layout.block_size = block_size_in_bytes;
+
+			// 2. Upload memory to GPU
+			if (!op.require_deswizzle)
+			{
+				g_upload_transfer_buffer.unmap();
+				g_upload_transfer_buffer.copy_to(&g_compute_decode_buffer.get(), upload_scratch_mem.second, compute_scratch_mem.second, image_linear_size);
+			}
+			else
+			{
+				// 2.1 Copy data to deswizzle buf
+				if (g_deswizzle_scratch_buffer.size() < min_required_buffer_size)
 				{
-					u64 row_pitch = rsx::align2<u64, u64>(layout.width_in_block * block_size_in_bytes, caps.alignment);
-
-					// We're in the "else" branch, so "is_compressed_host_format()" is always false.
-					// Handle emulated compressed formats with host unpack (R8G8 compressed)
-					row_pitch = std::max<u64>(row_pitch, dst->pitch());
-
-					// FIXME: Double-check this logic; it seems like we should always use texels both here and for row_pitch.
-					image_linear_size = row_pitch * layout.height_in_texel * layout.depth;
-
-					compute_scratch_mem = { nullptr, g_compute_decode_buffer.alloc(static_cast<u32>(image_linear_size), 256) };
-					compute_scratch_mem.first = reinterpret_cast<void*>(static_cast<uintptr_t>(compute_scratch_mem.second));
-
-					g_upload_transfer_buffer.reserve_storage_on_heap(static_cast<u32>(image_linear_size));
-					upload_scratch_mem = g_upload_transfer_buffer.alloc_from_heap(static_cast<u32>(image_linear_size), 256);
-					dst_buffer = { reinterpret_cast<std::byte*>(upload_scratch_mem.first), image_linear_size };
+					g_deswizzle_scratch_buffer.remove();
+					g_deswizzle_scratch_buffer.create(gl::buffer::target::ssbo, min_required_buffer_size);
 				}
 
-				rsx::io_buffer io_buf = dst_buffer;
-				caps.supports_hw_deswizzle = (is_swizzled && driver_caps.ARB_compute_shader_supported && image_linear_size > 1024);
-				auto op = upload_texture_subresource(io_buf, layout, format, is_swizzled, caps);
+				u32 deswizzle_data_offset = g_deswizzle_scratch_buffer.alloc(static_cast<u32>(image_linear_size), 256);
+				g_upload_transfer_buffer.unmap();
+				g_upload_transfer_buffer.copy_to(&g_deswizzle_scratch_buffer.get(), upload_scratch_mem.second, deswizzle_data_offset, static_cast<u32>(image_linear_size));
 
-				// Define upload region
-				coord3u region;
-				region.x = 0;
-				region.y = 0;
-				region.z = layout.layer;
-				region.width = layout.width_in_texel;
-				region.height = layout.height_in_texel;
-				region.depth = layout.depth;
+				// 2.2 Apply compute transform to deswizzle input and dump it in compute_scratch_mem
+				const auto block_size = op.element_size * op.block_length;
 
-				if (driver_caps.ARB_compute_shader_supported)
+				if (op.require_swap)
 				{
-					// 0. Preconf
-					mem_layout.alignment = static_cast<u8>(caps.alignment);
-					mem_layout.swap_bytes = op.require_swap;
-					mem_layout.format = gl_format;
-					mem_layout.type = gl_type;
-					mem_layout.block_size = block_size_in_bytes;
+					mem_layout.swap_bytes = false;
 
-					// 2. Upload memory to GPU
-					if (!op.require_deswizzle)
+					switch (op.element_size)
 					{
-						g_upload_transfer_buffer.unmap();
-						g_upload_transfer_buffer.copy_to(&g_compute_decode_buffer.get(), upload_scratch_mem.second, compute_scratch_mem.second, image_linear_size);
+					case 1:
+						do_deswizzle_transformation<u8, true>(cmd, block_size,
+							&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
+							static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
+						break;
+					case 2:
+						do_deswizzle_transformation<u16, true>(cmd, block_size,
+							&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
+							static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
+						break;
+					case 4:
+						do_deswizzle_transformation<u32, true>(cmd, block_size,
+							&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
+							static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
+						break;
+					default:
+						fmt::throw_exception("Unimplemented element size deswizzle");
 					}
-					else
-					{
-						// 2.1 Copy data to deswizzle buf
-						if (g_deswizzle_scratch_buffer.size() < min_required_buffer_size)
-						{
-							g_deswizzle_scratch_buffer.remove();
-							g_deswizzle_scratch_buffer.create(gl::buffer::target::ssbo, min_required_buffer_size);
-						}
-
-						u32 deswizzle_data_offset = g_deswizzle_scratch_buffer.alloc(static_cast<u32>(image_linear_size), 256);
-						g_upload_transfer_buffer.unmap();
-						g_upload_transfer_buffer.copy_to(&g_deswizzle_scratch_buffer.get(), upload_scratch_mem.second, deswizzle_data_offset, static_cast<u32>(image_linear_size));
-
-						// 2.2 Apply compute transform to deswizzle input and dump it in compute_scratch_mem
-						const auto block_size = op.element_size * op.block_length;
-
-						if (op.require_swap)
-						{
-							mem_layout.swap_bytes = false;
-
-							switch (op.element_size)
-							{
-							case 1:
-								do_deswizzle_transformation<u8, true>(cmd, block_size,
-									&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
-									static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
-								break;
-							case 2:
-								do_deswizzle_transformation<u16, true>(cmd, block_size,
-									&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
-									static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
-								break;
-							case 4:
-								do_deswizzle_transformation<u32, true>(cmd, block_size,
-									&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
-									static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
-								break;
-							default:
-								fmt::throw_exception("Unimplemented element size deswizzle");
-							}
-						}
-						else
-						{
-							switch (op.element_size)
-							{
-							case 1:
-								do_deswizzle_transformation<u8, false>(cmd, block_size,
-									&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
-									static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
-								break;
-							case 2:
-								do_deswizzle_transformation<u16, false>(cmd, block_size,
-									&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
-									static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
-								break;
-							case 4:
-								do_deswizzle_transformation<u32, false>(cmd, block_size,
-									&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
-									static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
-								break;
-							default:
-								fmt::throw_exception("Unimplemented element size deswizzle");
-							}
-						}
-
-						// Barrier
-						g_deswizzle_scratch_buffer.push_barrier(deswizzle_data_offset, static_cast<u32>(image_linear_size));
-					}
-
-					// 3. Update configuration
-					mem_info.image_size_in_texels = image_linear_size / block_size_in_bytes;
-					mem_info.image_size_in_bytes = image_linear_size;
-					mem_info.memory_required = 0;
-
-					// 4. Dispatch compute routines
-					copy_buffer_to_image(cmd, mem_layout, &g_compute_decode_buffer.get(), dst, compute_scratch_mem.first, layout.level, region, &mem_info);
-
-					// Barrier
-					g_compute_decode_buffer.push_barrier(compute_scratch_mem.second, static_cast<u32>(image_linear_size));
 				}
 				else
 				{
-					unpack_settings.swap_bytes(op.require_swap);
-					dst->copy_from(staging_buffer, static_cast<texture::format>(gl_format), static_cast<texture::type>(gl_type), layout.level, region, unpack_settings);
+					switch (op.element_size)
+					{
+					case 1:
+						do_deswizzle_transformation<u8, false>(cmd, block_size,
+							&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
+							static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
+						break;
+					case 2:
+						do_deswizzle_transformation<u16, false>(cmd, block_size,
+							&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
+							static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
+						break;
+					case 4:
+						do_deswizzle_transformation<u32, false>(cmd, block_size,
+							&g_compute_decode_buffer.get(), compute_scratch_mem.second, &g_deswizzle_scratch_buffer.get(), deswizzle_data_offset,
+							static_cast<u32>(image_linear_size), layout.width_in_texel, layout.height_in_texel, layout.depth);
+						break;
+					default:
+						fmt::throw_exception("Unimplemented element size deswizzle");
+					}
 				}
+
+				// Barrier
+				g_deswizzle_scratch_buffer.push_barrier(deswizzle_data_offset, static_cast<u32>(image_linear_size));
 			}
+
+			// 3. Update configuration
+			mem_info.image_size_in_texels = image_linear_size / block_size_in_bytes;
+			mem_info.image_size_in_bytes = image_linear_size;
+			mem_info.memory_required = 0;
+
+			// 4. Dispatch compute routines
+			copy_buffer_to_image(cmd, mem_layout, &g_compute_decode_buffer.get(), dst, compute_scratch_mem.first, layout.level, region, &mem_info);
+
+			// Barrier
+			g_compute_decode_buffer.push_barrier(compute_scratch_mem.second, static_cast<u32>(image_linear_size));
 		}
 	}
 
diff --git a/rpcs3/Emu/RSX/GL/GLTexture.h b/rpcs3/Emu/RSX/GL/GLTexture.h
index 4a17dae081..6d0bbb18a3 100644
--- a/rpcs3/Emu/RSX/GL/GLTexture.h
+++ b/rpcs3/Emu/RSX/GL/GLTexture.h
@@ -14,20 +14,20 @@ namespace gl
 {
 	struct pixel_buffer_layout
 	{
-		GLenum format;
-		GLenum type;
-		u32    row_length;
-		u8     block_size;
-		bool   swap_bytes;
-		u8     alignment;
+		GLenum format = GL_RGBA;
+		GLenum type = GL_UNSIGNED_BYTE;
+		u32    row_length = 0;
+		u8     block_size = 0;
+		bool   swap_bytes = false;
+		u8     alignment = 0;
 		u8     reserved;
 	};
 
 	struct image_memory_requirements
 	{
-		u64 image_size_in_texels;
-		u64 image_size_in_bytes;
-		u64 memory_required;
+		u64 image_size_in_texels = 0;
+		u64 image_size_in_bytes = 0;
+		u64 memory_required = 0;
 	};
 
 	struct clear_cmd_info

From c19d22ce887c0fb7e768bf1c1a95e8c2e1f7f47b Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Mon, 23 Mar 2026 01:38:57 +0300
Subject: [PATCH 17/98] overlays/sdf: Clamp rounded-rect border radius to never
 exceed the box sides

- If the radius exceeds any half-dimension then the box-shrink subtraction yields a negative.
  That negative introduces a second transition boundary when the classification happens as it transitions back to positive.
  Normally not a big deal but when rendering borders at the transition points it can introduce artifacts.
---
 rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp  |  4 ++--
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp  |  7 +++++--
 rpcs3/Emu/RSX/Overlays/overlay_controls.h    |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_list_view.cpp |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_select.cpp    |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_slider.cpp    | 10 +++++-----
 6 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
index e3cc2689ed..0c5c087ce0 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
@@ -84,7 +84,7 @@ namespace rsx::overlays
 
 	void switchbox::set_size(u16 w, u16 h)
 	{
-		const u16 dim = std::max<u16>(std::min(w, h), 14) & ~1u;
+		const u16 dim = std::max<u16>(std::min(w, h), 14);
 		box_layout::set_size(w, h);
 
 		clear_items();
@@ -99,7 +99,7 @@ namespace rsx::overlays
 		ellipse_part->set_size(dim * 2, dim);
 		ellipse_part->set_padding(1);
 		ellipse_part->set_pos(0, 0);
-		ellipse_part->radius = (dim - 2) / 2;
+		ellipse_part->border_radius = (dim - 2) / 2;
 
 		circle_part->set_size(dim, dim);
 		circle_part->set_padding(4);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index e6643915cd..93148d655c 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -68,7 +68,10 @@ namespace rsx
 			br *= scale_av;
 			bw *= scale_av;
 
-			// Account for flipped viewport
+			// Border radius clamp
+			br = std::min({ br, hx, hy });
+
+			// Compute the function's origin. Account for flipped viewports as well.
 			if (target_viewport.x2 < target_viewport.x1)
 			{
 				cx = target_viewport.width() -  (cx * scale_x) + target_viewport.x2;
@@ -1171,7 +1174,7 @@ namespace rsx
 			overlay_element::get_compiled();
 			auto& config = compiled_resources.draw_commands.front().config;
 			configure_sdf(config, sdf_function::rounded_box);
-			config.sdf_config.br = radius;
+			config.sdf_config.br = std::min({ static_cast<f32>(border_radius), config.sdf_config.hx, config.sdf_config.hy });
 
 			m_is_compiled = true;
 			return compiled_resources;
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.h b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
index 7b88af2e12..04b6820287 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
@@ -350,7 +350,7 @@ namespace rsx
 
 		struct rounded_rect : public overlay_element
 		{
-			u8 radius = 5;
+			u16 border_radius = 5;
 
 			using overlay_element::overlay_element;
 			compiled_resource& get_compiled() override;
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_list_view.cpp b/rpcs3/Emu/RSX/Overlays/overlay_list_view.cpp
index 23c45d29bb..943da6271b 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_list_view.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_list_view.cpp
@@ -17,7 +17,7 @@ namespace rsx
 
 			scroll_indicator_grip->set_pos(1, 0);
 			scroll_indicator_grip->set_size(5, 5);
-			scroll_indicator_grip->radius = 2;
+			scroll_indicator_grip->border_radius = 2;
 			scroll_indicator_track->set_size(7, height);
 
 			m_scroll_indicator = std::make_unique<box_layout>();
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_select.cpp b/rpcs3/Emu/RSX/Overlays/overlay_select.cpp
index 5ef6eb254c..6e0d4a4c6c 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_select.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_select.cpp
@@ -144,7 +144,7 @@ namespace rsx::overlays
 
 		auto background = std::make_unique<rounded_rect>();
 		background->set_size(w, h);
-		background->radius = std::min(h / 4, 5);
+		background->border_radius = std::min(h / 4, 5);
 		background->back_color = color4f(0.3f, 0.3f, 0.3f, 1.0f);
 
 		const u16 arrow_size = std::min<u16>(h / 2, max_dropdown_arrow_dimension);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
index ff09af7994..3a3b2698be 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
@@ -34,22 +34,22 @@ namespace rsx::overlays
 		auto min_label = std::make_unique<label>();
 		auto max_label = std::make_unique<label>();
 
-		indicator->radius = slider_indicator_radius;
+		indicator->border_radius = slider_indicator_radius;
 		indicator->set_size(slider_indicator_dia + 2, slider_indicator_dia + 2);
 		indicator->set_padding(2);
 		indicator->set_pos(0, -2);
 		indicator->back_color = color4f(1.f);
 
-		background->radius = slider_rail_thickness / 2;
+		background->border_radius = slider_rail_thickness / 2;
 		background->back_color = this->back_color;
 		background->back_color.a = 1.f;
 		background->set_size(w, slider_rail_thickness);
-		background->set_pos(0, (slider_indicator_dia / 2) - background->radius);
+		background->set_pos(0, (slider_indicator_dia / 2) - background->border_radius);
 
-		foreground->radius = slider_cover_thickness / 2;
+		foreground->border_radius = slider_cover_thickness / 2;
 		foreground->back_color = this->fore_color;
 		foreground->set_size(0, slider_cover_thickness);
-		foreground->set_pos(0, (slider_indicator_dia / 2) - foreground->radius);
+		foreground->set_pos(0, (slider_indicator_dia / 2) - foreground->border_radius);
 
 		value_label->set_padding(2);
 		value_label->set_font(slider_label_font_family, slider_label_font_size);

From 5a90dc005969218aa05b4cfdf7cd24d3aa259986 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Mon, 23 Mar 2026 01:49:17 +0300
Subject: [PATCH 18/98] overlays: Bump the slider label font size

---
 rpcs3/Emu/RSX/Overlays/overlay_slider.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
index 3a3b2698be..4a0d607212 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_slider.cpp
@@ -8,7 +8,7 @@ namespace rsx::overlays
 	constexpr u16 slider_indicator_radius = 8;
 	constexpr u16 slider_indicator_dia = slider_indicator_radius * 2;
 	constexpr const char* slider_label_font_family = "Arial";
-	constexpr int slider_label_font_size = 10;
+	constexpr int slider_label_font_size = 11;
 
 	void slider::init()
 	{

From 90e2c39015f25e15c181336c8e43c76c9e23732d Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 09:01:28 +0100
Subject: [PATCH 19/98] Qt: loop SND0.AT3 audio

---
 rpcs3/rpcs3qt/qt_video_source.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rpcs3/rpcs3qt/qt_video_source.cpp b/rpcs3/rpcs3qt/qt_video_source.cpp
index 1f60800752..191822c7a8 100644
--- a/rpcs3/rpcs3qt/qt_video_source.cpp
+++ b/rpcs3/rpcs3qt/qt_video_source.cpp
@@ -261,6 +261,7 @@ void qt_video_source::start_audio()
 		audio.output = std::make_unique<QAudioOutput>();
 		audio.player = std::make_unique<QMediaPlayer>();
 		audio.player->setAudioOutput(audio.output.get());
+		audio.player->setLoops(QMediaPlayer::Infinite);
 	}
 
 	if (m_iso_path.empty())

From 36e1d664ea963391793218550f10fd49f4d2e177 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 09:32:16 +0100
Subject: [PATCH 20/98] Qt: Smoothly start/stop audio with fade in and fade out

---
 rpcs3/rpcs3qt/qt_video_source.cpp | 57 ++++++++++++++++++++++++++-----
 1 file changed, 49 insertions(+), 8 deletions(-)

diff --git a/rpcs3/rpcs3qt/qt_video_source.cpp b/rpcs3/rpcs3qt/qt_video_source.cpp
index 191822c7a8..760369ad74 100644
--- a/rpcs3/rpcs3qt/qt_video_source.cpp
+++ b/rpcs3/rpcs3qt/qt_video_source.cpp
@@ -8,6 +8,7 @@
 #include "Loader/ISO.h"
 
 #include <QAudioOutput>
+#include <QPropertyAnimation>
 #include <QFile>
 
 struct qt_audio_instance
@@ -24,10 +25,17 @@ struct qt_audio_instance
 
 static std::array<qt_audio_instance, 2> s_audio_instance = {};
 
+static constexpr int emu_timeout_start_ms = 0;
+static constexpr int gui_timeout_start_ms = 1000;
+static constexpr int gui_fade_in_ms = 2000;
+static constexpr int gui_fade_out_ms = 1000;
+
+static_assert(gui_fade_out_ms <= gui_timeout_start_ms);
+
 qt_video_source::qt_video_source(bool is_emulation)
 	: video_source()
 	, m_audio_instance_index(is_emulation ? qt_audio_instance::emu_index : qt_audio_instance::gui_index)
-	, m_video_timer_timeout_ms(is_emulation ? 0 : 1000)
+	, m_video_timer_timeout_ms(is_emulation ? emu_timeout_start_ms : gui_timeout_start_ms)
 {
 }
 
@@ -301,7 +309,13 @@ void qt_video_source::start_audio()
 		volume = audio::get_volume();
 	}
 
-	audio.output->setVolume(std::clamp(volume, 0.0f, 1.0f));
+	QPropertyAnimation* fade_in = new QPropertyAnimation(audio.output.get(), "volume", audio.output.get());
+	fade_in->setDuration(gui_fade_in_ms);
+	fade_in->setStartValue(0.0);
+	fade_in->setEndValue(std::clamp(volume, 0.0f, 1.0f));
+	fade_in->setEasingCurve(QEasingCurve::InSine);
+	fade_in->start(QAbstractAnimation::DeleteWhenStopped);
+
 	audio.player->play();
 	audio.source = this;
 }
@@ -313,15 +327,42 @@ void qt_video_source::stop_audio()
 
 	audio.source = nullptr;
 
-	if (audio.player)
+	QMediaPlayer* player = audio.player.release();
+	QAudioOutput* output = audio.output.release();
+	QBuffer* buffer = audio.buffer.release();
+	QByteArray* data = audio.data.release();
+
+	const auto reset_player = [=]()
 	{
-		audio.player->stop();
-		audio.player.reset();
+		if (player)
+		{
+			player->stop();
+			delete player;
+		}
+
+		if (output) delete output;
+		if (buffer) delete buffer;
+		if (data) delete data;
+	};
+
+	if (output)
+	{
+		QPropertyAnimation* fade_out = new QPropertyAnimation(output, "volume", output);
+		fade_out->setDuration(gui_fade_out_ms);
+		fade_out->setEasingCurve(QEasingCurve::OutSine);
+		fade_out->setStartValue(output->volume());
+		fade_out->setEndValue(0.0);
+
+		QObject::connect(fade_out, &QPropertyAnimation::finished, [reset_player]()
+		{
+			reset_player();
+		});
+
+		fade_out->start(QAbstractAnimation::DeleteWhenStopped);
+		return;
 	}
 
-	audio.output.reset();
-	audio.buffer.reset();
-	audio.data.reset();
+	reset_player();
 }
 
 QPixmap qt_video_source::get_movie_image(const QVideoFrame& frame) const

From 07f5b0aa5b8f0fc4e85522d5eb047e9c747a8b74 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 15:53:03 +0100
Subject: [PATCH 21/98] Qt: Improve find dialog

Add index of current line and word.
Add case sensitivity checkbox.
---
 rpcs3/rpcs3qt/find_dialog.cpp | 176 ++++++++++++++++++++++------------
 rpcs3/rpcs3qt/find_dialog.h   |  29 +++---
 2 files changed, 131 insertions(+), 74 deletions(-)

diff --git a/rpcs3/rpcs3qt/find_dialog.cpp b/rpcs3/rpcs3qt/find_dialog.cpp
index 9c5e805050..25d9442f2b 100644
--- a/rpcs3/rpcs3qt/find_dialog.cpp
+++ b/rpcs3/rpcs3qt/find_dialog.cpp
@@ -1,6 +1,10 @@
+#include "stdafx.h"
 #include "find_dialog.h"
 
+#include <QPushButton>
 #include <QVBoxLayout>
+#include <QTextBlock>
+#include <QCheckBox>
 
 find_dialog::find_dialog(QPlainTextEdit* edit, QWidget *parent, Qt::WindowFlags f) : QDialog(parent, f), m_text_edit(edit)
 {
@@ -9,109 +13,159 @@ find_dialog::find_dialog(QPlainTextEdit* edit, QWidget *parent, Qt::WindowFlags
 	m_find_bar = new QLineEdit();
 	m_find_bar->setPlaceholderText(tr("Search..."));
 
-	m_label_count_lines = new QLabel(tr("Counted in lines: -"));
-	m_label_count_total = new QLabel(tr("Counted in total: -"));
+	QCheckBox* cb_case_sensitive = new QCheckBox(tr("Case sensitive"));
+	cb_case_sensitive->setChecked(m_case_sensitive);
+	connect(cb_case_sensitive, &QCheckBox::toggled, this, [=](bool checked)
+	{
+		m_case_sensitive = checked;
+	});
 
-	m_find_first = new QPushButton(tr("First"));
-	m_find_last = new QPushButton(tr("Last"));
-	m_find_next = new QPushButton(tr("Next"));
-	m_find_previous = new QPushButton(tr("Previous"));
+	m_label_count_lines = new QLabel(tr("Line 0/0"));
+	m_label_count_total = new QLabel(tr("Word 0/0"));
+
+	QPushButton* find_first = new QPushButton(tr("First"));
+	QPushButton* find_last = new QPushButton(tr("Last"));
+	QPushButton* find_next = new QPushButton(tr("Next"));
+	QPushButton* find_previous = new QPushButton(tr("Previous"));
+
+	QHBoxLayout* find_layout = new QHBoxLayout();
+	find_layout->addWidget(m_find_bar);
+	find_layout->addWidget(cb_case_sensitive);
 
 	QHBoxLayout* count_layout = new QHBoxLayout();
 	count_layout->addWidget(m_label_count_lines);
 	count_layout->addWidget(m_label_count_total);
 
 	QHBoxLayout* button_layout = new QHBoxLayout();
-	button_layout->addWidget(m_find_first);
-	button_layout->addWidget(m_find_last);
-	button_layout->addWidget(m_find_previous);
-	button_layout->addWidget(m_find_next);
+	button_layout->addWidget(find_first);
+	button_layout->addWidget(find_last);
+	button_layout->addWidget(find_previous);
+	button_layout->addWidget(find_next);
 
 	QVBoxLayout* layout = new QVBoxLayout();
-	layout->addWidget(m_find_bar);
+	layout->addLayout(find_layout);
 	layout->addLayout(count_layout);
 	layout->addLayout(button_layout);
 	setLayout(layout);
 
-	connect(m_find_first, &QPushButton::clicked, this, &find_dialog::find_first);
-	connect(m_find_last, &QPushButton::clicked, this, &find_dialog::find_last);
-	connect(m_find_next, &QPushButton::clicked, this, &find_dialog::find_next);
-	connect(m_find_previous, &QPushButton::clicked, this, &find_dialog::find_previous);
+	connect(find_first, &QPushButton::clicked, this, [this](){ find(find_type::first); });
+	connect(find_last, &QPushButton::clicked, this, [this](){ find(find_type::last); });
+	connect(find_next, &QPushButton::clicked, this, [this](){ find(find_type::next); });
+	connect(find_previous, &QPushButton::clicked, this, [this](){ find(find_type::prev); });
 
-	m_find_next->setDefault(true);
+	find_next->setDefault(true);
 
 	show();
 }
 
-int find_dialog::count_all()
+void find_dialog::find(find_type type)
 {
 	m_count_lines = 0;
 	m_count_total = 0;
+	m_current_line = 0;
+	m_current_index = 0;
 
 	if (!m_text_edit || m_find_bar->text().isEmpty())
 	{
 		show_count();
-		return 0;
+		return;
 	}
 
+	const QTextDocument::FindFlags flags = m_case_sensitive ? QTextDocument::FindCaseSensitively : QTextDocument::FindFlag{};
+
+	std::map<int /*block*/, std::map<int /*line*/, std::vector<int> /*pos*/>> block_indices;
+
 	const QTextCursor old_cursor = m_text_edit->textCursor();
 	m_text_edit->moveCursor(QTextCursor::Start);
 
-	int old_line_index = -1;
+	const QString text = m_find_bar->text();
 
-	while (m_text_edit->find(m_find_bar->text()))
+	while (m_text_edit->find(text, flags))
 	{
 		m_count_total++;
-		const int new_line_index = m_text_edit->textCursor().blockNumber();
 
-		if (new_line_index != old_line_index)
+		const QTextCursor cursor = m_text_edit->textCursor();
+		const QTextBlock block = cursor.block();
+		const QTextLayout* layout = block.layout();
+
+		const int relative_pos = cursor.position() - block.position();
+		const QTextLine line = layout->lineForTextPosition(relative_pos);
+		const int pos_in_line = relative_pos - line.textStart();
+
+		block_indices[cursor.blockNumber()][line.lineNumber()].push_back(pos_in_line);
+	}
+
+	switch (type)
+	{
+	case find_type::first:
+	{
+		m_text_edit->moveCursor(QTextCursor::Start);
+		m_text_edit->find(text, flags);
+		break;
+	}
+	case find_type::last:
+	{
+		m_text_edit->moveCursor(QTextCursor::End);
+		m_text_edit->find(text, flags | QTextDocument::FindBackward);
+		break;
+	}
+	case find_type::next:
+	{
+		m_text_edit->setTextCursor(old_cursor);
+		m_text_edit->find(text, flags);
+		break;
+	}
+	case find_type::prev:
+	{
+		m_text_edit->setTextCursor(old_cursor);
+		m_text_edit->find(text, flags | QTextDocument::FindBackward);
+		break;
+	}
+	}
+
+	const QTextCursor cursor = m_text_edit->textCursor();
+	const QTextBlock block = cursor.block();
+	const QTextLayout* layout = block.layout();
+
+	const int relative_pos = cursor.position() - block.position();
+	const QTextLine line = layout->lineForTextPosition(relative_pos);
+	const int pos_in_line = relative_pos - line.textStart();
+
+	const int current_line = line.lineNumber();
+	const int current_pos = pos_in_line;
+
+	int word_count = 0;
+	for (const auto& [block, lines] : block_indices)
+	{
+		const bool is_current_block = block == cursor.blockNumber();
+
+		for (const auto& [line, positions] : lines)
 		{
+			const bool is_current_line = line == current_line;
+
 			m_count_lines++;
-			old_line_index = new_line_index;
+
+			int pos_count = 0;
+
+			for (int pos : positions)
+			{
+				pos_count++;
+				word_count++;
+
+				if (is_current_block && is_current_line && pos == current_pos)
+				{
+					m_current_line = m_count_lines;
+					m_current_index = word_count;
+				}
+			}
 		}
 	}
 
-	m_text_edit->setTextCursor(old_cursor);
 	show_count();
-	return m_count_total;
-}
-
-void find_dialog::find_first()
-{
-	if (count_all() <= 0)
-		return;
-
-	m_text_edit->moveCursor(QTextCursor::Start);
-	m_text_edit->find(m_find_bar->text());
-}
-
-void find_dialog::find_last()
-{
-	if (count_all() <= 0)
-		return;
-
-	m_text_edit->moveCursor(QTextCursor::End);
-	m_text_edit->find(m_find_bar->text(), QTextDocument::FindBackward);
-}
-
-void find_dialog::find_next()
-{
-	if (count_all() <= 0)
-		return;
-
-	m_text_edit->find(m_find_bar->text());
-}
-
-void find_dialog::find_previous()
-{
-	if (count_all() <= 0)
-		return;
-
-	m_text_edit->find(m_find_bar->text(), QTextDocument::FindBackward);
 }
 
 void find_dialog::show_count() const
 {
-	m_label_count_lines->setText(tr("Counted in lines: %0").arg(m_count_lines));
-	m_label_count_total->setText(tr("Counted in total: %0").arg(m_count_total));
+	m_label_count_lines->setText(tr("Line %0/%1").arg(m_current_line).arg(m_count_lines));
+	m_label_count_total->setText(tr("Word %0/%1").arg(m_current_index).arg(m_count_total));
 }
diff --git a/rpcs3/rpcs3qt/find_dialog.h b/rpcs3/rpcs3qt/find_dialog.h
index 27baf03c75..a4e9293fc6 100644
--- a/rpcs3/rpcs3qt/find_dialog.h
+++ b/rpcs3/rpcs3qt/find_dialog.h
@@ -3,7 +3,6 @@
 #include <QDialog>
 #include <QPlainTextEdit>
 #include <QLineEdit>
-#include <QPushButton>
 #include <QLabel>
 
 class find_dialog : public QDialog
@@ -14,22 +13,26 @@ public:
 	find_dialog(QPlainTextEdit* edit, QWidget *parent = Q_NULLPTR, Qt::WindowFlags f = Qt::WindowFlags());
 
 private:
+	enum class find_type
+	{
+		first,
+		last,
+		next,
+		prev
+	};
+
+	void find(find_type type);
+	void show_count() const;
+
 	int m_count_lines = 0;
 	int m_count_total = 0;
+	int m_current_line = 0;
+	int m_current_index = 0;
+
+	bool m_case_sensitive = false;
+
 	QLabel* m_label_count_lines;
 	QLabel* m_label_count_total;
 	QPlainTextEdit* m_text_edit;
 	QLineEdit* m_find_bar;
-	QPushButton* m_find_first;
-	QPushButton* m_find_last;
-	QPushButton* m_find_next;
-	QPushButton* m_find_previous;
-
-private Q_SLOTS:
-	int count_all();
-	void find_first();
-	void find_last();
-	void find_next();
-	void find_previous();
-	void show_count() const;
 };

From 1d05cf9ce5a3abe06e7f1be8a2e4de5c68377b05 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 16:41:06 +0100
Subject: [PATCH 22/98] Qt/Input: trace gui pad navigation button presses

---
 rpcs3/Input/gui_pad_thread.cpp | 49 +++++++++++++++++++++++++++++-----
 rpcs3/Input/gui_pad_thread.h   | 16 +++++------
 2 files changed, 50 insertions(+), 15 deletions(-)

diff --git a/rpcs3/Input/gui_pad_thread.cpp b/rpcs3/Input/gui_pad_thread.cpp
index 666bf329ac..4e33ffb52b 100644
--- a/rpcs3/Input/gui_pad_thread.cpp
+++ b/rpcs3/Input/gui_pad_thread.cpp
@@ -38,6 +38,39 @@
 
 LOG_CHANNEL(gui_log, "GUI");
 
+template <>
+void fmt_class_string<gui_pad_thread::mouse_button>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](gui_pad_thread::mouse_button value)
+	{
+		switch (value)
+		{
+		case gui_pad_thread::mouse_button::none: return "Mouse none";
+		case gui_pad_thread::mouse_button::left: return "Mouse left";
+		case gui_pad_thread::mouse_button::right: return "Mouse right";
+		case gui_pad_thread::mouse_button::middle: return "Mouse middle";
+		}
+
+		return unknown;
+	});
+}
+
+template <>
+void fmt_class_string<gui_pad_thread::mouse_wheel>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](gui_pad_thread::mouse_wheel value)
+	{
+		switch (value)
+		{
+		case gui_pad_thread::mouse_wheel::none: return "Wheel none";
+		case gui_pad_thread::mouse_wheel::vertical: return "Wheel vertical";
+		case gui_pad_thread::mouse_wheel::horizontal: return "Wheel horizontal";
+		}
+
+		return unknown;
+	});
+}
+
 atomic_t<bool> gui_pad_thread::m_reset = false;
 
 gui_pad_thread::gui_pad_thread()
@@ -294,8 +327,10 @@ void gui_pad_thread::process_input()
 
 	constexpr u64 ms_threshold = 500;
 
-	const auto on_button_pressed = [this](pad_button button_id, bool pressed, u16 value)
+	const auto on_button_pressed = [this](pad_button button_id, bool pressed, bool auto_repeat, u16 value)
 	{
+		gui_log.trace("gui_pad_thread::on_button_pressed: btn=%s, pressed=%d, auto_repeat=%d, value=%d", button_id, pressed, auto_repeat, value);
+
 		if (button_id == m_mouse_boost_button)
 		{
 			m_boost_mouse = pressed;
@@ -390,7 +425,7 @@ void gui_pad_thread::process_input()
 					m_last_auto_repeat_button = is_auto_repeat_button ? button_id : pad_button::pad_button_max_enum;
 				}
 
-				on_button_pressed(static_cast<pad_button>(button_id), true, value);
+				on_button_pressed(static_cast<pad_button>(button_id), true, false, value);
 			}
 			else if (is_auto_repeat_button)
 			{
@@ -400,7 +435,7 @@ void gui_pad_thread::process_input()
 				{
 					// The auto-repeat button was pressed for at least the given threshold in ms and will trigger at an interval.
 					m_timestamp = steady_clock::now();
-					on_button_pressed(static_cast<pad_button>(button_id), true, value);
+					on_button_pressed(static_cast<pad_button>(button_id), true, true, value);
 				}
 				else if (m_last_auto_repeat_button == pad_button::pad_button_max_enum)
 				{
@@ -410,7 +445,7 @@ void gui_pad_thread::process_input()
 			}
 			else if (is_mouse_move_button)
 			{
-				on_button_pressed(static_cast<pad_button>(button_id), pressed, value);
+				on_button_pressed(static_cast<pad_button>(button_id), true, false, value);
 			}
 		}
 		else if (last_state)
@@ -421,7 +456,7 @@ void gui_pad_thread::process_input()
 				m_last_auto_repeat_button = pad_button::pad_button_max_enum;
 			}
 
-			on_button_pressed(static_cast<pad_button>(button_id), false, value);
+			on_button_pressed(static_cast<pad_button>(button_id), false, false, value);
 		}
 
 		last_state = pressed;
@@ -618,7 +653,7 @@ void gui_pad_thread::send_key_event(u32 key, bool pressed)
 
 void gui_pad_thread::send_mouse_button_event(mouse_button btn, bool pressed)
 {
-	gui_log.trace("gui_pad_thread::send_mouse_button_event: btn=%d, pressed=%d", static_cast<int>(btn), pressed);
+	gui_log.trace("gui_pad_thread::send_mouse_button_event: btn=%s, pressed=%d", btn, pressed);
 
 #ifdef _WIN32
 	INPUT input{};
@@ -684,7 +719,7 @@ void gui_pad_thread::send_mouse_button_event(mouse_button btn, bool pressed)
 
 void gui_pad_thread::send_mouse_wheel_event(mouse_wheel wheel, int delta)
 {
-	gui_log.trace("gui_pad_thread::send_mouse_wheel_event: wheel=%d, delta=%d", static_cast<int>(wheel), delta);
+	gui_log.trace("gui_pad_thread::send_mouse_wheel_event: wheel=%s, delta=%d", wheel, delta);
 
 	if (!delta)
 	{
diff --git a/rpcs3/Input/gui_pad_thread.h b/rpcs3/Input/gui_pad_thread.h
index dc04fb456f..d3f45a5efb 100644
--- a/rpcs3/Input/gui_pad_thread.h
+++ b/rpcs3/Input/gui_pad_thread.h
@@ -27,12 +27,6 @@ public:
 		m_reset = true;
 	}
 
-protected:
-	bool init();
-	void run();
-
-	void process_input();
-
 	enum class mouse_button
 	{
 		none,
@@ -48,6 +42,12 @@ protected:
 		horizontal
 	};
 
+protected:
+	bool init();
+	void run();
+
+	void process_input();
+
 	void send_key_event(u32 key, bool pressed);
 	void send_mouse_button_event(mouse_button btn, bool pressed);
 	void send_mouse_wheel_event(mouse_wheel wheel, int delta);
@@ -73,7 +73,7 @@ protected:
 
 	static constexpr u64 auto_repeat_ms_interval_default = 200;
 	pad_button m_last_auto_repeat_button = pad_button::pad_button_max_enum;
-	std::map<pad_button, u64> m_auto_repeat_buttons = {
+	const std::map<pad_button, u64> m_auto_repeat_buttons = {
 		{ pad_button::dpad_up, auto_repeat_ms_interval_default },
 		{ pad_button::dpad_down, auto_repeat_ms_interval_default },
 		{ pad_button::dpad_left, auto_repeat_ms_interval_default },
@@ -85,7 +85,7 @@ protected:
 	};
 
 	// Mouse movement should just work without delays
-	std::map<pad_button, u64> m_mouse_move_buttons = {
+	const std::map<pad_button, u64> m_mouse_move_buttons = {
 		{ pad_button::ls_up, 1 },
 		{ pad_button::ls_down, 1 },
 		{ pad_button::ls_left, 1 },

From 53c33cd8122818de301d94b5fc335612f5d80f63 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 17:44:02 +0100
Subject: [PATCH 23/98] gui/input: disable stick anti deadzone in pad
 navigation

This is only meant to be used during emulation.
---
 rpcs3/Input/gui_pad_thread.cpp | 14 +++++++++-----
 rpcs3/Input/gui_pad_thread.h   |  4 ++--
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/rpcs3/Input/gui_pad_thread.cpp b/rpcs3/Input/gui_pad_thread.cpp
index 4e33ffb52b..4710af77ab 100644
--- a/rpcs3/Input/gui_pad_thread.cpp
+++ b/rpcs3/Input/gui_pad_thread.cpp
@@ -137,7 +137,7 @@ bool gui_pad_thread::init()
 	for (usz i = 0; i < g_cfg_input.player.size(); i++)
 	{
 		std::shared_ptr<PadHandlerBase> handler;
-		gui_pad_thread::InitPadConfig(g_cfg_input.player[i]->config, g_cfg_input.player[i]->handler, handler);
+		gui_pad_thread::init_pad_config(g_cfg_input.player[i]->config, g_cfg_input.player[i]->handler, handler);
 	}
 
 	// Reload with proper defaults
@@ -153,13 +153,17 @@ bool gui_pad_thread::init()
 		cfg_player* cfg = g_cfg_input.player[i];
 
 		const pad_handler handler_type = cfg->handler.get();
-		std::shared_ptr<PadHandlerBase> cur_pad_handler = GetHandler(handler_type);
+		std::shared_ptr<PadHandlerBase> cur_pad_handler = get_handler(handler_type);
 
 		if (!cur_pad_handler)
 		{
 			continue;
 		}
 
+		// Disable stick anti-deadzone. We are not trying to emulate the PS3's behavior here.
+		cfg->config.lstick_anti_deadzone.set(0);
+		cfg->config.rstick_anti_deadzone.set(0);
+
 		cur_pad_handler->Init();
 
 		m_handler = cur_pad_handler;
@@ -229,7 +233,7 @@ bool gui_pad_thread::init()
 	return true;
 }
 
-std::shared_ptr<PadHandlerBase> gui_pad_thread::GetHandler(pad_handler type)
+std::shared_ptr<PadHandlerBase> gui_pad_thread::get_handler(pad_handler type)
 {
 	switch (type)
 	{
@@ -265,14 +269,14 @@ std::shared_ptr<PadHandlerBase> gui_pad_thread::GetHandler(pad_handler type)
 	return nullptr;
 }
 
-void gui_pad_thread::InitPadConfig(cfg_pad& cfg, pad_handler type, std::shared_ptr<PadHandlerBase>& handler)
+void gui_pad_thread::init_pad_config(cfg_pad& cfg, pad_handler type, std::shared_ptr<PadHandlerBase>& handler)
 {
 	// We need to restore the original defaults first.
 	cfg.restore_defaults();
 
 	if (!handler)
 	{
-		handler = GetHandler(type);
+		handler = get_handler(type);
 	}
 
 	if (handler)
diff --git a/rpcs3/Input/gui_pad_thread.h b/rpcs3/Input/gui_pad_thread.h
index d3f45a5efb..7c3503af1e 100644
--- a/rpcs3/Input/gui_pad_thread.h
+++ b/rpcs3/Input/gui_pad_thread.h
@@ -19,8 +19,8 @@ public:
 
 	void update_settings(const std::shared_ptr<gui_settings>& settings);
 
-	static std::shared_ptr<PadHandlerBase> GetHandler(pad_handler type);
-	static void InitPadConfig(cfg_pad& cfg, pad_handler type, std::shared_ptr<PadHandlerBase>& handler);
+	static std::shared_ptr<PadHandlerBase> get_handler(pad_handler type);
+	static void init_pad_config(cfg_pad& cfg, pad_handler type, std::shared_ptr<PadHandlerBase>& handler);
 
 	static void reset()
 	{

From 2bcc27d581875025610f6f0ad4b34053cd5a470b Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 18:35:58 +0100
Subject: [PATCH 24/98] Qt/input: Do not send gui input release events until
 there was at least one button press

---
 rpcs3/Input/gui_pad_thread.cpp | 16 +++++++++++++---
 rpcs3/Input/gui_pad_thread.h   |  2 +-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/rpcs3/Input/gui_pad_thread.cpp b/rpcs3/Input/gui_pad_thread.cpp
index 4710af77ab..e467c9ae0a 100644
--- a/rpcs3/Input/gui_pad_thread.cpp
+++ b/rpcs3/Input/gui_pad_thread.cpp
@@ -109,9 +109,8 @@ bool gui_pad_thread::init()
 {
 	m_handler.reset();
 	m_pad.reset();
+	m_last_button_state.clear();
 
-	// Initialize last button states as pressed to avoid unwanted button presses when starting the thread.
-	m_last_button_state.fill(true);
 	m_timestamp = steady_clock::now();
 	m_initial_timestamp = steady_clock::now();
 	m_last_auto_repeat_button = pad_button::pad_button_max_enum;
@@ -412,7 +411,18 @@ void gui_pad_thread::process_input()
 			return;
 		}
 
-		bool& last_state = m_last_button_state[static_cast<u32>(button_id)];
+		if (!m_last_button_state.contains(button_id))
+		{
+			// Ignore button presses and releases if there was no release detected at least once.
+			if (!pressed)
+			{
+				m_last_button_state[button_id] = false;
+			}
+
+			return;
+		}
+
+		bool& last_state = m_last_button_state[button_id];
 
 		if (pressed)
 		{
diff --git a/rpcs3/Input/gui_pad_thread.h b/rpcs3/Input/gui_pad_thread.h
index 7c3503af1e..92140567c3 100644
--- a/rpcs3/Input/gui_pad_thread.h
+++ b/rpcs3/Input/gui_pad_thread.h
@@ -65,7 +65,7 @@ protected:
 	atomic_t<bool> m_allow_global_input = false;
 	static atomic_t<bool> m_reset;
 
-	std::array<bool, static_cast<u32>(pad_button::pad_button_max_enum)> m_last_button_state{};
+	std::map<pad_button, bool> m_last_button_state{};
 
 	steady_clock::time_point m_timestamp;
 	steady_clock::time_point m_initial_timestamp;

From 99bb042bea170a0fc5e573d23445713b6bef9c2d Mon Sep 17 00:00:00 2001
From: capriots <29807355+capriots@users.noreply.github.com>
Date: Mon, 23 Mar 2026 21:52:23 +0100
Subject: [PATCH 25/98] HLE modules: process PPU state after lv2 syscalls

---
 rpcs3/Emu/Cell/Modules/cellAdec.cpp      | 22 ++++-----
 rpcs3/Emu/Cell/Modules/cellAdec.h        | 27 ++++++++---
 rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp | 32 ++++++-------
 rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp  | 59 +++++++++++++++---------
 4 files changed, 83 insertions(+), 57 deletions(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellAdec.cpp b/rpcs3/Emu/Cell/Modules/cellAdec.cpp
index dfc91c8d2f..f5cb90be7e 100644
--- a/rpcs3/Emu/Cell/Modules/cellAdec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellAdec.cpp
@@ -261,7 +261,7 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 		savestate = lpcm_dec_state::waiting_for_output_mutex_lock;
 		output_mutex_lock:
 
-		error_occurred |= static_cast<u32>(sys_mutex_lock(ppu, output_mutex, 0) != CELL_OK);
+		error_occurred |= static_cast<u32>(lv2_syscall<sys_mutex_lock>(ppu, output_mutex, 0) != CELL_OK);
 
 		if (ppu.state & cpu_flag::again)
 		{
@@ -273,7 +273,7 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 			savestate = lpcm_dec_state::waiting_for_output_cond_wait;
 			output_cond_wait:
 
-			ensure(sys_cond_wait(ppu, output_consumed, 0) == CELL_OK); // Error code isn't checked on LLE
+			ensure(lv2_syscall<sys_cond_wait>(ppu, output_consumed, 0) == CELL_OK); // Error code isn't checked on LLE
 
 			if (ppu.state & cpu_flag::again)
 			{
@@ -287,7 +287,7 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 		savestate = lpcm_dec_state::queue_mutex_lock;
 		queue_mutex_lock:
 
-		ensure(sys_mutex_lock(ppu, queue_mutex, 0) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, queue_mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 
 		if (ppu.state & cpu_flag::again)
 		{
@@ -703,7 +703,7 @@ error_code LpcmDecContext::send_command(ppu_thread& ppu, auto&&... args)
 {
 	ppu.state += cpu_flag::wait;
 
-	if (error_code ret = sys_mutex_lock(ppu, queue_size_mutex, 0); ret != CELL_OK)
+	if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, queue_size_mutex, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -720,7 +720,7 @@ error_code LpcmDecContext::send_command(ppu_thread& ppu, auto&&... args)
 		*lpcm_param = { args... };
 	}
 
-	if (error_code ret = sys_mutex_lock(ppu, queue_mutex, 0); ret != CELL_OK)
+	if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, queue_mutex, 0); ret != CELL_OK)
 	{
 		ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
 		return ret;
@@ -740,14 +740,14 @@ error_code LpcmDecContext::send_command(ppu_thread& ppu, auto&&... args)
 
 inline error_code LpcmDecContext::release_output(ppu_thread& ppu)
 {
-	if (error_code ret = sys_mutex_lock(ppu, output_mutex, 0); ret != CELL_OK)
+	if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, output_mutex, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	output_locked = false;
 
-	if (error_code ret = sys_cond_signal(ppu, output_consumed); ret != CELL_OK)
+	if (error_code ret = lv2_syscall<sys_cond_signal>(ppu, output_consumed); ret != CELL_OK)
 	{
 		return ret; // LLE doesn't unlock the mutex
 	}
@@ -865,8 +865,8 @@ error_code _CellAdecCoreOpClose_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> ha
 
 	cellAdec.notice("_CellAdecCoreOpClose_lpcm(handle=*0x%x)", handle);
 
-	if (error_code ret = sys_mutex_lock(ppu, handle->queue_size_mutex, 0); ret != CELL_OK
-		|| (ret = sys_mutex_lock(ppu, handle->queue_mutex, 0)) != CELL_OK)
+	if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, handle->queue_size_mutex, 0); ret != CELL_OK
+		|| (ret = lv2_syscall<sys_mutex_lock>(ppu, handle->queue_mutex, 0)) != CELL_OK)
 	{
 		return ret;
 	}
@@ -1091,7 +1091,7 @@ error_code AdecContext::set_pcm_item(s32 pcm_handle, vm::ptr<void> pcm_addr, u32
 
 error_code AdecContext::link_frame(ppu_thread& ppu, s32 pcm_handle)
 {
-	ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
+	ensure(lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 
 	if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
 	{
@@ -1125,7 +1125,7 @@ error_code AdecContext::link_frame(ppu_thread& ppu, s32 pcm_handle)
 
 error_code AdecContext::unlink_frame(ppu_thread& ppu, s32 pcm_handle)
 {
-	ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
+	ensure(lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 
 	if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
 	{
diff --git a/rpcs3/Emu/Cell/Modules/cellAdec.h b/rpcs3/Emu/Cell/Modules/cellAdec.h
index a43c3f0aef..33dd356ee5 100644
--- a/rpcs3/Emu/Cell/Modules/cellAdec.h
+++ b/rpcs3/Emu/Cell/Modules/cellAdec.h
@@ -485,6 +485,19 @@ struct AdecFrame
 
 CHECK_SIZE(AdecFrame, 0x68);
 
+template <auto Syscall>
+static auto lv2_syscall(ppu_thread& ppu, auto&&... args)
+{
+	const auto ret = Syscall(ppu, std::forward<decltype(args)>(args)...);
+
+	if (ppu.test_stopped())
+	{
+		ppu.state += cpu_flag::again;
+	}
+
+	return ret;
+}
+
 class AdecOutputQueue
 {
 	struct entry
@@ -539,7 +552,7 @@ public:
 
 	error_code push(ppu_thread& ppu, vm::ptr<CellAdecPcmItem> pcm_item, s32 pcm_handle)
 	{
-		ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 
 		if (entries[back].state != 0xff)
 		{
@@ -560,7 +573,7 @@ public:
 
 	const entry* pop(ppu_thread& ppu)
 	{
-		ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 
 		if (ppu.state & cpu_flag::again) // Savestate was created while waiting on the mutex
 		{
@@ -587,7 +600,7 @@ public:
 
 	const entry& peek(ppu_thread& ppu) const
 	{
-		ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 		const entry& ret = entries[front];
 		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return ret;
@@ -728,14 +741,14 @@ public:
 
 	error_code release(ppu_thread& ppu)
 	{
-		if (error_code ret = sys_mutex_lock(ppu, mutex, 0); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, mutex, 0); ret != CELL_OK)
 		{
 			return ret;
 		}
 
 		value++;
 
-		if (error_code ret = sys_cond_signal(ppu, cond); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_cond_signal>(ppu, cond); ret != CELL_OK)
 		{
 			return ret; // LLE doesn't unlock the mutex
 		}
@@ -752,7 +765,7 @@ public:
 
 		savestate = lpcm_dec_state::waiting_for_cmd_mutex_lock;
 
-		if (error_code ret = sys_mutex_lock(ppu, mutex, 0); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, mutex, 0); ret != CELL_OK)
 		{
 			return ret;
 		}
@@ -767,7 +780,7 @@ public:
 			savestate = lpcm_dec_state::waiting_for_cmd_cond_wait;
 			cond_wait:
 
-			if (error_code ret = sys_cond_wait(ppu, cond, 0); ret != CELL_OK)
+			if (error_code ret = lv2_syscall<sys_cond_wait>(ppu, cond, 0); ret != CELL_OK)
 			{
 				return ret; // LLE doesn't unlock the mutex
 			}
diff --git a/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp b/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp
index c55cf7b60f..15e0069408 100644
--- a/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp
@@ -295,7 +295,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 		{
 			savestate = atracxdec_state::initial;
 
-			ensure(sys_mutex_lock(ppu, queue_mutex, 0) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_lock>(ppu, queue_mutex, 0) == CELL_OK);
 
 			if (ppu.state & cpu_flag::again)
 			{
@@ -310,7 +310,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 			savestate = atracxdec_state::waiting_for_cmd;
 			label1_wait_for_cmd_state:
 
-			ensure(sys_cond_wait(ppu, queue_not_empty, 0) == CELL_OK);
+			ensure(lv2_syscall<sys_cond_wait>(ppu, queue_not_empty, 0) == CELL_OK);
 
 			if (ppu.state & cpu_flag::again)
 			{
@@ -327,7 +327,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 		savestate = atracxdec_state::checking_run_thread_1;
 		label2_check_run_thread_1_state:
 
-		ensure(sys_mutex_lock(ppu, run_thread_mutex, 0) == CELL_OK);
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, run_thread_mutex, 0) == CELL_OK);
 
 		if (ppu.state & cpu_flag::again)
 		{
@@ -392,7 +392,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 
 			cellAtracXdec.trace("Waiting for output to be consumed...");
 
-			ensure(sys_mutex_lock(ppu, output_mutex, 0) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_lock>(ppu, output_mutex, 0) == CELL_OK);
 
 			if (ppu.state & cpu_flag::again)
 			{
@@ -404,7 +404,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 				savestate = atracxdec_state::waiting_for_output;
 				label4_wait_for_output_state:
 
-				ensure(sys_cond_wait(ppu, output_consumed, 0) == CELL_OK);
+				ensure(lv2_syscall<sys_cond_wait>(ppu, output_consumed, 0) == CELL_OK);
 
 				if (ppu.state & cpu_flag::again)
 				{
@@ -417,7 +417,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 			savestate = atracxdec_state::checking_run_thread_2;
 			label5_check_run_thread_2_state:
 
-			ensure(sys_mutex_lock(ppu, run_thread_mutex, 0) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_lock>(ppu, run_thread_mutex, 0) == CELL_OK);
 
 			if (ppu.state & cpu_flag::again)
 			{
@@ -680,7 +680,7 @@ error_code AtracXdecContext::send_command(ppu_thread& ppu, auto&&... args)
 
 	if (!signal)
 	{
-		ensure(sys_mutex_lock(ppu, queue_mutex, 0) == CELL_OK);
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, queue_mutex, 0) == CELL_OK);
 
 		if (ppu.state & cpu_flag::again)
 		{
@@ -708,7 +708,7 @@ error_code AtracXdecContext::send_command(ppu_thread& ppu, auto&&... args)
 		ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK);
 	}
 
-	ensure(sys_cond_signal(ppu, queue_not_empty) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_signal>(ppu, queue_not_empty) == CELL_OK);
 
 	if (ppu.state & cpu_flag::again)
 	{
@@ -794,9 +794,9 @@ error_code _CellAdecCoreOpOpenExt_atracx(ppu_thread& ppu, vm::ptr<AtracXdecConte
 	ensure(sys_mutex_create(ppu, handle.ptr(&AtracXdecContext::output_mutex), mutex_attr) == CELL_OK);
 	ensure(sys_cond_create(ppu, handle.ptr(&AtracXdecContext::output_consumed), handle->output_mutex, cond_attr) == CELL_OK);
 
-	ensure(sys_mutex_lock(ppu, handle->output_mutex, 0) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->output_mutex, 0) == CELL_OK);
 	handle->output_locked = false;
-	ensure(sys_cond_signal(ppu, handle->output_consumed) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_signal>(ppu, handle->output_consumed) == CELL_OK);
 	ensure(sys_mutex_unlock(ppu, handle->output_mutex) == CELL_OK);
 
 	const vm::var<char[]> _name = vm::make_str("HLE ATRAC3plus decoder");
@@ -829,19 +829,19 @@ error_code _CellAdecCoreOpClose_atracx(ppu_thread& ppu, vm::ptr<AtracXdecContext
 
 	ensure(!!handle); // Not checked on LLE
 
-	ensure(sys_mutex_lock(ppu, handle->run_thread_mutex, 0) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->run_thread_mutex, 0) == CELL_OK);
 	handle->run_thread = false;
 	ensure(sys_mutex_unlock(ppu, handle->run_thread_mutex) == CELL_OK);
 
 	handle->send_command<AtracXdecCmdType::close>(ppu);
 
-	ensure(sys_mutex_lock(ppu, handle->output_mutex, 0) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->output_mutex, 0) == CELL_OK);
 	handle->output_locked = false;
 	ensure(sys_mutex_unlock(ppu, handle->output_mutex) == CELL_OK);
-	ensure(sys_cond_signal(ppu, handle->output_consumed) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_signal>(ppu, handle->output_consumed) == CELL_OK);
 
 	vm::var<u64> thread_ret;
-	ensure(sys_ppu_thread_join(ppu, static_cast<u32>(handle->thread_id), +thread_ret) == CELL_OK);
+	ensure(lv2_syscall<sys_ppu_thread_join>(ppu, static_cast<u32>(handle->thread_id), +thread_ret) == CELL_OK);
 
 	error_code ret = sys_cond_destroy(ppu, handle->queue_not_empty);
 	ret = ret ? ret : sys_cond_destroy(ppu, handle->run_thread_cond);
@@ -921,7 +921,7 @@ error_code _CellAdecCoreOpReleasePcm_atracx(ppu_thread& ppu, vm::ptr<AtracXdecCo
 
 	if (!signal)
 	{
-		ensure(sys_mutex_lock(ppu, handle->output_mutex, 0) == CELL_OK);
+		ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->output_mutex, 0) == CELL_OK);
 
 		if (ppu.state & cpu_flag::again)
 		{
@@ -931,7 +931,7 @@ error_code _CellAdecCoreOpReleasePcm_atracx(ppu_thread& ppu, vm::ptr<AtracXdecCo
 		handle->output_locked = false;
 	}
 
-	ensure(sys_cond_signal(ppu, handle->output_consumed) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_signal>(ppu, handle->output_consumed) == CELL_OK);
 
 	if (ppu.state & cpu_flag::again)
 	{
diff --git a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
index b8d9ba75b0..ac3dfa7e06 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
@@ -1154,6 +1154,19 @@ void dmux_pamf_spu_context::save(utils::serial& ar)
 
 // PPU thread
 
+template <auto Syscall>
+static auto lv2_syscall(ppu_thread& ppu, auto&&... args)
+{
+	const auto ret = Syscall(ppu, std::forward<decltype(args)>(args)...);
+
+	if (ppu.test_stopped())
+	{
+		ppu.state += cpu_flag::again;
+	}
+
+	return ret;
+}
+
 template <DmuxPamfCommandType type>
 void DmuxPamfContext::send_spu_command_and_wait(ppu_thread& ppu, bool waiting_for_spu_state, auto&&... cmd_params)
 {
@@ -1195,7 +1208,7 @@ error_code DmuxPamfContext::wait_au_released_or_stream_reset(ppu_thread& ppu, u6
 		goto label1_waiting_for_au_released_state;
 	}
 
-	if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+	if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -1214,7 +1227,7 @@ error_code DmuxPamfContext::wait_au_released_or_stream_reset(ppu_thread& ppu, u6
 			savestate = dmux_pamf_state::waiting_for_au_released;
 			label1_waiting_for_au_released_state:
 
-			if (sys_cond_wait(ppu, cond, 0) != CELL_OK)
+			if (lv2_syscall<sys_cond_wait>(ppu, cond, 0) != CELL_OK)
 			{
 				sys_mutex_unlock(ppu, mutex);
 				return CELL_DMUX_PAMF_ERROR_FATAL;
@@ -1240,7 +1253,7 @@ error_code DmuxPamfContext::wait_au_released_or_stream_reset(ppu_thread& ppu, u6
 template <bool reset>
 error_code DmuxPamfContext::set_au_reset(ppu_thread& ppu)
 {
-	if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+	if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -1358,7 +1371,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 			savestate = dmux_pamf_state::starting_demux_done;
 			label4_starting_demux_done_state:
 
-			if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+			if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::starting_demux_done_mutex_lock_error;
 				label5_starting_demux_done_mutex_lock_error_state:
@@ -1423,7 +1436,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 		{
 		case DmuxPamfEventType::au_found:
 		{
-			if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+			if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1537,7 +1550,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 			savestate = dmux_pamf_state::demux_done_mutex_lock;
 			label15_demux_done_mutex_lock_state:
 
-			if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+			if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1552,7 +1565,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 				savestate = dmux_pamf_state::demux_done_cond_signal;
 				label16_demux_done_cond_signal_state:
 
-				if (sys_cond_signal_all(ppu, cond) != CELL_OK)
+				if (lv2_syscall<sys_cond_signal_all>(ppu, cond) != CELL_OK)
 				{
 					sys_mutex_unlock(ppu, mutex);
 
@@ -1578,7 +1591,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 		}
 		case DmuxPamfEventType::flush_done:
 		{
-			if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+			if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1632,7 +1645,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 			savestate = dmux_pamf_state::resuming_demux_mutex_lock;
 			label17_resuming_demux_mutex_lock_state:
 
-			if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+			if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -2118,7 +2131,7 @@ error_code DmuxPamfContext::reset_stream(ppu_thread& ppu)
 	switch (savestate)
 	{
 	case 0:
-		if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+		if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2149,7 +2162,7 @@ error_code DmuxPamfContext::reset_stream(ppu_thread& ppu)
 		[[fallthrough]];
 
 	case 2:
-		if (const error_code ret = sys_cond_signal_to(ppu, cond, static_cast<u32>(thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
+		if (const error_code ret = lv2_syscall<sys_cond_signal_to>(ppu, cond, static_cast<u32>(thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
 		{
 			sys_mutex_unlock(ppu, mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
@@ -2216,7 +2229,7 @@ error_code _CellDmuxCoreOpCreateThread(ppu_thread& ppu, vm::ptr<CellDmuxPamfHand
 
 error_code DmuxPamfContext::join_thread(ppu_thread& ppu)
 {
-	if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+	if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -2232,7 +2245,7 @@ error_code DmuxPamfContext::join_thread(ppu_thread& ppu)
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
 
-	return sys_ppu_thread_join(ppu, static_cast<u32>(thread_id), +vm::var<u64>{}) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+	return lv2_syscall<sys_ppu_thread_join>(ppu, static_cast<u32>(thread_id), +vm::var<u64>{}) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 }
 
 error_code _CellDmuxCoreOpJoinThread(ppu_thread& ppu, vm::ptr<CellDmuxPamfHandle> handle)
@@ -2265,7 +2278,7 @@ error_code DmuxPamfContext::set_stream(ppu_thread& ppu, vm::cptr<u8> stream_addr
 
 	if (!waiting_for_spu_state)
 	{
-		if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+		if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2321,7 +2334,7 @@ error_code DmuxPamfElementaryStream::release_au(ppu_thread& ppu, vm::ptr<u8> au_
 	switch (savestate)
 	{
 	case 0:
-		if (sys_mutex_lock(ppu, demuxer->mutex, 0) != CELL_OK)
+		if (lv2_syscall<sys_mutex_lock>(ppu, demuxer->mutex, 0) != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2347,7 +2360,7 @@ error_code DmuxPamfElementaryStream::release_au(ppu_thread& ppu, vm::ptr<u8> au_
 		[[fallthrough]];
 
 	case 2:
-		if (const error_code ret = sys_cond_signal_to(ppu, demuxer->cond, static_cast<u32>(demuxer->thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
+		if (const error_code ret = lv2_syscall<sys_cond_signal_to>(ppu, demuxer->cond, static_cast<u32>(demuxer->thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
 		{
 			sys_mutex_unlock(ppu, demuxer->mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
@@ -2462,7 +2475,7 @@ error_code DmuxPamfContext::enable_es(ppu_thread& ppu, u16 stream_id, u16 privat
 			return CELL_DMUX_PAMF_ERROR_ARG;
 		}
 
-		if (const error_code ret = sys_mutex_lock(ppu, mutex, 0); ret != CELL_OK)
+		if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, mutex, 0); ret != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2615,7 +2628,7 @@ error_code DmuxPamfElementaryStream::disable_es(ppu_thread& ppu)
 	switch (savestate)
 	{
 	case 0:
-		if (sys_mutex_lock(ppu, dmux->mutex, 0) != CELL_OK)
+		if (lv2_syscall<sys_mutex_lock>(ppu, dmux->mutex, 0) != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2660,7 +2673,7 @@ error_code DmuxPamfElementaryStream::disable_es(ppu_thread& ppu)
 		[[fallthrough]];
 
 	case 2:
-		if (const error_code ret = sys_cond_signal_to(ppu, dmux->cond, static_cast<u32>(dmux->thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
+		if (const error_code ret = lv2_syscall<sys_cond_signal_to>(ppu, dmux->cond, static_cast<u32>(dmux->thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
 		{
 			sys_mutex_unlock(ppu, dmux->mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
@@ -2699,7 +2712,7 @@ error_code DmuxPamfElementaryStream::flush_es(ppu_thread& ppu) const
 
 	if (!waiting_for_spu_state)
 	{
-		if (sys_mutex_lock(ppu, demuxer->mutex, 0) != CELL_OK)
+		if (lv2_syscall<sys_mutex_lock>(ppu, demuxer->mutex, 0) != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2742,7 +2755,7 @@ error_code DmuxPamfElementaryStream::reset_es(ppu_thread& ppu) const
 
 	if (!waiting_for_spu_state)
 	{
-		if (sys_mutex_lock(ppu, demuxer->mutex, 0) != CELL_OK)
+		if (lv2_syscall<sys_mutex_lock>(ppu, demuxer->mutex, 0) != CELL_OK)
 		{
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
@@ -2798,7 +2811,7 @@ error_code DmuxPamfContext::reset_stream_and_wait_done(ppu_thread& ppu)
 		return {};
 	}
 
-	if (sys_mutex_lock(ppu, mutex, 0) != CELL_OK)
+	if (lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -2810,7 +2823,7 @@ error_code DmuxPamfContext::reset_stream_and_wait_done(ppu_thread& ppu)
 
 	while (sequence_state != DmuxPamfSequenceState::dormant)
 	{
-		if (sys_cond_wait(ppu, cond, 0) != CELL_OK)
+		if (lv2_syscall<sys_cond_wait>(ppu, cond, 0) != CELL_OK)
 		{
 			sys_mutex_unlock(ppu, mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;

From a03d4f69f8a57e44e20adb6f0e33a38dd5479326 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 23 Mar 2026 16:40:33 +0100
Subject: [PATCH 26/98] logs: Fix global log levels during boot and after
 changing log level settings

---
 rpcs3/main_application.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/rpcs3/main_application.cpp b/rpcs3/main_application.cpp
index ff3b70f952..b5d4401b7e 100644
--- a/rpcs3/main_application.cpp
+++ b/rpcs3/main_application.cpp
@@ -70,10 +70,15 @@ void main_application::InitializeEmulator(const std::string& user, bool show_gui
 	const std::string firmware_version = utils::get_firmware_version();
 	const std::string firmware_string  = firmware_version.empty() ? "Missing Firmware" : ("Firmware version: " + firmware_version);
 	sys_log.always()("%s", firmware_string);
+
+	rpcs3::utils::configure_logs(Emu.IsStopped());
 }
 
 void main_application::OnEmuSettingsChange()
 {
+	// Change logging
+	rpcs3::utils::configure_logs(Emu.IsStopped());
+
 	if (Emu.IsRunning())
 	{
 		enable_display_sleep(!g_cfg.misc.prevent_display_sleep);
@@ -81,9 +86,6 @@ void main_application::OnEmuSettingsChange()
 
 	if (!Emu.IsStopped())
 	{
-		// Change logging (only allowed during gameplay)
-		rpcs3::utils::configure_logs();
-
 		// Force audio provider
 		g_cfg.audio.provider.set(Emu.IsVsh() ? audio_provider::rsxaudio : audio_provider::cell_audio);
 	}

From a8b603dd9266c97100cc6799900988f6042f0336 Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Sun, 15 Feb 2026 15:01:22 +0100
Subject: [PATCH 27/98] CMake: remove option USE_MSVC_STATIC_CRT and clean up

---
 3rdparty/curl/CMakeLists.txt             |  3 --
 3rdparty/protobuf/CMakeLists.txt         |  2 +
 CMakeLists.txt                           | 51 +-----------------------
 buildfiles/cmake/ConfigureCompiler.cmake |  5 ---
 rpcs3/CMakeLists.txt                     |  6 ---
 rpcs3/Emu/CMakeLists.txt                 |  3 ++
 6 files changed, 7 insertions(+), 63 deletions(-)

diff --git a/3rdparty/curl/CMakeLists.txt b/3rdparty/curl/CMakeLists.txt
index b20763af65..2b725169f9 100644
--- a/3rdparty/curl/CMakeLists.txt
+++ b/3rdparty/curl/CMakeLists.txt
@@ -18,9 +18,6 @@ else()
 	set(USE_LIBIDN2 OFF CACHE BOOL "Use libidn2 for IDN support") # Disabled because MacOS CI doesn't work otherwise
 	set(CURL_CA_PATH "none" CACHE STRING "Location of default CA path. Set 'none' to disable or 'auto' for auto-detection. Defaults to 'auto'.")
 	option(CURL_DISABLE_INSTALL "Disable installation targets" ON)
-	if(USE_MSVC_STATIC_CRT)
-		set(CURL_STATIC_CRT ON CACHE BOOL "Use static crt to build curl")
-	endif()
 	if(WIN32)
 		set(ENABLE_UNICODE ON CACHE BOOL "enable Unicode")
 	endif()
diff --git a/3rdparty/protobuf/CMakeLists.txt b/3rdparty/protobuf/CMakeLists.txt
index f8e6bed59b..e1f82f146f 100644
--- a/3rdparty/protobuf/CMakeLists.txt
+++ b/3rdparty/protobuf/CMakeLists.txt
@@ -20,6 +20,8 @@ else()
 	option(protobuf_DISABLE_RTTI "Remove runtime type information in the binaries" OFF)
 	option(protobuf_FORCE_FETCH_DEPENDENCIES "Force all dependencies to be downloaded from GitHub.  Local installations will be ignored." OFF)
 	option(protobuf_LOCAL_DEPENDENCIES_ONLY "Prevent downloading any dependencies from GitHub. If this option is set, the dependency must be available locally as an installed package." OFF)
+	option(protobuf_BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
+	option(protobuf_MSVC_STATIC_RUNTIME "Link static runtime libraries" OFF)
 
 	add_subdirectory(protobuf EXCLUDE_FROM_ALL)
 	target_include_directories(3rdparty_protobuf SYSTEM INTERFACE protobuf/src)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e5b77091cb..217c40f341 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -86,50 +86,7 @@ if(CMAKE_BUILD_TYPE MATCHES "Debug" AND NOT MSVC)
 endif()
 
 if(MSVC)
-    option(USE_MSVC_STATIC_CRT "Use static MSVC C runtime" OFF)
-
-    # TODO(cjj19970505@live.cn)
-    # DiscordRPC binary in 3rdparty is compiled /MT
-    # So theoretically we should enable DiscordRPC in Release and static CRT build
-    # since we might encounter some rumtime issues when more than one CRT version are presented.
-    # https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features?view=msvc-160#what-problems-exist-if-an-application-uses-more-than-one-crt-version
-    # Add other DiscordRPC binaries(compiled with /MTd, /MD, /MDd) or compile it from source may address this issue.
-    if(NOT IS_MULTI_CONFIG)
-        if(NOT(CMAKE_BUILD_TYPE MATCHES "Release" AND USE_MSVC_STATIC_CRT))
-            set(USE_DISCORD_RPC OFF CACHE BOOL "Discord RPC is only available in Release and static CRT build." FORCE)
-        endif()
-    endif()
-
-    if(USE_MSVC_STATIC_CRT)
-        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
-    else()
-        # though doc ( https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html )
-        # says if that property is not set then CMake uses the default value MultiThreaded$<$<CONFIG:Debug>:Debug>DLL
-        # to select a MSVC runtime library.
-        # But yaml-cpp set /MT(d) if CMAKE_MSVC_RUNTIME_LIBRARY is undefined
-        # So we have to define it explicitly
-        set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
-    endif()
-
-    # TODO(cjj19970505@live.cn)
-    # offical QT uses dynamic CRT.
-    # When building our lib with static CRT and debug build type
-    # and linking with Qt with dynamic CRT and debug build,
-    # error is encountered in runtime (which is expected).
-    # But building our lib with static CRT and release build type,
-    # and linking with Qt with dynamic CRT and release build seems to be working,
-    # which is the same config with VS solution.
-    # (though technically it might still have some hidden errors).
-    # So we allow static CRT in both relase and debug build, but prompt warning in debug build.
-    # For more info:
-    # https://docs.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features?view=msvc-160#what-problems-exist-if-an-application-uses-more-than-one-crt-version
-    # https://wiki.qt.io/Technical_FAQ#Why_does_a_statically_built_Qt_use_the_dynamic_Visual_Studio_runtime_libraries_.3F_Do_I_need_to_deploy_those_with_my_application_.3F
-    if(USE_MSVC_STATIC_CRT)
-        if(IS_MULTI_CONFIG OR CMAKE_BUILD_TYPE MATCHES "Debug")
-            message(AUTHOR_WARNING "Debug build currently can not work with static CRT.")
-        endif()
-    endif()
-    add_compile_options(/MP)
+    add_compile_options("$<$<COMPILE_LANGUAGE:C,CXX>:/MP>")
 endif()
 
 if(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
@@ -142,7 +99,7 @@ if(APPLE AND CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
 endif()
 
 if(MSVC)
-    add_compile_options(/wd4530 /utf-8) # C++ exception handler used, but unwind semantics are not enabled
+    add_compile_options("$<$<COMPILE_LANGUAGE:C,CXX>:/wd4530;/utf-8>") # C++ exception handler used, but unwind semantics are not enabled
 endif()
 
 add_subdirectory(3rdparty)
@@ -161,10 +118,6 @@ if (NOT FOUND_LTO EQUAL -1)
     message(FATAL_ERROR "RPCS3 doesn't support building with LTO, use -DDISABLE_LTO=TRUE to force-disable it")
 endif()
 
-if(NOT WIN32)
-    add_compile_options(-pthread)
-endif()
-
 ## Look for Gamemode if its installed on Linux
 if(LINUX)
     ## User chooses whether to Enable GameMode features or not
diff --git a/buildfiles/cmake/ConfigureCompiler.cmake b/buildfiles/cmake/ConfigureCompiler.cmake
index be900d13c2..ea8cd3200b 100644
--- a/buildfiles/cmake/ConfigureCompiler.cmake
+++ b/buildfiles/cmake/ConfigureCompiler.cmake
@@ -96,11 +96,6 @@ else()
 		# This hides our LLVM from mesa's LLVM, otherwise we get some unresolvable conflicts.
 		add_link_options(-Wl,--exclude-libs,ALL)
 	elseif(WIN32)
-		add_compile_definitions(__STDC_FORMAT_MACROS=1)
-
-		# Workaround for mingw64 (MSYS2)
-		add_link_options(-Wl,--allow-multiple-definition)
-
 		# Increase stack limit to 8 MB
 		add_link_options(-Wl,--stack -Wl,8388608)
 	endif()
diff --git a/rpcs3/CMakeLists.txt b/rpcs3/CMakeLists.txt
index 2aa8120752..cfc2495f15 100644
--- a/rpcs3/CMakeLists.txt
+++ b/rpcs3/CMakeLists.txt
@@ -87,12 +87,6 @@ if (NOT ANDROID)
         message(FATAL_ERROR "RPCS3 requires either X11 or Wayland (or both) for Vulkan.")
     endif()
 
-    if(UNIX)
-        set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-        find_package(Threads REQUIRED)
-        target_link_libraries(rpcs3_lib PRIVATE Threads::Threads)
-    endif()
-
     if(WIN32)
         target_link_libraries(rpcs3_lib PRIVATE ws2_32 Iphlpapi Winmm Psapi gdi32 setupapi)
     else()
diff --git a/rpcs3/Emu/CMakeLists.txt b/rpcs3/Emu/CMakeLists.txt
index e115585db9..d691952fa0 100644
--- a/rpcs3/Emu/CMakeLists.txt
+++ b/rpcs3/Emu/CMakeLists.txt
@@ -645,6 +645,9 @@ if(TARGET 3rdparty_vulkan)
     endif()
 endif()
 
+if(NOT WIN32)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+endif()
 find_package(Threads REQUIRED)
 
 target_link_libraries(rpcs3_emu

From 2dd194d3813e3b09642156608330eb96c5d4e09a Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Sat, 28 Feb 2026 22:13:46 +0100
Subject: [PATCH 28/98] make the code build with Clang 22

---
 rpcs3/Emu/Cell/Modules/sceNp.h | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/rpcs3/Emu/Cell/Modules/sceNp.h b/rpcs3/Emu/Cell/Modules/sceNp.h
index 1bc0a345db..e6b8bff945 100644
--- a/rpcs3/Emu/Cell/Modules/sceNp.h
+++ b/rpcs3/Emu/Cell/Modules/sceNp.h
@@ -1267,6 +1267,11 @@ struct SceNpOnlineId
 {
 	char data[SCE_NET_NP_ONLINEID_MAX_LENGTH + 1]; // char term;
 	char dummy[3];
+
+	bool operator<(const SceNpOnlineId& other) const
+	{
+		return memcmp(data, other.data, sizeof(data)) < 0;
+	}
 };
 
 // NP ID structure
@@ -1283,6 +1288,11 @@ struct SceNpId
 	};
 
 	u8 reserved[8];
+
+	bool operator<(const SceNpId& other) const
+	{
+		return handle < other.handle;
+	}
 };
 
 CHECK_SIZE_ALIGN(SceNpId, 0x24, 1);
@@ -1689,12 +1699,22 @@ struct SceNpLobbyId
 {
 	u8 opt[28];
 	u8 reserved[8];
+
+	bool operator<(const SceNpLobbyId& other) const
+	{
+		return memcmp(opt, other.opt, sizeof(opt)) < 0;
+	}
 };
 
 struct SceNpRoomId
 {
 	u8 opt[28];
 	u8 reserved[8];
+
+	bool operator<(const SceNpRoomId& other) const
+	{
+		return memcmp(opt, other.opt, sizeof(opt)) < 0;
+	}
 };
 
 struct SceNpMatchingAttr

From 18bd6d681e51c2a44394ee9943d4c379c9cef69c Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Wed, 4 Mar 2026 23:18:20 +0100
Subject: [PATCH 29/98] cmake: fix build with bundled zlib

---
 3rdparty/zlib/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/3rdparty/zlib/CMakeLists.txt b/3rdparty/zlib/CMakeLists.txt
index 55d7353acf..47645d290c 100644
--- a/3rdparty/zlib/CMakeLists.txt
+++ b/3rdparty/zlib/CMakeLists.txt
@@ -6,7 +6,8 @@ if (USE_SYSTEM_ZLIB)
 	target_link_libraries(3rdparty_zlib INTERFACE ZLIB::ZLIB)
 	target_compile_definitions(3rdparty_zlib INTERFACE -DZLIB_CONST=1)
 else()
-	option(ZLIB_BUILD_EXAMPLES "Enable Zlib Examples" OFF)
+	option(ZLIB_BUILD_TESTING "Enable Zlib Examples as tests" OFF)
+	option(ZLIB_BUILD_SHARED "Enable building zlib shared library" OFF)
 	message(STATUS "RPCS3: Using builtin ZLIB")
 	set(SKIP_INSTALL_ALL ON)
 	add_subdirectory(zlib EXCLUDE_FROM_ALL)

From 86b7ea6bf36faf0db468acac473bda4bc4f90483 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Tue, 24 Mar 2026 20:48:30 +0300
Subject: [PATCH 30/98] overlays/sdf: Avoid 0-height inner boxes for switch
 capsule

- Can introduce dfdx/dfdy discontinuities on the midline as the distance changes direction
- The seams can sometimes become visible if a border is applied on some GPUs
---
 rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
index 0c5c087ce0..304c07a1f6 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_checkbox.cpp
@@ -99,7 +99,7 @@ namespace rsx::overlays
 		ellipse_part->set_size(dim * 2, dim);
 		ellipse_part->set_padding(1);
 		ellipse_part->set_pos(0, 0);
-		ellipse_part->border_radius = (dim - 2) / 2;
+		ellipse_part->border_radius = (dim - 4) / 2; // Avoid perfect capsule shape since we want a border and perfect capsules can have a false border along the midline due to subgroup shenanigans
 
 		circle_part->set_size(dim, dim);
 		circle_part->set_padding(4);

From 9b6bc7c1b441a19000925ba79886dddaf6cb0cb7 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Wed, 25 Mar 2026 01:40:09 +0300
Subject: [PATCH 31/98] rsx: Make resolution scaling configuration non-global

- Paves the way for other changes.
- The main goal is to be able to switch the resolution scale and MSAA level at runtime.
---
 rpcs3/Emu/RSX/Common/surface_store.h         |  12 ++-
 rpcs3/Emu/RSX/Common/surface_utils.h         |  45 +++++---
 rpcs3/Emu/RSX/Common/texture_cache.h         |  20 ++--
 rpcs3/Emu/RSX/Common/texture_cache_helpers.h |  43 ++++----
 rpcs3/Emu/RSX/Core/RSXDisplay.cpp            |   4 +-
 rpcs3/Emu/RSX/Core/RSXDisplay.h              |   4 +-
 rpcs3/Emu/RSX/Core/RSXDrawCommands.cpp       |   4 +-
 rpcs3/Emu/RSX/GL/GLDraw.cpp                  |   2 +-
 rpcs3/Emu/RSX/GL/GLGSRender.cpp              |   3 +-
 rpcs3/Emu/RSX/GL/GLPresent.cpp               |   7 +-
 rpcs3/Emu/RSX/GL/GLRenderTargets.cpp         |   5 +-
 rpcs3/Emu/RSX/GL/GLRenderTargets.h           |  24 +++--
 rpcs3/Emu/RSX/GL/GLTextureCache.h            |   4 +-
 rpcs3/Emu/RSX/RSXThread.cpp                  |  10 +-
 rpcs3/Emu/RSX/RSXThread.h                    |   2 +
 rpcs3/Emu/RSX/RSXZCULL.cpp                   |   2 +-
 rpcs3/Emu/RSX/VK/VKDraw.cpp                  |   2 +-
 rpcs3/Emu/RSX/VK/VKGSRender.cpp              |   6 +-
 rpcs3/Emu/RSX/VK/VKPresent.cpp               |   7 +-
 rpcs3/Emu/RSX/VK/VKRenderTargets.cpp         |   4 +-
 rpcs3/Emu/RSX/VK/VKRenderTargets.h           |  16 ++-
 rpcs3/Emu/RSX/VK/VKResourceManager.cpp       |   2 +-
 rpcs3/Emu/RSX/rsx_utils.h                    | 106 ++++++++++---------
 rpcs3/rpcs3qt/gs_frame.cpp                   |   3 +-
 24 files changed, 207 insertions(+), 130 deletions(-)

diff --git a/rpcs3/Emu/RSX/Common/surface_store.h b/rpcs3/Emu/RSX/Common/surface_store.h
index 4476930607..51152ea32a 100644
--- a/rpcs3/Emu/RSX/Common/surface_store.h
+++ b/rpcs3/Emu/RSX/Common/surface_store.h
@@ -398,6 +398,7 @@ namespace rsx
 			surface_antialiasing antialias,
 			usz width, usz height, usz pitch,
 			u8 bpp,
+			const rsx::surface_scaling_config_t& scaling_config,
 			Args&&... extra_params)
 		{
 			surface_storage_type old_surface_storage;
@@ -531,7 +532,7 @@ namespace rsx
 			if (!new_surface)
 			{
 				ensure(store);
-				new_surface_storage = Traits::create_new_surface(address, format, width, height, pitch, antialias, std::forward<Args>(extra_params)...);
+				new_surface_storage = Traits::create_new_surface(address, format, width, height, pitch, antialias, scaling_config, std::forward<Args>(extra_params)...);
 				new_surface = Traits::get(new_surface_storage);
 				Traits::prepare_surface_for_drawing(command_list, new_surface);
 				allocate_rsx_memory(new_surface);
@@ -842,11 +843,13 @@ namespace rsx
 			surface_color_format color_format,
 			surface_antialiasing antialias,
 			usz width, usz height, usz pitch,
+			const rsx::surface_scaling_config_t& scaling_config,
 			Args&&... extra_params)
 		{
 			return bind_surface_address<false>(
 				command_list, address, color_format, antialias,
 				width, height, pitch, get_format_block_size_in_bytes(color_format),
+				scaling_config,
 				std::forward<Args>(extra_params)...);
 		}
 
@@ -857,12 +860,14 @@ namespace rsx
 			surface_depth_format2 depth_format,
 			surface_antialiasing antialias,
 			usz width, usz height, usz pitch,
+			const rsx::surface_scaling_config_t& scaling_config,
 			Args&&... extra_params)
 		{
 			return bind_surface_address<true>(
 				command_list, address, depth_format, antialias,
 				width, height, pitch,
 				get_format_block_size_in_bytes(depth_format),
+				scaling_config,
 				std::forward<Args>(extra_params)...);
 		}
 
@@ -969,6 +974,7 @@ namespace rsx
 			surface_raster_type raster_type,
 			const std::array<u32, 4> &surface_addresses, u32 address_z,
 			const std::array<u32, 4> &surface_pitch, u32 zeta_pitch,
+			const rsx::surface_scaling_config_t& scaling_config,
 			Args&&... extra_params)
 		{
 			u32 clip_width = clip_horizontal_reg;
@@ -998,7 +1004,7 @@ namespace rsx
 
 					m_bound_render_targets[surface_index] = std::make_pair(surface_addresses[surface_index],
 						bind_address_as_render_targets(command_list, surface_addresses[surface_index], color_format, antialias,
-							clip_width, clip_height, surface_pitch[surface_index], std::forward<Args>(extra_params)...));
+							clip_width, clip_height, surface_pitch[surface_index], scaling_config, std::forward<Args>(extra_params)...));
 
 					m_bound_render_target_ids.push_back(surface_index);
 				}
@@ -1014,7 +1020,7 @@ namespace rsx
 			{
 				m_bound_depth_stencil = std::make_pair(address_z,
 					bind_address_as_depth_stencil(command_list, address_z, depth_format, antialias,
-						clip_width, clip_height, zeta_pitch, std::forward<Args>(extra_params)...));
+						clip_width, clip_height, zeta_pitch, scaling_config, std::forward<Args>(extra_params)...));
 			}
 			else
 			{
diff --git a/rpcs3/Emu/RSX/Common/surface_utils.h b/rpcs3/Emu/RSX/Common/surface_utils.h
index bf7dee2db3..ffd71e6003 100644
--- a/rpcs3/Emu/RSX/Common/surface_utils.h
+++ b/rpcs3/Emu/RSX/Common/surface_utils.h
@@ -88,18 +88,18 @@ namespace rsx
 				auto dst_h = std::get<3>(region);
 
 				// Apply resolution scale if needed
-				if (g_cfg.video.resolution_scale_percent != 100)
-				{
-					auto src = static_cast<T>(source);
+				auto src = static_cast<T>(source);
+				std::tie(src_w, src_h) = rsx::apply_resolution_scale<true>(
+					src->resolution_scaling_config,
+					src_w, src_h,
+					src->template get_surface_width<rsx::surface_metrics::pixels>(),
+					src->template get_surface_height<rsx::surface_metrics::pixels>());
 
-					std::tie(src_w, src_h) = rsx::apply_resolution_scale<true>(src_w, src_h,
-						src->template get_surface_width<rsx::surface_metrics::pixels>(),
-						src->template get_surface_height<rsx::surface_metrics::pixels>());
-
-					std::tie(dst_w, dst_h) = rsx::apply_resolution_scale<true>(dst_w, dst_h,
-						target_surface->template get_surface_width<rsx::surface_metrics::pixels>(),
-						target_surface->template get_surface_height<rsx::surface_metrics::pixels>());
-				}
+				std::tie(dst_w, dst_h) = rsx::apply_resolution_scale<true>(
+					target_surface->resolution_scaling_config,
+					dst_w, dst_h,
+					target_surface->template get_surface_width<rsx::surface_metrics::pixels>(),
+					target_surface->template get_surface_height<rsx::surface_metrics::pixels>());
 
 				width = src_w;
 				height = src_h;
@@ -146,6 +146,9 @@ namespace rsx
 		u8  samples_x = 1;
 		u8  samples_y = 1;
 
+		// Scaling configuration
+		surface_scaling_config_t resolution_scaling_config;
+
 		rsx::address_range32 memory_range;
 
 		std::unique_ptr<typename std::remove_pointer_t<image_storage_type>> resolve_surface;
@@ -303,6 +306,11 @@ namespace rsx
 			format_info.gcm_depth_format = format;
 		}
 
+		void set_resolution_scaling_config(const surface_scaling_config_t& config)
+		{
+			resolution_scaling_config = config;
+		}
+
 		inline rsx::surface_color_format get_surface_color_format() const
 		{
 			return format_info.gcm_color_format;
@@ -323,6 +331,11 @@ namespace rsx
 			);
 		}
 
+		inline const rsx::surface_scaling_config_t& get_resolution_scaling_config() const
+		{
+			return resolution_scaling_config;
+		}
+
 		inline bool dirty() const
 		{
 			return (state_flags != rsx::surface_state_flags::ready) || !old_contents.empty();
@@ -541,10 +554,10 @@ namespace rsx
 			}
 
 			// Apply resolution scale if needed
-			if (g_cfg.video.resolution_scale_percent != 100)
+			if (resolution_scaling_config.scale_percent != 100)
 			{
-				auto [src_width, src_height] = rsx::apply_resolution_scale<true>(slice.width, slice.height, slice.source->width(), slice.source->height());
-				auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(slice.width, slice.height, slice.target->width(), slice.target->height());
+				auto [src_width, src_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, slice.width, slice.height, slice.source->width(), slice.source->height());
+				auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, slice.width, slice.height, slice.target->width(), slice.target->height());
 
 				slice.transfer_scale_x *= f32(dst_width) / src_width;
 				slice.transfer_scale_y *= f32(dst_height) / src_height;
@@ -552,8 +565,8 @@ namespace rsx
 				slice.width = src_width;
 				slice.height = src_height;
 
-				std::tie(slice.src_x, slice.src_y) = rsx::apply_resolution_scale<false>(slice.src_x, slice.src_y, slice.source->width(), slice.source->height());
-				std::tie(slice.dst_x, slice.dst_y) = rsx::apply_resolution_scale<false>(slice.dst_x, slice.dst_y, slice.target->width(), slice.target->height());
+				std::tie(slice.src_x, slice.src_y) = rsx::apply_resolution_scale<false>(resolution_scaling_config, slice.src_x, slice.src_y, slice.source->width(), slice.source->height());
+				std::tie(slice.dst_x, slice.dst_y) = rsx::apply_resolution_scale<false>(resolution_scaling_config, slice.dst_x, slice.dst_y, slice.target->width(), slice.target->height());
 			}
 		}
 
diff --git a/rpcs3/Emu/RSX/Common/texture_cache.h b/rpcs3/Emu/RSX/Common/texture_cache.h
index dfe8043bd3..8aed0ccc34 100644
--- a/rpcs3/Emu/RSX/Common/texture_cache.h
+++ b/rpcs3/Emu/RSX/Common/texture_cache.h
@@ -2413,9 +2413,13 @@ namespace rsx
 				// 2. The image has to have been generated on the GPU (fbo or blit target only)
 
 				rsx::simple_array<copy_region_descriptor> sections;
-				const bool use_upscaling = (result.upload_context == rsx::texture_upload_context::framebuffer_storage && g_cfg.video.resolution_scale_percent != 100);
+				const bool use_upscaling = (result.upload_context == rsx::texture_upload_context::framebuffer_storage);
+				auto to_surface_type = [](const copy_region_descriptor& rgn) -> typename surface_store_type::surface_type
+				{
+					return static_cast<typename surface_store_type::surface_type>(rgn.src);
+				};
 
-				if (!helpers::append_mipmap_level(sections, result, attributes, 0, use_upscaling, attributes)) [[unlikely]]
+				if (!helpers::append_mipmap_level(to_surface_type, sections, result, attributes, 0, use_upscaling, attributes)) [[unlikely]]
 				{
 					// Abort if mip0 is not compatible
 					return result;
@@ -2445,7 +2449,7 @@ namespace rsx
 						options, range, extended_dimension, m_rtts, std::forward<Args>(extras)...);
 
 					if (!ret.validate() ||
-						!helpers::append_mipmap_level(sections, ret, attr2, subsurface, use_upscaling, attributes))
+						!helpers::append_mipmap_level(to_surface_type, sections, ret, attr2, subsurface, use_upscaling, attributes))
 					{
 						// Abort
 						break;
@@ -2778,7 +2782,7 @@ namespace rsx
 					surf->template get_surface_height<rsx::surface_metrics::pixels>() != surf->height())
 				{
 					// Must go through a scaling operation due to resolution scaling being present
-					ensure(g_cfg.video.resolution_scale_percent != 100);
+					ensure(src_subres.surface->resolution_scaling_config.scale_percent != 100);
 					use_null_region = false;
 				}
 			}
@@ -3389,8 +3393,8 @@ namespace rsx
 			{
 				const auto surface_width = src_subres.surface->template get_surface_width<rsx::surface_metrics::pixels>();
 				const auto surface_height = src_subres.surface->template get_surface_height<rsx::surface_metrics::pixels>();
-				std::tie(src_area.x1, src_area.y1) = rsx::apply_resolution_scale<false>(src_area.x1, src_area.y1, surface_width, surface_height);
-				std::tie(src_area.x2, src_area.y2) = rsx::apply_resolution_scale<true>(src_area.x2, src_area.y2, surface_width, surface_height);
+				std::tie(src_area.x1, src_area.y1) = rsx::apply_resolution_scale<false>(src_subres.surface->resolution_scaling_config, src_area.x1, src_area.y1, surface_width, surface_height);
+				std::tie(src_area.x2, src_area.y2) = rsx::apply_resolution_scale<true>(src_subres.surface->resolution_scaling_config, src_area.x2, src_area.y2, surface_width, surface_height);
 
 				// The resource is of surface type; possibly disabled AA emulation
 				src_subres.surface->transform_blit_coordinates(rsx::surface_access::transfer_read, src_area);
@@ -3400,8 +3404,8 @@ namespace rsx
 			{
 				const auto surface_width = dst_subres.surface->template get_surface_width<rsx::surface_metrics::pixels>();
 				const auto surface_height = dst_subres.surface->template get_surface_height<rsx::surface_metrics::pixels>();
-				std::tie(dst_area.x1, dst_area.y1) = rsx::apply_resolution_scale<false>(dst_area.x1, dst_area.y1, surface_width, surface_height);
-				std::tie(dst_area.x2, dst_area.y2) = rsx::apply_resolution_scale<true>(dst_area.x2, dst_area.y2, surface_width, surface_height);
+				std::tie(dst_area.x1, dst_area.y1) = rsx::apply_resolution_scale<false>(dst_subres.surface->resolution_scaling_config, dst_area.x1, dst_area.y1, surface_width, surface_height);
+				std::tie(dst_area.x2, dst_area.y2) = rsx::apply_resolution_scale<true>(dst_subres.surface->resolution_scaling_config, dst_area.x2, dst_area.y2, surface_width, surface_height);
 
 				// The resource is of surface type; possibly disabled AA emulation
 				dst_subres.surface->transform_blit_coordinates(rsx::surface_access::transfer_write, dst_area);
diff --git a/rpcs3/Emu/RSX/Common/texture_cache_helpers.h b/rpcs3/Emu/RSX/Common/texture_cache_helpers.h
index 1560f40ad4..8898830034 100644
--- a/rpcs3/Emu/RSX/Common/texture_cache_helpers.h
+++ b/rpcs3/Emu/RSX/Common/texture_cache_helpers.h
@@ -357,11 +357,11 @@ namespace rsx
 
 				const auto surface_width = section.surface->template get_surface_width<rsx::surface_metrics::pixels>();
 				const auto surface_height = section.surface->template get_surface_height<rsx::surface_metrics::pixels>();
-				const auto [src_width, src_height] = rsx::apply_resolution_scale<true>(section.src_area.width, h, surface_width, surface_height);
-				const auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(section.dst_area.width, h, attr.width, attr.height);
+				const auto [src_width, src_height] = rsx::apply_resolution_scale<true>(section.surface->resolution_scaling_config, section.src_area.width, h, surface_width, surface_height);
+				const auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(section.surface->resolution_scaling_config, section.dst_area.width, h, attr.width, attr.height);
 
-				std::tie(src_x, src_y) = rsx::apply_resolution_scale<false>(src_x, src_y, surface_width, surface_height);
-				std::tie(dst_x, dst_y) = rsx::apply_resolution_scale<false>(dst_x, dst_y, attr.width, attr.height);
+				std::tie(src_x, src_y) = rsx::apply_resolution_scale<false>(section.surface->resolution_scaling_config, src_x, src_y, surface_width, surface_height);
+				std::tie(dst_x, dst_y) = rsx::apply_resolution_scale<false>(section.surface->resolution_scaling_config, dst_x, dst_y, attr.width, attr.height);
 
 				section.surface->memory_barrier(cmd, rsx::surface_access::transfer_read);
 
@@ -430,8 +430,10 @@ namespace rsx
 				if (scaling)
 				{
 					// Since output is upscaled, also upscale on dst
-					const auto [_dst_x, _dst_y] = rsx::apply_resolution_scale<false>(static_cast<u16>(dst_offset.x), static_cast<u16>(dst_y - dst_slice_begin), attr.width, attr.height);
-					const auto [_dst_w, _dst_h] = rsx::apply_resolution_scale<true>(dst_w, height, attr.width, attr.height);
+
+					const auto& scaling_config = rsx::get_current_renderer()->resolution_scaling_config;
+					const auto [_dst_x, _dst_y] = rsx::apply_resolution_scale<false>(scaling_config, static_cast<u16>(dst_offset.x), static_cast<u16>(dst_y - dst_slice_begin), attr.width, attr.height);
+					const auto [_dst_w, _dst_h] = rsx::apply_resolution_scale<true>(scaling_config, dst_w, height, attr.width, attr.height);
 
 					out.push_back
 					({
@@ -660,10 +662,10 @@ namespace rsx
 			bool is_depth = texptr->is_depth_surface();
 			auto attr2 = attr;
 
-			if (rsx::get_resolution_scale_percent() != 100)
+			if (texptr->resolution_scaling_config.scale_percent != 100)
 			{
-				const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale<true>(attr.width, attr.height, surface_width, surface_height);
-				const auto [unused, scaled_slice_h] = rsx::apply_resolution_scale<false>(RSX_SURFACE_DIMENSION_IGNORED, attr.slice_h, surface_width, surface_height);
+				const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale<true>(texptr->resolution_scaling_config, attr.width, attr.height, surface_width, surface_height);
+				const auto [unused, scaled_slice_h] = rsx::apply_resolution_scale<false>(texptr->resolution_scaling_config, RSX_SURFACE_DIMENSION_IGNORED, attr.slice_h, surface_width, surface_height);
 				attr2.width = scaled_w;
 				attr2.height = scaled_h;
 				attr2.slice_h = scaled_slice_h;
@@ -841,7 +843,8 @@ namespace rsx
 			}
 
 			// If this method was called, there is no easy solution, likely means atlas gather is needed
-			const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale(attr2.width, attr2.height);
+			const auto& scaling_config = rsx::get_current_renderer()->resolution_scaling_config;
+			const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale(scaling_config, attr2.width, attr2.height);
 			const auto format_class = classify_format(attr2.gcm_format);
 			const auto upload_context = (fbos.empty()) ? texture_upload_context::shader_read : texture_upload_context::framebuffer_storage;
 
@@ -892,14 +895,15 @@ namespace rsx
 			return result;
 		}
 
-		template<typename sampled_image_descriptor, typename copy_region_descriptor_type>
+		template<typename to_surface_type_converter, typename sampled_image_descriptor, typename copy_region_descriptor_type>
 		bool append_mipmap_level(
+			to_surface_type_converter&& as_surface_type,                // Cast function to surface type
 			rsx::simple_array<copy_region_descriptor_type>& sections,   // Destination list
-			const sampled_image_descriptor& level,                // Descriptor for the image level being checked
-			const image_section_attributes_t& attr,               // Attributes of image level
-			u8 mipmap_level,                                      // Level index
-			bool apply_upscaling,                                 // Whether to upscale the results or not
-			const image_section_attributes_t& level0_attr)        // Attributes of the first mipmap level
+			const sampled_image_descriptor& level,                      // Descriptor for the image level being checked
+			const image_section_attributes_t& attr,                     // Attributes of image level
+			u8 mipmap_level,                                            // Level index
+			bool apply_upscaling,                                       // Whether to upscale the results or not
+			const image_section_attributes_t& level0_attr)              // Attributes of the first mipmap level
 		{
 			if (level.image_handle)
 			{
@@ -916,7 +920,8 @@ namespace rsx
 				// Calculate transfer dimensions from attr
 				if (level.upload_context == rsx::texture_upload_context::framebuffer_storage) [[likely]]
 				{
-					std::tie(mip.src_w, mip.src_h) = rsx::apply_resolution_scale<true>(attr.width, attr.height);
+					auto rtv = as_surface_type(mip);
+					std::tie(mip.src_w, mip.src_h) = rsx::apply_resolution_scale<true>(rtv->resolution_scaling_config, attr.width, attr.height);
 				}
 				else
 				{
@@ -964,7 +969,9 @@ namespace rsx
 			if (apply_upscaling)
 			{
 				auto& mip = sections.back();
-				std::tie(mip.dst_w, mip.dst_h) = rsx::apply_resolution_scale<true>(mip.dst_w, mip.dst_h, level0_attr.width, level0_attr.height);
+				std::tie(mip.dst_w, mip.dst_h) = rsx::apply_resolution_scale<true>(
+					as_surface_type(mip)->resolution_scaling_config,
+					mip.dst_w, mip.dst_h, level0_attr.width, level0_attr.height);
 			}
 
 			return true;
diff --git a/rpcs3/Emu/RSX/Core/RSXDisplay.cpp b/rpcs3/Emu/RSX/Core/RSXDisplay.cpp
index e263a945ef..f86c6dea04 100644
--- a/rpcs3/Emu/RSX/Core/RSXDisplay.cpp
+++ b/rpcs3/Emu/RSX/Core/RSXDisplay.cpp
@@ -49,7 +49,7 @@ namespace rsx
 		}
 	}
 
-	std::string framebuffer_statistics_t::to_string(bool squash) const
+	std::string framebuffer_statistics_t::to_string(const surface_scaling_config_t& scaling_config, bool squash) const
 	{
 		// Format is sorted by sample count
 		struct sorted_message_t
@@ -70,7 +70,7 @@ namespace rsx
 		for (const auto& [aa_mode, stat] : data)
 		{
 			auto real_stat = stat;
-			std::tie(real_stat.width, real_stat.height) = apply_resolution_scale(stat.width, stat.height);
+			std::tie(real_stat.width, real_stat.height) = apply_resolution_scale(scaling_config, stat.width, stat.height);
 			real_stats.push_back(real_stat);
 
 			sorted_message_t msg;
diff --git a/rpcs3/Emu/RSX/Core/RSXDisplay.h b/rpcs3/Emu/RSX/Core/RSXDisplay.h
index 77407f2f19..6a04374e1b 100644
--- a/rpcs3/Emu/RSX/Core/RSXDisplay.h
+++ b/rpcs3/Emu/RSX/Core/RSXDisplay.h
@@ -12,6 +12,8 @@ namespace rsx
 {
 	enum class surface_antialiasing : u8;
 
+	struct surface_scaling_config_t;
+
 	struct framebuffer_dimensions_t
 	{
 		u16 width;
@@ -42,7 +44,7 @@ namespace rsx
 		void add(u16 width, u16 height, rsx::surface_antialiasing aa);
 
 		// Returns a formatted string representing the statistics collected over the frame.
-		std::string to_string(bool squash) const;
+		std::string to_string(const surface_scaling_config_t& scaling_config, bool squash) const;
 	};
 
 	struct frame_statistics_t
diff --git a/rpcs3/Emu/RSX/Core/RSXDrawCommands.cpp b/rpcs3/Emu/RSX/Core/RSXDrawCommands.cpp
index 53f6ce31e7..8ef45e1f06 100644
--- a/rpcs3/Emu/RSX/Core/RSXDrawCommands.cpp
+++ b/rpcs3/Emu/RSX/Core/RSXDrawCommands.cpp
@@ -699,7 +699,9 @@ namespace rsx
 		const auto window_origin = REGS(m_ctx)->shader_window_origin();
 		const u32 window_height = REGS(m_ctx)->shader_window_height();
 		const auto pixel_center = REGS(m_ctx)->pixel_center();
-		const f32 resolution_scale = (window_height <= static_cast<u32>(g_cfg.video.min_scalable_dimension)) ? 1.f : rsx::get_resolution_scale();
+		const f32 resolution_scale = (window_height <= RSX(m_ctx)->resolution_scaling_config.min_scalable_dimension)
+			? 1.f
+			: RSX(m_ctx)->resolution_scaling_config.scale_factor();
 
 		payload.wpos_scale = (window_origin == rsx::window_origin::top) ? (1.f / resolution_scale) : (-1.f / resolution_scale);
 		payload.wpos_bias[0] = 0.f;
diff --git a/rpcs3/Emu/RSX/GL/GLDraw.cpp b/rpcs3/Emu/RSX/GL/GLDraw.cpp
index 3de2585523..d0c2e233e9 100644
--- a/rpcs3/Emu/RSX/GL/GLDraw.cpp
+++ b/rpcs3/Emu/RSX/GL/GLDraw.cpp
@@ -227,7 +227,7 @@ void GLGSRender::update_draw_state()
 	case rsx::primitive_type::lines:
 	case rsx::primitive_type::line_loop:
 	case rsx::primitive_type::line_strip:
-		gl_state.line_width(rsx::method_registers.line_width() * rsx::get_resolution_scale());
+		gl_state.line_width(rsx::method_registers.line_width() * resolution_scaling_config.scale_factor());
 		gl_state.enable(rsx::method_registers.line_smooth_enabled(), GL_LINE_SMOOTH);
 		break;
 	default:
diff --git a/rpcs3/Emu/RSX/GL/GLGSRender.cpp b/rpcs3/Emu/RSX/GL/GLGSRender.cpp
index 20553eeb00..c1acabd601 100644
--- a/rpcs3/Emu/RSX/GL/GLGSRender.cpp
+++ b/rpcs3/Emu/RSX/GL/GLGSRender.cpp
@@ -73,6 +73,7 @@ void GLGSRender::set_viewport()
 {
 	// NOTE: scale offset matrix already contains the viewport transformation
 	const auto [clip_width, clip_height] = rsx::apply_resolution_scale<true>(
+		resolution_scaling_config,
 		rsx::method_registers.surface_clip_width(), rsx::method_registers.surface_clip_height());
 
 	glViewport(0, 0, clip_width, clip_height);
@@ -936,7 +937,7 @@ void GLGSRender::load_program_env()
 		m_draw_processor.fill_scale_offset_data(buf, false);
 		m_draw_processor.fill_user_clip_data(buf + 64);
 		*(reinterpret_cast<u32*>(buf + 68)) = rsx::method_registers.transform_branch_bits();
-		*(reinterpret_cast<f32*>(buf + 72)) = rsx::method_registers.point_size() * rsx::get_resolution_scale();
+		*(reinterpret_cast<f32*>(buf + 72)) = rsx::method_registers.point_size() * resolution_scaling_config.scale_factor();
 		*(reinterpret_cast<f32*>(buf + 76)) = rsx::method_registers.clip_min();
 		*(reinterpret_cast<f32*>(buf + 80)) = rsx::method_registers.clip_max();
 
diff --git a/rpcs3/Emu/RSX/GL/GLPresent.cpp b/rpcs3/Emu/RSX/GL/GLPresent.cpp
index 68a570e359..e101d77e03 100644
--- a/rpcs3/Emu/RSX/GL/GLPresent.cpp
+++ b/rpcs3/Emu/RSX/GL/GLPresent.cpp
@@ -95,6 +95,7 @@ gl::texture* GLGSRender::get_present_source(gl::present_surface_info* info, cons
 				image = section.surface->get_surface(rsx::surface_access::transfer_read);
 
 				std::tie(info->width, info->height) = rsx::apply_resolution_scale<true>(
+					resolution_scaling_config,
 					std::min(surface_width, info->width),
 					std::min(surface_height, info->height));
 			}
@@ -225,7 +226,7 @@ void GLGSRender::flip(const rsx::display_flip_info_t& info)
 
 		if (avconfig.stereo_enabled) [[unlikely]]
 		{
-			const auto [unused, min_expected_height] = rsx::apply_resolution_scale<true>(RSX_SURFACE_DIMENSION_IGNORED, buffer_height + 30);
+			const auto [unused, min_expected_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, RSX_SURFACE_DIMENSION_IGNORED, buffer_height + 30);
 			if (image_to_flip->height() < min_expected_height)
 			{
 				// Get image for second eye
@@ -240,7 +241,7 @@ void GLGSRender::flip(const rsx::display_flip_info_t& info)
 			else
 			{
 				// Account for possible insets
-				const auto [unused2, scaled_buffer_height] = rsx::apply_resolution_scale<true>(RSX_SURFACE_DIMENSION_IGNORED, buffer_height);
+				const auto [unused2, scaled_buffer_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, RSX_SURFACE_DIMENSION_IGNORED, buffer_height);
 				buffer_height = std::min<u32>(image_to_flip->height() - min_expected_height, scaled_buffer_height);
 			}
 		}
@@ -477,7 +478,7 @@ void GLGSRender::flip(const rsx::display_flip_info_t& info)
 			"Texture uploads: %11u (%u from CPU - %02u%%, %u copies avoided)\n"
 			"Vertex cache hits: %9u/%u (%u%%)\n"
 			"Program cache lookup ellision: %u/%u (%u%%)",
-			info.stats.framebuffer_stats.to_string(!backend_config.supports_hw_msaa),
+			info.stats.framebuffer_stats.to_string(resolution_scaling_config, !backend_config.supports_hw_msaa),
 			get_load(), info.stats.draw_calls, info.stats.setup_time, info.stats.vertex_upload_time,
 			info.stats.textures_upload_time, info.stats.draw_exec_time, num_dirty_textures, texture_memory_size,
 			num_flushes, num_misses, cache_miss_ratio, num_unavoidable, num_mispredict, num_speculate,
diff --git a/rpcs3/Emu/RSX/GL/GLRenderTargets.cpp b/rpcs3/Emu/RSX/GL/GLRenderTargets.cpp
index a61fb4b365..34c2ca72d3 100644
--- a/rpcs3/Emu/RSX/GL/GLRenderTargets.cpp
+++ b/rpcs3/Emu/RSX/GL/GLRenderTargets.cpp
@@ -141,7 +141,8 @@ void GLGSRender::init_buffers(rsx::framebuffer_creation_context context, bool /*
 		m_framebuffer_layout.width, m_framebuffer_layout.height,
 		m_framebuffer_layout.target, m_framebuffer_layout.aa_mode, m_framebuffer_layout.raster_type,
 		m_framebuffer_layout.color_addresses, m_framebuffer_layout.zeta_address,
-		m_framebuffer_layout.actual_color_pitch, m_framebuffer_layout.actual_zeta_pitch);
+		m_framebuffer_layout.actual_color_pitch, m_framebuffer_layout.actual_zeta_pitch,
+		resolution_scaling_config);
 
 	std::array<GLuint, 4> color_targets;
 	GLuint depth_stencil_target;
@@ -448,7 +449,7 @@ void gl::render_target::load_memory(gl::command_context& cmd)
 	subres.data = { vm::get_super_ptr<const std::byte>(base_addr), static_cast<std::span<const std::byte>::size_type>(rsx_pitch * surface_height * samples_y) };
 
 	// TODO: MSAA support
-	if (g_cfg.video.resolution_scale_percent == 100 && spp == 1) [[likely]]
+	if (resolution_scaling_config.scale_percent == 100 && spp == 1) [[likely]]
 	{
 		gl::upload_texture(cmd, this, get_gcm_format(), is_swizzled, { subres });
 	}
diff --git a/rpcs3/Emu/RSX/GL/GLRenderTargets.h b/rpcs3/Emu/RSX/GL/GLRenderTargets.h
index ee3bc03956..ecf7e161da 100644
--- a/rpcs3/Emu/RSX/GL/GLRenderTargets.h
+++ b/rpcs3/Emu/RSX/GL/GLRenderTargets.h
@@ -98,7 +98,7 @@ namespace gl
 		bool matches_dimensions(u16 _width, u16 _height) const
 		{
 			//Use forward scaling to account for rounding and clamping errors
-			const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale<true>(_width, _height);
+			const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale<true>(resolution_scaling_config, _width, _height);
 			return (scaled_w == width()) && (scaled_h == height());
 		}
 
@@ -138,11 +138,12 @@ struct gl_render_target_traits
 		u32 address,
 		rsx::surface_color_format surface_color_format,
 		usz width, usz height, usz pitch,
-		rsx::surface_antialiasing antialias
+		rsx::surface_antialiasing antialias,
+		const rsx::surface_scaling_config_t& resolution_scaling_config
 	)
 	{
 		auto format = rsx::internals::surface_color_format_to_gl(surface_color_format);
-		const auto [width_, height_] = rsx::apply_resolution_scale<true>(static_cast<u16>(width), static_cast<u16>(height));
+		const auto [width_, height_] = rsx::apply_resolution_scale<true>(resolution_scaling_config, static_cast<u16>(width), static_cast<u16>(height));
 
 		u8 samples;
 		rsx::surface_sample_layout sample_layout;
@@ -162,6 +163,7 @@ struct gl_render_target_traits
 
 		result->set_name(fmt::format("RTV_%u@0x%x", result->id(), address));
 		result->set_aa_mode(antialias);
+		result->set_resolution_scaling_config(resolution_scaling_config);
 		result->set_native_pitch(static_cast<u32>(width) * get_format_block_size_in_bytes(surface_color_format) * result->samples_x);
 		result->set_surface_dimensions(static_cast<u16>(width), static_cast<u16>(height), static_cast<u32>(pitch));
 		result->set_format(surface_color_format);
@@ -182,11 +184,12 @@ struct gl_render_target_traits
 			u32 address,
 			rsx::surface_depth_format2 surface_depth_format,
 			usz width, usz height, usz pitch,
-			rsx::surface_antialiasing antialias
+			rsx::surface_antialiasing antialias,
+			const rsx::surface_scaling_config_t& resolution_scaling_config
 		)
 	{
 		auto format = rsx::internals::surface_depth_format_to_gl(surface_depth_format);
-		const auto [width_, height_] = rsx::apply_resolution_scale<true>(static_cast<u16>(width), static_cast<u16>(height));
+		const auto [width_, height_] = rsx::apply_resolution_scale<true>(resolution_scaling_config, static_cast<u16>(width), static_cast<u16>(height));
 
 		u8 samples;
 		rsx::surface_sample_layout sample_layout;
@@ -206,6 +209,7 @@ struct gl_render_target_traits
 
 		result->set_name(fmt::format("DSV_%u@0x%x", result->id(), address));
 		result->set_aa_mode(antialias);
+		result->set_resolution_scaling_config(resolution_scaling_config);
 		result->set_surface_dimensions(static_cast<u16>(width), static_cast<u16>(height), static_cast<u32>(pitch));
 		result->set_format(surface_depth_format);
 		result->set_native_pitch(static_cast<u32>(width) * get_format_block_size_in_bytes(surface_depth_format) * result->samples_x);
@@ -230,8 +234,11 @@ struct gl_render_target_traits
 		if (!sink)
 		{
 			auto internal_format = static_cast<GLenum>(ref->get_internal_format());
-			const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(prev.width, prev.height,
-				ref->get_surface_width<rsx::surface_metrics::pixels>(), ref->get_surface_height<rsx::surface_metrics::pixels>());
+			const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(
+				ref->resolution_scaling_config,
+				prev.width, prev.height,
+				ref->get_surface_width<rsx::surface_metrics::pixels>(),
+				ref->get_surface_height<rsx::surface_metrics::pixels>());
 
 			sink = std::make_unique<gl::render_target>(new_w, new_h, ref->samples(), internal_format, ref->format_class());
 			sink->add_ref();
@@ -240,6 +247,9 @@ struct gl_render_target_traits
 			sink->state_flags = rsx::surface_state_flags::erase_bkgnd;
 			sink->format_info = ref->format_info;
 
+			sink->sample_layout = ref->sample_layout;
+			sink->resolution_scaling_config = ref->resolution_scaling_config;
+
 			sink->set_name(fmt::format("SINK_%u@0x%x", sink->id(), address));
 			sink->set_spp(ref->get_spp());
 			sink->set_native_pitch(static_cast<u32>(prev.width) * ref->get_bpp() * ref->samples_x);
diff --git a/rpcs3/Emu/RSX/GL/GLTextureCache.h b/rpcs3/Emu/RSX/GL/GLTextureCache.h
index a4b931186f..27b455374e 100644
--- a/rpcs3/Emu/RSX/GL/GLTextureCache.h
+++ b/rpcs3/Emu/RSX/GL/GLTextureCache.h
@@ -287,6 +287,7 @@ namespace gl
 			u32 transfer_width = width;
 			u32 transfer_height = height;
 			u32 transfer_x = 0, transfer_y = 0;
+			u16 resolution_scale_percent = 100;
 
 			if (context == rsx::texture_upload_context::framebuffer_storage)
 			{
@@ -295,9 +296,10 @@ namespace gl
 				target_texture = surface->get_surface(rsx::surface_access::transfer_read);
 				transfer_width *= surface->samples_x;
 				transfer_height *= surface->samples_y;
+				resolution_scale_percent = surface->resolution_scaling_config.scale_percent;
 			}
 
-			if ((rsx::get_resolution_scale_percent() != 100 && context == rsx::texture_upload_context::framebuffer_storage) ||
+			if ((resolution_scale_percent != 100 && context == rsx::texture_upload_context::framebuffer_storage) ||
 				(vram_texture->pitch() != rsx_pitch))
 			{
 				areai src_area = { 0, 0, 0, 0 };
diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp
index 7d634de677..6ffa8f2e9a 100644
--- a/rpcs3/Emu/RSX/RSXThread.cpp
+++ b/rpcs3/Emu/RSX/RSXThread.cpp
@@ -996,6 +996,12 @@ namespace rsx
 		fifo_ctrl = std::make_unique<::rsx::FIFO::FIFO_control>(this);
 		fifo_ctrl->set_get(ctrl->get);
 
+		resolution_scaling_config =
+		{
+			.scale_percent = static_cast<u16>(g_cfg.video.resolution_scale_percent),
+			.min_scalable_dimension = static_cast<u16>(g_cfg.video.min_scalable_dimension),
+		};
+
 		last_guest_flip_timestamp = get_system_time() - 1000000;
 
 		vblank_count = 0;
@@ -1940,8 +1946,8 @@ namespace rsx
 			m_graphics_state.set(rsx::rtt_config_valid);
 		}
 
-		std::tie(region.x1, region.y1) = rsx::apply_resolution_scale<false>(x1, y1, m_framebuffer_layout.width, m_framebuffer_layout.height);
-		std::tie(region.x2, region.y2) = rsx::apply_resolution_scale<true>(x2, y2, m_framebuffer_layout.width, m_framebuffer_layout.height);
+		std::tie(region.x1, region.y1) = rsx::apply_resolution_scale<false>(resolution_scaling_config, x1, y1, m_framebuffer_layout.width, m_framebuffer_layout.height);
+		std::tie(region.x2, region.y2) = rsx::apply_resolution_scale<true>(resolution_scaling_config, x2, y2, m_framebuffer_layout.width, m_framebuffer_layout.height);
 
 		return true;
 	}
diff --git a/rpcs3/Emu/RSX/RSXThread.h b/rpcs3/Emu/RSX/RSXThread.h
index 4b2de0acc4..cdeaa9f419 100644
--- a/rpcs3/Emu/RSX/RSXThread.h
+++ b/rpcs3/Emu/RSX/RSXThread.h
@@ -215,6 +215,8 @@ namespace rsx
 		atomic_bitmask_t<flip_request> async_flip_requested{};
 		u8 async_flip_buffer{ 0 };
 
+		surface_scaling_config_t resolution_scaling_config{};
+
 		void capture_frame(const std::string& name);
 		const backend_configuration& get_backend_config() const { return backend_config; }
 
diff --git a/rpcs3/Emu/RSX/RSXZCULL.cpp b/rpcs3/Emu/RSX/RSXZCULL.cpp
index 54b7ed4139..51052c8879 100644
--- a/rpcs3/Emu/RSX/RSXZCULL.cpp
+++ b/rpcs3/Emu/RSX/RSXZCULL.cpp
@@ -335,7 +335,7 @@ namespace rsx
 
 			auto scale_result = [](u32 value)
 			{
-				const auto scale = rsx::get_resolution_scale_percent();
+				const auto scale = get_current_renderer()->resolution_scaling_config.scale_percent;
 				const auto result = (value * 10000ull) / (scale * scale);
 				return std::max(1u, static_cast<u32>(result));
 			};
diff --git a/rpcs3/Emu/RSX/VK/VKDraw.cpp b/rpcs3/Emu/RSX/VK/VKDraw.cpp
index b18ebaed3a..5c3737fdf2 100644
--- a/rpcs3/Emu/RSX/VK/VKDraw.cpp
+++ b/rpcs3/Emu/RSX/VK/VKDraw.cpp
@@ -164,7 +164,7 @@ void VKGSRender::update_draw_state()
 		rsx::method_registers.current_draw_clause.primitive <= rsx::primitive_type::line_strip)
 	{
 		const float actual_line_width =
-			m_device->get_wide_lines_support() ? rsx::method_registers.line_width() * rsx::get_resolution_scale() : 1.f;
+			m_device->get_wide_lines_support() ? rsx::method_registers.line_width() * resolution_scaling_config.scale_factor() : 1.f;
 		vkCmdSetLineWidth(*m_current_command_buffer, actual_line_width);
 	}
 
diff --git a/rpcs3/Emu/RSX/VK/VKGSRender.cpp b/rpcs3/Emu/RSX/VK/VKGSRender.cpp
index 8d90f9a09f..5906c14824 100644
--- a/rpcs3/Emu/RSX/VK/VKGSRender.cpp
+++ b/rpcs3/Emu/RSX/VK/VKGSRender.cpp
@@ -1152,6 +1152,7 @@ void VKGSRender::check_present_status()
 void VKGSRender::set_viewport()
 {
 	const auto [clip_width, clip_height] = rsx::apply_resolution_scale<true>(
+		resolution_scaling_config,
 		rsx::method_registers.surface_clip_width(), rsx::method_registers.surface_clip_height());
 
 	const auto zclip_near = rsx::method_registers.clip_min();
@@ -1952,7 +1953,7 @@ void VKGSRender::load_program_env()
 		m_draw_processor.fill_scale_offset_data(buf, false);
 		m_draw_processor.fill_user_clip_data(buf + 64);
 		*(reinterpret_cast<u32*>(buf + 68)) = ctx->transform_branch_bits();
-		*(reinterpret_cast<f32*>(buf + 72)) = ctx->point_size() * rsx::get_resolution_scale();
+		*(reinterpret_cast<f32*>(buf + 72)) = ctx->point_size() * resolution_scaling_config.scale_factor();
 		*(reinterpret_cast<f32*>(buf + 76)) = ctx->clip_min();
 		*(reinterpret_cast<f32*>(buf + 80)) = ctx->clip_max();
 
@@ -2441,6 +2442,7 @@ void VKGSRender::prepare_rtts(rsx::framebuffer_creation_context context)
 		m_framebuffer_layout.target, m_framebuffer_layout.aa_mode, m_framebuffer_layout.raster_type,
 		m_framebuffer_layout.color_addresses, m_framebuffer_layout.zeta_address,
 		m_framebuffer_layout.actual_color_pitch, m_framebuffer_layout.actual_zeta_pitch,
+		resolution_scaling_config,
 		(*m_device), *m_current_command_buffer);
 
 	// Reset framebuffer information
@@ -2620,7 +2622,7 @@ void VKGSRender::prepare_rtts(rsx::framebuffer_creation_context context)
 	m_cached_renderpass = vk::get_renderpass(*m_device, m_current_renderpass_key);
 
 	// Search old framebuffers for this same configuration
-	const auto [fbo_width, fbo_height] = rsx::apply_resolution_scale<true>(m_framebuffer_layout.width, m_framebuffer_layout.height);
+	const auto [fbo_width, fbo_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, m_framebuffer_layout.width, m_framebuffer_layout.height);
 
 	if (m_draw_fbo)
 	{
diff --git a/rpcs3/Emu/RSX/VK/VKPresent.cpp b/rpcs3/Emu/RSX/VK/VKPresent.cpp
index f8345726ef..3b47e28162 100644
--- a/rpcs3/Emu/RSX/VK/VKPresent.cpp
+++ b/rpcs3/Emu/RSX/VK/VKPresent.cpp
@@ -341,6 +341,7 @@ vk::viewable_image* VKGSRender::get_present_source(/* inout */ vk::present_surfa
 				image_to_flip = section.surface->get_surface(rsx::surface_access::transfer_read);
 
 				std::tie(info->width, info->height) = rsx::apply_resolution_scale<true>(
+					resolution_scaling_config,
 					std::min(surface_width, info->width),
 					std::min(surface_height, info->height));
 			}
@@ -550,7 +551,7 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
 
 		if (avconfig.stereo_enabled) [[unlikely]]
 		{
-			const auto [unused, min_expected_height] = rsx::apply_resolution_scale<true>(RSX_SURFACE_DIMENSION_IGNORED, buffer_height + 30);
+			const auto [unused, min_expected_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, RSX_SURFACE_DIMENSION_IGNORED, buffer_height + 30);
 			if (image_to_flip->height() < min_expected_height)
 			{
 				// Get image for second eye
@@ -565,7 +566,7 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
 			else
 			{
 				// Account for possible insets
-				const auto [unused2, scaled_buffer_height] = rsx::apply_resolution_scale<true>(RSX_SURFACE_DIMENSION_IGNORED, buffer_height);
+				const auto [unused2, scaled_buffer_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, RSX_SURFACE_DIMENSION_IGNORED, buffer_height);
 				buffer_height = std::min<u32>(image_to_flip->height() - min_expected_height, scaled_buffer_height);
 			}
 		}
@@ -935,7 +936,7 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
 				"Texture uploads: %12u (%u from CPU - %02u%%, %u copies avoided)\n"
 				"Vertex cache hits: %10u/%u (%u%%)\n"
 				"Program cache lookup ellision: %u/%u (%u%%)",
-				info.stats.framebuffer_stats.to_string(!backend_config.supports_hw_msaa),
+				info.stats.framebuffer_stats.to_string(resolution_scaling_config, !backend_config.supports_hw_msaa),
 				get_load(), info.stats.draw_calls, info.stats.submit_count, info.stats.setup_time, info.stats.vertex_upload_time,
 				info.stats.textures_upload_time, info.stats.draw_exec_time, info.stats.flip_time,
 				num_dirty_textures, texture_memory_size, tmp_texture_memory_size,
diff --git a/rpcs3/Emu/RSX/VK/VKRenderTargets.cpp b/rpcs3/Emu/RSX/VK/VKRenderTargets.cpp
index 9d66baa9d2..138f7e46aa 100644
--- a/rpcs3/Emu/RSX/VK/VKRenderTargets.cpp
+++ b/rpcs3/Emu/RSX/VK/VKRenderTargets.cpp
@@ -735,7 +735,7 @@ namespace vk
 #endif
 		}
 
-		if (g_cfg.video.resolution_scale_percent == 100 && spp == 1) [[likely]]
+		if (resolution_scaling_config.scale_percent == 100 && spp == 1) [[likely]]
 		{
 			push_layout(cmd, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 			vk::upload_image(cmd, this, { subres }, get_gcm_format(), is_swizzled, 1, aspect(), upload_heap, heap_align, upload_flags);
@@ -842,7 +842,7 @@ namespace vk
 	bool render_target::matches_dimensions(u16 _width, u16 _height) const
 	{
 		// Use forward scaling to account for rounding and clamping errors
-		const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale<true>(_width, _height);
+		const auto [scaled_w, scaled_h] = rsx::apply_resolution_scale<true>(resolution_scaling_config, _width, _height);
 		return (scaled_w == width()) && (scaled_h == height());
 	}
 
diff --git a/rpcs3/Emu/RSX/VK/VKRenderTargets.h b/rpcs3/Emu/RSX/VK/VKRenderTargets.h
index 3c3ef0acbd..7d4f515b4e 100644
--- a/rpcs3/Emu/RSX/VK/VKRenderTargets.h
+++ b/rpcs3/Emu/RSX/VK/VKRenderTargets.h
@@ -200,6 +200,7 @@ namespace vk
 			rsx::surface_color_format format,
 			usz width, usz height, usz pitch,
 			rsx::surface_antialiasing antialias,
+			const rsx::surface_scaling_config_t& resolution_scaling_config,
 			vk::render_device& device, vk::command_buffer& cmd)
 		{
 			const auto fmt = vk::get_compatible_surface_format(format);
@@ -231,7 +232,7 @@ namespace vk
 			}
 
 			std::unique_ptr<vk::render_target> rtt;
-			const auto [width_, height_] = rsx::apply_resolution_scale<true>(static_cast<u16>(width), static_cast<u16>(height));
+			const auto [width_, height_] = rsx::apply_resolution_scale<true>(resolution_scaling_config, static_cast<u16>(width), static_cast<u16>(height));
 
 			rtt = std::make_unique<vk::render_target>(device, device.get_memory_mapping().device_local,
 				VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
@@ -251,6 +252,7 @@ namespace vk
 
 			rtt->set_format(format);
 			rtt->set_aa_mode(antialias);
+			rtt->set_resolution_scaling_config(resolution_scaling_config);
 			rtt->sample_layout = sample_layout;
 			rtt->memory_usage_flags = rsx::surface_usage_flags::attachment;
 			rtt->state_flags = rsx::surface_state_flags::erase_bkgnd;
@@ -270,6 +272,7 @@ namespace vk
 			rsx::surface_depth_format2 format,
 			usz width, usz height, usz pitch,
 			rsx::surface_antialiasing antialias,
+			const rsx::surface_scaling_config_t& resolution_scaling_config,
 			vk::render_device& device, vk::command_buffer& cmd)
 		{
 			const VkFormat requested_format = vk::get_compatible_depth_surface_format(device.get_formats_support(), format);
@@ -296,7 +299,7 @@ namespace vk
 			}
 
 			std::unique_ptr<vk::render_target> ds;
-			const auto [width_, height_] = rsx::apply_resolution_scale<true>(static_cast<u16>(width), static_cast<u16>(height));
+			const auto [width_, height_] = rsx::apply_resolution_scale<true>(resolution_scaling_config, static_cast<u16>(width), static_cast<u16>(height));
 
 			ds = std::make_unique<vk::render_target>(device, device.get_memory_mapping().device_local,
 				VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
@@ -316,6 +319,7 @@ namespace vk
 
 			ds->set_format(format);
 			ds->set_aa_mode(antialias);
+			ds->set_resolution_scaling_config(resolution_scaling_config);
 			ds->sample_layout = sample_layout;
 			ds->memory_usage_flags = rsx::surface_usage_flags::attachment;
 			ds->state_flags = rsx::surface_state_flags::erase_bkgnd;
@@ -337,7 +341,9 @@ namespace vk
 		{
 			if (!sink)
 			{
-				const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(prev.width, prev.height,
+				const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(
+					ref->resolution_scaling_config,
+					prev.width, prev.height,
 					ref->get_surface_width<rsx::surface_metrics::pixels>(), ref->get_surface_height<rsx::surface_metrics::pixels>());
 
 				auto& dev = cmd.get_command_pool().get_owner();
@@ -355,6 +361,10 @@ namespace vk
 					ref->format_class());
 
 				sink->add_ref();
+
+				sink->sample_layout = ref->sample_layout;
+				sink->resolution_scaling_config = ref->resolution_scaling_config;
+
 				sink->set_spp(ref->get_spp());
 				sink->format_info = ref->format_info;
 				sink->memory_usage_flags = rsx::surface_usage_flags::storage;
diff --git a/rpcs3/Emu/RSX/VK/VKResourceManager.cpp b/rpcs3/Emu/RSX/VK/VKResourceManager.cpp
index 9d34509a09..82be25194f 100644
--- a/rpcs3/Emu/RSX/VK/VKResourceManager.cpp
+++ b/rpcs3/Emu/RSX/VK/VKResourceManager.cpp
@@ -214,7 +214,7 @@ namespace vk
 			const auto local_memory_usage = vmm_get_application_memory_usage(mem_info.device_local);
 
 			constexpr u64 _1M = 0x100000;
-			const auto res_scale = rsx::get_resolution_scale();
+			const auto res_scale = rsx::get_current_renderer()->resolution_scaling_config.scale_factor();
 			const auto mem_threshold_1 = static_cast<u64>(256 * res_scale * res_scale) * _1M;
 			const auto mem_threshold_2 = static_cast<u64>(64 * res_scale * res_scale) * _1M;
 
diff --git a/rpcs3/Emu/RSX/rsx_utils.h b/rpcs3/Emu/RSX/rsx_utils.h
index 8fec69f88a..310af56dab 100644
--- a/rpcs3/Emu/RSX/rsx_utils.h
+++ b/rpcs3/Emu/RSX/rsx_utils.h
@@ -37,7 +37,38 @@ namespace rsx
 		fatal
 	};
 
-	//Base for resources with reference counting
+	namespace limits
+	{
+		enum
+		{
+			fragment_textures_count = 16,
+			vertex_textures_count = 4,
+			vertex_count = 16,
+			fragment_count = 32,
+			tiles_count = 15,
+			zculls_count = 8,
+			color_buffers_count = 4
+		};
+	}
+
+	namespace constants
+	{
+		constexpr std::array<const char*, 16> fragment_texture_names =
+		{
+			"tex0", "tex1", "tex2", "tex3", "tex4", "tex5", "tex6", "tex7",
+			"tex8", "tex9", "tex10", "tex11", "tex12", "tex13", "tex14", "tex15",
+		};
+
+		constexpr std::array<const char*, 4> vertex_texture_names =
+		{
+			"vtex0", "vtex1", "vtex2", "vtex3",
+		};
+
+		// Local RSX memory base (known as constant)
+		constexpr u32 local_mem_base = 0xC0000000;
+	}
+
+	// Base for resources with reference counting
 	class ref_counted
 	{
 	protected:
@@ -73,37 +104,6 @@ namespace rsx
 		}
 	};
 
-	namespace limits
-	{
-		enum
-		{
-			fragment_textures_count = 16,
-			vertex_textures_count = 4,
-			vertex_count = 16,
-			fragment_count = 32,
-			tiles_count = 15,
-			zculls_count = 8,
-			color_buffers_count = 4
-		};
-	}
-
-	namespace constants
-	{
-		constexpr std::array<const char*, 16> fragment_texture_names =
-		{
-			"tex0", "tex1", "tex2", "tex3", "tex4", "tex5", "tex6", "tex7",
-			"tex8", "tex9", "tex10", "tex11", "tex12", "tex13", "tex14", "tex15",
-		};
-
-		constexpr std::array<const char*, 4> vertex_texture_names =
-		{
-			"vtex0", "vtex1", "vtex2", "vtex3",
-		};
-
-		// Local RSX memory base (known as constant)
-		constexpr u32 local_mem_base = 0xC0000000;
-	}
-
 	/**
 	* Holds information about a framebuffer
 	*/
@@ -214,6 +214,14 @@ namespace rsx
 		bool swizzled;
 	};
 
+	struct surface_scaling_config_t
+	{
+		u16 scale_percent = 100;
+		u16 min_scalable_dimension = 0;
+
+		f32 scale_factor() const { return scale_percent * 0.01f; }
+	};
+
 	template <typename T>
 	void pad_texture(const void* input_pixels, void* output_pixels, u16 input_width, u16 input_height, u16 output_width, u16 /*output_height*/)
 	{
@@ -575,28 +583,23 @@ namespace rsx
 		}
 	}
 
-	static inline f32 get_resolution_scale()
-	{
-		return g_cfg.video.strict_rendering_mode ? 1.f : (g_cfg.video.resolution_scale_percent / 100.f);
-	}
-
-	static inline int get_resolution_scale_percent()
-	{
-		return g_cfg.video.strict_rendering_mode ? 100 : g_cfg.video.resolution_scale_percent;
-	}
-
 	template <bool clamp = false>
-	static inline const std::pair<u16, u16> apply_resolution_scale(u16 width, u16 height, u16 ref_width = 0, u16 ref_height = 0)
+	static inline const std::pair<u16, u16> apply_resolution_scale(
+		const surface_scaling_config_t& config,
+		u16 width,
+		u16 height,
+		u16 ref_width = 0,
+		u16 ref_height = 0)
 	{
 		ref_width = (ref_width) ? ref_width : width;
 		ref_height = (ref_height) ? ref_height : height;
 		const u16 ref = std::max(ref_width, ref_height);
 
-		if (ref > g_cfg.video.min_scalable_dimension)
+		if (ref > config.min_scalable_dimension)
 		{
 			// Upscale both width and height
-			width = (get_resolution_scale_percent() * width) / 100;
-			height = (get_resolution_scale_percent() * height) / 100;
+			width = (config.scale_percent * width) / 100;
+			height = (config.scale_percent * height) / 100;
 
 			if constexpr (clamp)
 			{
@@ -609,11 +612,14 @@ namespace rsx
 	}
 
 	template <bool clamp = false>
-	static inline const std::pair<u16, u16> apply_inverse_resolution_scale(u16 width, u16 height)
+	static inline const std::pair<u16, u16> apply_inverse_resolution_scale(
+		const surface_scaling_config_t& config,
+		u16 width,
+		u16 height)
 	{
 		// Inverse scale
-		auto width_ = (width * 100) / get_resolution_scale_percent();
-		auto height_ = (height * 100) / get_resolution_scale_percent();
+		auto width_ = (width * 100) / config.scale_percent;
+		auto height_ = (height * 100) / config.scale_percent;
 
 		if constexpr (clamp)
 		{
@@ -621,7 +627,7 @@ namespace rsx
 			height_ = std::max<u16>(height_, 1);
 		}
 
-		if (std::max(width_, height_) > g_cfg.video.min_scalable_dimension)
+		if (std::max(width_, height_) > config.min_scalable_dimension)
 		{
 			return { width_, height_ };
 		}
diff --git a/rpcs3/rpcs3qt/gs_frame.cpp b/rpcs3/rpcs3qt/gs_frame.cpp
index 67a750316e..c73db8a687 100644
--- a/rpcs3/rpcs3qt/gs_frame.cpp
+++ b/rpcs3/rpcs3qt/gs_frame.cpp
@@ -15,6 +15,7 @@
 #include "Emu/Cell/Modules/cellScreenshot.h"
 #include "Emu/Cell/Modules/cellAudio.h"
 #include "Emu/Cell/lv2/sys_rsxaudio.h"
+#include "Emu/RSX/RSXThread.h"
 #include "Emu/RSX/rsx_utils.h"
 #include "Emu/RSX/Overlays/overlay_message.h"
 #include "Emu/Io/interception.h"
@@ -1040,7 +1041,7 @@ void gs_frame::take_screenshot(std::vector<u8>&& data, u32 sshot_width, u32 ssho
 
 					if (new_size.width != static_cast<u32>(img.width()) || new_size.height != static_cast<u32>(img.height()))
 					{
-						const int scale = rsx::get_resolution_scale_percent();
+						const int scale = rsx::get_current_renderer()->resolution_scaling_config.scale_percent;
 						const int x = (scale * manager.overlay_offset_x) / 100;
 						const int y = (scale * manager.overlay_offset_y) / 100;
 						const int width = (scale * overlay_img.width()) / 100;

From a863e94c25a9b8419994d37086d9ff680e86400d Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Sat, 13 Dec 2025 17:20:07 +0200
Subject: [PATCH 32/98] SPU: Detect reduced loop

---
 rpcs3/Emu/Cell/SPUAnalyser.h           |    4 +
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 1324 +++++++++++++++++++++++-
 rpcs3/Emu/Cell/SPUOpcodes.h            |   14 +
 rpcs3/Emu/Cell/SPURecompiler.h         |  426 +++++++-
 4 files changed, 1726 insertions(+), 42 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUAnalyser.h b/rpcs3/Emu/Cell/SPUAnalyser.h
index 123a629bed..59560cd182 100644
--- a/rpcs3/Emu/Cell/SPUAnalyser.h
+++ b/rpcs3/Emu/Cell/SPUAnalyser.h
@@ -303,6 +303,8 @@ struct spu_itype
 	}
 };
 
+using spu_itype_t = spu_itype::type;
+
 struct spu_iflag
 {
 	enum
@@ -528,6 +530,8 @@ struct spu_iflag
 	}
 };
 
+using spu_iflag_t = spu_iflag::flag;
+
 #define NAME(x) static constexpr const char& x = *#x
 
 struct spu_iname
diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 1b6003036b..4b52ce8c43 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -52,6 +52,36 @@ struct span_less
 template <typename T>
 inline constexpr span_less<T> s_span_less{};
 
+template <>
+void fmt_class_string<spu_recompiler_base::compare_direction>::format(std::string& out, u64 arg)
+{
+	format_enum(out, arg, [](spu_recompiler_base::compare_direction arg)
+	{
+		switch (arg)
+		{
+		case spu_recompiler_base::CMP_SLESS: return "SLT";
+		case spu_recompiler_base::CMP_SGREATER: return "SGT";
+		case spu_recompiler_base::CMP_EQUAL: return "IEQ";
+		case spu_recompiler_base::CMP_LLESS: return "ULT";
+		case spu_recompiler_base::CMP_LGREATER: return "UGT";
+		case spu_recompiler_base::CMP_SGREATER_EQUAL: return "SGE";
+		case spu_recompiler_base::CMP_SLOWER_EQUAL: return "SLE";
+		case spu_recompiler_base::CMP_NOT_EQUAL: return "INE";
+		case spu_recompiler_base::CMP_LGREATER_EQUAL: return "UGE";
+		case spu_recompiler_base::CMP_LLOWER_EQUAL: return "ULE";
+		case spu_recompiler_base::CMP_UNKNOWN:
+		case spu_recompiler_base::CMP_NOT_EQUAL2:
+		case spu_recompiler_base::CMP_EQUAL2:
+		default:
+		{
+			break;
+		}
+		}
+
+		return unknown;
+	});
+}
+
 // Move 4 args for calling native function from a GHC calling convention function
 #if defined(ARCH_X64)
 static u8* move_args_ghc_to_native(u8* raw)
@@ -3002,7 +3032,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 							is_no_return = is_no_return || (op_next.rb >= 4 && op_next.rb < 10);
 						}
 
-						if (type_next & spu_itype::_quadrop && +iflags & +spu_iflag::use_rc)
+						if (+iflags & +spu_iflag::use_rc)
 						{
 							is_no_return = is_no_return || (op_next.ra >= 4 && op_next.rb < 10);
 						}
@@ -3308,7 +3338,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 							is_no_return = is_no_return || (op_next.rb >= 4 && op_next.rb < 10);
 						}
 
-						if (type_next & spu_itype::_quadrop && +iflags & +spu_iflag::use_rc)
+						if (+iflags & +spu_iflag::use_rc)
 						{
 							is_no_return = is_no_return || (op_next.rc >= 4 && op_next.rc < 10);
 						}
@@ -3834,17 +3864,25 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			continue;
 		}
 
+		bool removed = false;
+
 		for (auto it2 = it->second.begin(); it2 != it->second.end();)
 		{
 			if (*it2 < lsa || *it2 >= limit)
 			{
 				it2 = it->second.erase(it2);
+				removed = true;
 				continue;
 			}
 
 			it2++;
 		}
 
+		if (removed)
+		{
+			it->second.emplace_back(SPU_LS_SIZE);
+		}
+
 		it++;
 	}
 
@@ -4863,19 +4901,24 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		return map;
 	};
 
-	struct putllc16_statistics_t
+	struct stats_t
 	{
 		atomic_t<u64> all = 0;
 		atomic_t<u64> single = 0;
-		atomic_t<u64> nowrite = 0;
 		std::array<atomic_t<u64>, 128> breaking_reason{};
 	};
 
-	struct rchcnt_statistics_t
+	struct putllc16_statistics_t : stats_t
+	{
+		atomic_t<u64> nowrite = 0;
+	};
+
+	struct rchcnt_statistics_t : stats_t
+	{
+	};
+
+	struct reduced_statistics_t : stats_t
 	{
-		atomic_t<u64> all = 0;
-		atomic_t<u64> single = 0;
-		std::array<atomic_t<u64>, 128> breaking_reason{};
 	};
 
 	// Pattern structures
@@ -4987,6 +5030,8 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		// RDCH/RCHCNT Loop analysis tracker
 		rchcnt_loop_t rchcnt_loop{};
 
+		reduced_loop_t reduced_loop{};
+
 		block_reg_state_iterator(u32 _pc, usz _parent_iterator_index = umax, usz _parent_target_index = 0) noexcept
 			: pc(_pc)
 			, parent_iterator_index(_parent_iterator_index)
@@ -4999,6 +5044,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 	std::map<u32, atomic16_t> atomic16_all; // RdAtomicStat location -> atomic loop optimization state
 	std::map<u32, rchcnt_loop_t> rchcnt_loop_all; // RDCH/RCHCNT location -> channel read loop optimization state
+	std::map<u32, reduced_loop_t> reduced_loop_all;
 	std::map<u32, bool> getllar_starts; // True for failed loops
 	std::map<u32, bool> run_on_block;
 	std::map<u32, bool> logged_block;
@@ -5007,6 +5053,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 	atomic16_t dummy16{};
 	rchcnt_loop_t dummy_loop{};
+	reduced_loop_t dummy_rloop{};
 
 	bool likely_putllc_loop = false;
 	bool had_putllc_evaluation = false;
@@ -5053,6 +5100,194 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 	u32 iterator_id_alloc = 0;
 
+	auto get_block_targets = [&](u32 pc) -> std::span<u32>
+	{
+		if (m_block_info[pc / 4] && m_bbs.count(pc))
+		{
+			return ::at32(m_bbs, pc).targets;
+		}
+
+		return {};
+	};
+
+	auto get_block_preds = [&](u32 pc) -> std::span<u32>
+	{
+		if (m_block_info[pc / 4] && m_bbs.count(pc))
+		{
+			return ::at32(m_bbs, pc).preds;
+		}
+
+		return {};
+	};
+
+	const auto initiate_patterns = [&](block_reg_state_iterator& block_state_it, u32 bpc, bool is_multi_block)
+	{
+		// Initiate patterns (that are initiated on block start)
+		const auto& bb_body = ::at32(m_bbs, bpc);
+
+		bool invalid = bb_body.size <= 2;
+		bool valid = true;
+
+		u32 expected_sup_conds = 0;
+		u32 first_pred_of_loop = SPU_LS_SIZE;
+
+		for (u32 pred : get_block_preds(bpc))
+		{
+			if (is_multi_block ? pred >= bpc : pred == bpc)
+			{
+				first_pred_of_loop = std::min<u32>(pred, first_pred_of_loop);
+			}
+		}
+
+		valid = first_pred_of_loop != SPU_LS_SIZE;
+
+		const auto& bb_connect = ::at32(m_bbs, valid ? first_pred_of_loop : bpc);
+
+		invalid = invalid || !valid;
+		valid = false;
+
+		// Check loop connector block (must jump to block-next or to loop-start)
+		u32 targets_count = 0;
+
+		for (u32 target : get_block_targets(first_pred_of_loop))
+		{
+			valid = true;
+			targets_count++;
+
+			if (first_pred_of_loop == bpc)
+			{
+				continue;
+			}
+
+			if (target != bpc)
+			{
+				if (target != first_pred_of_loop + bb_connect.size * 4)
+				{
+					invalid = true;
+				}
+			}
+		}
+
+		if (targets_count > 2)
+		{
+			invalid = true;
+		}
+
+		const bool is_two_block_loop = targets_count == 1;
+ 
+		invalid = invalid || !valid;
+		valid = false;
+
+		// Check loop body block (must jump to last-block or another location)
+
+		for (u32 block_pc = bpc; !invalid;)
+		{
+			targets_count = 0;
+
+			const u32 cond_next = block_pc + ::at32(m_bbs, block_pc).size * 4;
+			valid = false;
+
+			bool is_end = false;
+
+			for (u32 target : get_block_targets(block_pc))
+			{
+				targets_count++;
+
+				if (target == cond_next)
+				{
+					// Conditional branch
+					valid = true;
+				}
+
+				if (target <= block_pc && target > bpc)
+				{
+					// Branch backwards
+					invalid = true;
+				}
+
+				if (target == bpc)
+				{
+					is_end = true;
+				}
+			}
+
+			// if (bpc != block_pc)
+			// {
+			// 	for (u32 pred : get_block_preds(block_pc))
+			// 	{
+			// 		if (pred < bpc || pred > first_pred_of_loop + ::at32(m_bbs, first_pred_of_loop).size * 4)
+			// 		{
+			// 			invalid = true;
+			// 			break;
+			// 		}
+			// 	}
+			// }
+
+			if (targets_count > 2)
+			{
+				invalid = true;
+				break;
+			}
+
+			if (cond_next == first_pred_of_loop && is_two_block_loop)
+			{
+				valid = true;
+				break;
+			}
+
+			if (!valid)
+			{
+				break;
+			}
+
+			if (bpc == first_pred_of_loop || is_end)
+			{
+				break;
+			}
+
+			if (targets_count == 2)
+			{
+				expected_sup_conds++;
+			}
+
+			block_pc = cond_next;
+		}
+
+		invalid = invalid || !valid;
+
+		if (bb_body.size > 2 && !invalid)
+		{
+			// Early filtering of false positives
+			const spu_opcode_t op{std::bit_cast<be_t<u32>>(::at32(result.data, (bpc - entry_point) / 4 + bb_body.size - 2))};
+			const spu_opcode_t op2{std::bit_cast<be_t<u32>>(::at32(result.data, (bpc - entry_point) / 4))};
+
+			switch (g_spu_itype.decode(op.opcode))
+			{
+			case spu_itype::RDCH: invalid = op.ra != SPU_RdDec; break;
+			case spu_itype::RCHCNT: invalid = true; break;
+			default: break;
+			}
+
+			switch (g_spu_itype.decode(op2.opcode))
+			{
+			case spu_itype::RDCH: invalid = invalid || op2.ra != SPU_RdDec; break;
+			case spu_itype::RCHCNT: invalid = true; break;
+			default: break;
+			}
+		}
+
+		if (valid && !invalid && !reduced_loop_all.count(bpc) && expected_sup_conds  == 0)
+		{
+			const auto reduced_loop = &block_state_it.reduced_loop;
+			reduced_loop->discard();
+			reduced_loop->active = true;
+			reduced_loop->loop_pc = bpc;
+			reduced_loop->loop_end = first_pred_of_loop;
+			reduced_loop->expected_sup_conds = expected_sup_conds;
+			reduced_loop->is_two_block_loop = is_two_block_loop;
+		}
+	};
+
 	for (u32 wf = 0, wi = 0, wa = entry_point, bpc = wa; wf <= 1;)
 	{
 		const bool is_form_block = wf == 0;
@@ -5121,6 +5356,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		auto& vregs = is_form_block ? infos[bpc]->local_state : *true_state_walkby;
 		const auto atomic16 = is_pattern_match ? &::at32(reg_state_it, wi).atomic16 : &dummy16;
 		const auto rchcnt_loop = is_pattern_match ? &::at32(reg_state_it, wi).rchcnt_loop : &dummy_loop;
+		const auto reduced_loop = &::at32(reg_state_it, wi).reduced_loop;
 
 		const u32 pos = wa;
 
@@ -5244,10 +5480,71 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			}
 		};
 
+		const auto break_reduced_loop_pattern = [&](u32 cause, reduced_loop_t previous)
+		{
+			if (previous.active && previous.loop_pc != SPU_LS_SIZE && reduced_loop_all.count(previous.loop_pc) == 0)
+			{
+				g_fxo->get<reduced_statistics_t>().breaking_reason[cause]++;
+
+				if (!spu_log.notice)
+				{
+					return;
+				}
+
+				previous.active = false;
+				previous.failed = true;
+
+				reduced_loop_all[previous.loop_pc] = previous;
+
+				std::string break_error = fmt::format("Reduced loop pattern breakage [%x cause=%u] (read_pc=0x%x)", pos, cause, previous.loop_pc);
+
+				const auto values = sort_breakig_reasons(g_fxo->get<reduced_statistics_t>().breaking_reason);
+
+				std::string tracing = "Top Breaking Reasons:";
+
+				usz i = 0;
+				usz fail_count = 0;
+				bool switched_to_minimal = false;
+
+				for (auto it = values.begin(); it != values.end(); i++, it++)
+				{
+					fail_count += it->second;
+
+					if (i >= 12)
+					{
+						continue;
+					}
+
+					if (i < 8 && it->second > 1)
+					{
+						fmt::append(tracing, " [cause=%u, n=%d]", it->first, it->second);
+					}
+					else
+					{
+						if (!std::exchange(switched_to_minimal, true))
+						{
+							fmt::append(tracing, "; More:");
+						}
+
+						fmt::append(tracing, " %u", it->first);
+					}
+				}
+
+				fmt::append(tracing, " of %d failures", fail_count);
+				spu_log.notice("%s\n%s", break_error, tracing);
+
+				std::string block_dump;
+				this->dump(result, block_dump, previous.loop_pc, previous.loop_end + 1);
+	
+				spu_log.notice("SPU Block Dump:\n%s", block_dump);
+			}
+		};
+
 		const auto break_all_patterns = [&](u32 cause)
 		{
 			break_putllc16(cause, atomic16->discard());
 			break_channel_pattern(cause, rchcnt_loop->discard());
+			break_reduced_loop_pattern(cause, reduced_loop->discard());
 		};
 
 		const auto calculate_absolute_ls_difference = [](u32 addr1, u32 addr2)
@@ -5309,16 +5606,6 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				u32 stackframe_pc = SPU_LS_SIZE;
 				usz entry_index = umax;
 
-				auto get_block_targets = [&](u32 pc) -> std::span<u32>
-				{
-					if (m_block_info[pc / 4] && m_bbs.count(pc))
-					{
-						return m_bbs.at(pc).targets;
-					}
-
-					return {};
-				};
-
 				u32 target_pc = SPU_LS_SIZE;
 				bool insert_entry = false;
 				bool is_code_backdoor = false;
@@ -5508,7 +5795,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					}
 				}
 
-				const u32 previous_pc = m_bbs.at(reg_state_it[stackframe_it].pc).size * 4 + reg_state_it[stackframe_it].pc - 4;
+				const u32 previous_pc = ::at32(m_bbs, reg_state_it[stackframe_it].pc).size * 4 + reg_state_it[stackframe_it].pc - 4;
 
 				bool may_return = previous_pc + 4 != entry_point + result.data.size() * 4 && (m_ret_info[(previous_pc / 4) + 1] || m_entry_info[previous_pc / 4]);
 
@@ -5537,6 +5824,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				// Backup analyser information
 				const auto atomic16_info = reg_state_it[stackframe_it].atomic16;
 				const auto rchcnt_loop_info = reg_state_it[stackframe_it].rchcnt_loop;
+				const auto reduced_loop_info = reg_state_it[stackframe_it].reduced_loop;
 
 				// Clean from the back possible because it does not affect old indices
 				// Technically should always do a full cleanup at the moment
@@ -5562,6 +5850,8 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					spu_log.trace("Emplacing: block_id=%d, pc=0x%x, target_it=%d/%d, new_pc=0x%x (has_it=%d)", reg_state_it[stackframe_it].iterator_id, stackframe_pc, entry_index + 1, target_size, target_pc, atomic16_info.active);
 					auto& next = reg_state_it.emplace_back(target_pc, stackframe_it, 0);
 
+					initiate_patterns(next, target_pc, true);
+
 					if (!is_code_backdoor)
 					{
 						// Restore analyser information (if not an entry)
@@ -5569,6 +5859,9 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 						if (previous_pc != rchcnt_loop_info.branch_pc || target_pc == rchcnt_loop_info.branch_target)
 							next.rchcnt_loop = rchcnt_loop_info;
+
+						if (previous_pc + 4 == target_pc && reduced_loop_info.loop_pc != reduced_loop_info.loop_end && reduced_loop_info.active && target_pc <= reduced_loop_info.loop_end)
+							next.reduced_loop = reduced_loop_info;
 					}
 					else
 					{
@@ -5604,15 +5897,30 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 					if (!infos.empty())
 					{
-						reg_state_it.emplace_back(::at32(infos, entry_point)->pc).iterator_id = iterator_id_alloc++;;
+						reg_state_it.emplace_back(::at32(infos, entry_point)->pc).iterator_id = iterator_id_alloc++;
+
+						initiate_patterns(reg_state_it.back(), ::at32(infos, entry_point)->pc, true);
 					}
 				}
 			}
 
+			const auto prev_wi = wi - 1;
+			if (prev_wi != umax && ::at32(reg_state_it, prev_wi).reduced_loop.active)
+			{
+				const auto reduced_loop = &::at32(reg_state_it, prev_wi).reduced_loop;
+
+				for (const auto& [reg_num, reg] : reduced_loop->regs)
+				{
+					
+				}
+			}
+
 			if (wi < reg_state_it.size())
 			{
 				wa = ::at32(reg_state_it, wi).pc;
 				bpc = wa;
+
+				initiate_patterns(::at32(reg_state_it, wi), bpc, false);
 			}
 		};
 
@@ -5737,7 +6045,8 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			if (!is_form_block)
 			{
 				// Call for external code
-				break_all_patterns(25);
+				break_putllc16(25, atomic16->discard());
+				break_channel_pattern(25, rchcnt_loop->discard());
 			}
 		}
 
@@ -5762,6 +6071,143 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		const auto op = spu_opcode_t{data};
 		const auto type = g_spu_itype.decode(data);
 
+		if (reduced_loop->active && !(type & spu_itype::zregmod))
+		{
+			const u32 op_rt = type & spu_itype::_quadrop ? +op.rt4 : +op.rt;
+
+			u32 ra = s_reg_max, rb = s_reg_max, rc = s_reg_max;
+
+			if (m_use_ra.test(pos / 4))
+			{
+				ra = op.ra;
+			}
+
+			if (m_use_rb.test(pos / 4))
+			{
+				rb = op.rb;
+			}
+
+			if (m_use_rc.test(pos / 4))
+			{
+				rc = op.rc;
+			}
+
+			bool is_move_register_op = false;
+
+			switch (type)
+			{
+			case spu_itype::SHLQBYI:
+			{
+				is_move_register_op = op.i7 == 0;
+				break;
+			}
+			// Technically only ORI is needed but I am taking into account possible third-party SPU compilers or hand-written assembly
+			case spu_itype::ORI:
+			case spu_itype::ORHI:
+			case spu_itype::ORBI:
+			case spu_itype::AI:
+			case spu_itype::AHI:
+			case spu_itype::XORI:
+			case spu_itype::XORHI:
+			case spu_itype::XORBI:
+			{
+				is_move_register_op = op.si10 == 0;
+				break;
+			}
+			case spu_itype::ANDI:
+			case spu_itype::ANDHI:
+			case spu_itype::ANDBI:
+			{
+				is_move_register_op = op.si10 == -1;
+				break;
+			}
+			default:
+			{
+				break;
+			}
+			}
+
+			u32 reg_pos = SPU_LS_SIZE;
+
+			auto org = reduced_loop->get_reg(op_rt);
+
+			u32 reg_first = s_reg_max;
+
+			for (u32 reg : {ra, rb, rc})
+			{
+				if (reg != s_reg_max && reg != reg_first)
+				{
+					const auto arg = reduced_loop->find_reg(reg);
+
+					if (arg && arg->modified >= 1)
+					{
+						reg_first = reg;
+
+						if (reg_first != s_reg_max && !is_move_register_op)
+						{
+							// Multiple origins
+							org.add_instruction_modifier(spu_itype::UNK, op.opcode);
+							break;
+						}
+					}
+				}
+			}
+
+			if (reg_first == s_reg_max)
+			{
+				org = {};
+
+				if (!is_move_register_op)
+				{
+					org.add_instruction_modifier(type, op.opcode);
+				}
+			}
+			else if (reg_first == rb)
+			{
+				std::swap(ra, rb);
+			}
+			else if (reg_first == rc)
+			{
+				std::swap(ra, rc);
+			}
+							
+			for (u32 reg : {ra, rb, rc})
+			{
+				if (reg != s_reg_max)
+				{
+					const auto arg = reduced_loop->find_reg(reg);
+
+					if (arg && reg != op_rt)
+					{
+						if (reg_first == reg)
+						{
+							org = *arg;
+
+							if (!is_move_register_op)
+							{
+								org.add_instruction_modifier(type, op.opcode);
+							}
+
+							continue;
+						}
+
+						org.join_with_this(*arg);
+					}
+					else
+					{
+						org.add_register_origin(reg);
+					}
+				}
+			}
+
+			*ensure(reduced_loop->find_reg(op_rt)) = org;
+		}
+
+		if (reduced_loop->active && ((type & spu_itype::memory) || type == spu_itype::STOP || type == spu_itype::STOPD))
+		{
+			reduced_loop->is_constant_expression = false;
+		}
+
 		// For debugging
 		if (false && likely_putllc_loop && is_pattern_match)
 		{
@@ -5848,12 +6294,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				break;
 			}
 
-			if (type == spu_itype::SYNC)
-			{
-				// Remember
-				sync = true;
-			}
-
+			break_reduced_loop_pattern(19, reduced_loop->discard());
 			break;
 		}
 
@@ -5880,8 +6321,57 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			break;
 		}
 
+		case spu_itype::BR:
 		case spu_itype::BRA:
 		{
+			if (reduced_loop->active)
+			{
+				if (!reduced_loop->is_two_block_loop || !reduced_loop->has_cond_state)
+				{
+					break_reduced_loop_pattern(20, reduced_loop->discard());
+					break;
+				}
+
+				for (const auto& [reg_num, reg] : reduced_loop->regs)
+				{
+					if (reg.is_loop_dictator(reg_num))
+					{
+						if (reg.is_non_predictable_loop_dictator(reg_num))
+						{
+							//break_reduced_loop_pattern(13, reduced_loop->discard());
+							reduced_loop->is_constant_expression = false;
+						}
+
+						reduced_loop->loop_dicts.set(reg_num);
+					}
+				}
+
+				for (u32 i = 0; i < s_reg_max; i++)
+				{
+					const auto& b = ::at32(m_bbs, reduced_loop->loop_pc); 
+					const auto& b2 = ::at32(m_bbs, bpc); 
+
+					if (!reduced_loop->loop_dicts.test(i))
+					{
+						if (b.reg_use.test(i) || (!b.reg_mod.test(i) && b2.reg_use.test(i)))
+						{
+							if ((b.reg_use.test(i) && b.reg_mod.test(i)) || b2.reg_mod.test(i))
+							{
+								reduced_loop->is_constant_expression = false;
+								reduced_loop->loop_writes.set(i);
+							}
+							else
+							{
+								reduced_loop->loop_args.set(i);
+							}
+						}
+					}
+				}
+
+				reduced_loop_all.emplace(reduced_loop->loop_pc, *reduced_loop);
+				reduced_loop->discard();
+			}
+
 			break;
 		}
 
@@ -5891,7 +6381,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			const u32 next_pc = spu_branch_target(pos, 1);
 			const u32 target = spu_branch_target(pos, op.i16);
 
-			if (rchcnt_loop->active)
+			while (rchcnt_loop->active)
 			{
 				const reg_state_t& rt = vregs[op.rt];
 
@@ -5907,16 +6397,663 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					rchcnt_loop->conditioned = true;
 					rchcnt_loop->branch_pc = pos;
 					rchcnt_loop->branch_target = rchcnt_loop->product_test_negate != (type == spu_itype::BRZ) ? target : next_pc;
-					break;
 				}
+
+				break;
 			}
 
-			break;
+			[[fallthrough]];
 		}
-		case spu_itype::BR:
 		case spu_itype::BRHZ:
 		case spu_itype::BRHNZ:
 		{
+			const u32 next_pc = spu_branch_target(pos, 1);
+			const u32 target = spu_branch_target(pos, op.i16);
+
+			const bool is_u16_jump = type == spu_itype::BRHZ || type == spu_itype::BRHNZ;
+			const bool is_jump_zero = (type == spu_itype::BRZ || type == spu_itype::BRHZ) ^ reduced_loop->is_two_block_loop;
+
+			while (reduced_loop->active)
+			{
+				if (reduced_loop->expected_sup_conds)
+				{
+					break_reduced_loop_pattern(50, reduced_loop->discard());
+					break;
+				}
+
+				const u32 op_rt = op.rt;
+
+				const auto reg = reduced_loop->find_reg(op_rt);
+
+				if (!reg/* || reg->modified == 0*/) // See special case regarding branch with direct comparison with 0
+				{
+					break_reduced_loop_pattern(1, reduced_loop->discard());
+					break;
+				}
+
+				bool should_have_argument_dictator = false;
+				bool should_have_argument_increment = false;
+				bool cond_val_incr_before_cond = false;
+				bool ends_with_comparison = false;
+
+				bool pattern_ok1 = true;
+
+				switch (reg->mod1_type)
+				{
+				case spu_itype::A:
+				{
+					should_have_argument_increment = true;
+					[[fallthrough]];
+				}
+				case spu_itype::AI:
+				case spu_itype::AHI:
+				{
+					cond_val_incr_before_cond = true;
+					pattern_ok1 = true;
+					break;
+				}
+				case spu_itype::CEQ:
+				case spu_itype::CEQH:
+				case spu_itype::CEQB:
+				case spu_itype::CGT:
+				case spu_itype::CGTH:
+				case spu_itype::CGTB:
+				case spu_itype::CLGT:
+				case spu_itype::CLGTH:
+				case spu_itype::CLGTB:
+				{
+					ends_with_comparison = true;
+					should_have_argument_dictator = true;
+					break;
+				}
+				case spu_itype::CEQI:
+				case spu_itype::CEQHI:
+				case spu_itype::CEQBI:
+				case spu_itype::CGTI:
+				case spu_itype::CGTHI:
+				case spu_itype::CGTBI:
+				case spu_itype::CLGTI:
+				case spu_itype::CLGTHI:
+				case spu_itype::CLGTBI:
+				{
+					ends_with_comparison = true;
+					pattern_ok1 = true;
+					break;
+				}
+				default:
+				{
+					if (reg->modified == 0)
+					{
+						// Special case: target may be sourced from another register which would be the loop dictator
+						break;
+					}
+
+					pattern_ok1 = false;
+					break;
+				}	
+				}
+	
+				if (!pattern_ok1)
+				{
+					break_reduced_loop_pattern(9, reduced_loop->discard());
+					break;
+				}
+	
+				if (reg->modified >= 2)
+				{
+					switch (reg->mod2_type)
+					{
+					case spu_itype::A:
+					{
+						should_have_argument_increment = true;
+						[[fallthrough]];
+					}
+					case spu_itype::AI:
+					case spu_itype::AHI:
+					{
+						if (cond_val_incr_before_cond)
+						{
+							// AI twice
+							break_reduced_loop_pattern(8, reduced_loop->discard());
+							pattern_ok1 = false;
+							break;
+						}
+
+						cond_val_incr_before_cond = false;
+						pattern_ok1 = true;
+						break;
+					}
+					case spu_itype::CEQ:
+					case spu_itype::CEQH:
+					case spu_itype::CEQB:
+					case spu_itype::CGT:
+					case spu_itype::CGTH:
+					case spu_itype::CGTB:
+					case spu_itype::CLGT:
+					case spu_itype::CLGTH:
+					case spu_itype::CLGTB:
+					{
+						if (!cond_val_incr_before_cond)
+						{
+							// Double comparison
+							break_reduced_loop_pattern(19, reduced_loop->discard());
+							pattern_ok1 = false;
+							break;
+						}
+
+						pattern_ok1 = true;
+						ends_with_comparison = true;
+						should_have_argument_dictator = true;
+						break;
+					}
+					case spu_itype::CEQI:
+					case spu_itype::CEQHI:
+					case spu_itype::CEQBI:
+					case spu_itype::CGTI:
+					case spu_itype::CGTHI:
+					case spu_itype::CGTBI:
+					case spu_itype::CLGTI:
+					case spu_itype::CLGTHI:
+					case spu_itype::CLGTBI:
+					{
+						if (!cond_val_incr_before_cond)
+						{
+							// Double comparison
+							break_reduced_loop_pattern(19, reduced_loop->discard());
+							pattern_ok1 = false;
+							break;
+						}
+
+						ends_with_comparison = true;
+						pattern_ok1 = true;
+						break;
+					}
+					default:
+					{
+						pattern_ok1 = false;
+						break;
+					}	
+					}
+				}
+
+				if (!pattern_ok1)
+				{
+					break_reduced_loop_pattern(10, reduced_loop->discard());
+					break;
+				}
+
+				bool found_loop_dictator = false;
+				bool found_loop_argument_for_dictator = false;
+				u32 null_regs_found = 0;
+
+				for (u32 i = 0; i < reg->regs.size() && reduced_loop->active; i++)
+				{
+					if (reg->regs.test(i))
+					{
+						if (0) if (i == op_rt || reg->modified == 0)
+						{
+							// Special case: direct comparison with zero for 32-bits (the only supported form by SPU)
+
+							if (is_jump_zero)
+							{
+								// Infinite or single-time "loop"
+								break_reduced_loop_pattern(3, reduced_loop->discard());
+								break;
+							}
+
+							if (reg->modified >= 2)
+							{
+								break_reduced_loop_pattern(22, reduced_loop->discard());
+								break;
+							}
+
+							reduced_loop->cond_val_mask = u32{umax};
+							reduced_loop->cond_val_min = 0;
+							reduced_loop->cond_val_size = u32{umax};
+
+							auto comp_reg = i == op_rt ? reg : reduced_loop->find_reg(i);
+
+							if (!comp_reg || !comp_reg->is_predictable_loop_dictator(i))
+							{
+								break_reduced_loop_pattern(4, reduced_loop->discard());
+								break;
+							}
+
+							ensure(reg->modified == 1 || i != op_rt);
+
+							reduced_loop->cond_val_incr = static_cast<s32>(comp_reg->IMM);
+							reduced_loop->cond_val_incr_before_cond = reg->modified == 1;
+							reduced_loop->cond_val_register_idx = i;
+							reduced_loop->cond_val_compare = CMP_NOT_EQUAL;
+							reduced_loop->cond_val_is_immediate = true;
+
+							found_loop_dictator = true;
+							break;
+						}
+
+						auto reg_org = reduced_loop->find_reg(i);
+						u32 reg_index = i;
+
+						if (reg_org && !cond_val_incr_before_cond && reg_org->modified == 0 && reg_org->regs.count() - 1u <= 1u && !reg_org->regs.test(i))
+						{
+							for (u32 j = 0; j <= s_reg_127; j++)
+							{
+								if (reg_org->regs.test(j))
+								{
+									if (const auto reg_found = reduced_loop->find_reg(j))
+									{
+										if (reg_found->modified)
+										{
+											reg_org = reg_found;
+											reg_index = j;
+											break;
+										}
+									}
+								}
+							}
+						}
+
+						if (!reg_org || reg_org->is_null(reg_index))
+						{
+							// if (found_loop_dictator && !reduced_loop->cond_val_incr_is_immediate)
+							// {
+							// 	ensure(reduced_loop->cond_val_incr < s_reg_max);
+
+							// }
+							// if (!should_have_argument_dictator)
+							// {
+							// 	break_reduced_loop_pattern(11, reduced_loop->discard());
+							// 	break;
+							// }
+
+							// if (found_loop_argument_for_dictator)
+							// {
+							// 	break_reduced_loop_pattern(6, reduced_loop->discard());
+							// 	break;
+							// }
+
+							// found_loop_argument_for_dictator = true;
+							// reduced_loop->cond_val_is_immediate = false;
+
+							// if (found_loop_dictator)
+							// {
+							// 	ensure(i == reduced_loop->cond_val_register_argument_idx);
+							// }
+							// else
+							// {
+							// 	reduced_loop->cond_val_register_argument_idx = i;
+							// }
+
+							// if (found_loop_dictator && reg->regs.count() == 2)
+							// {
+							// 	break;
+							// }
+
+							null_regs_found++;
+							continue;
+						}
+
+						if (found_loop_dictator)
+						{
+							break_reduced_loop_pattern(13, reduced_loop->discard());
+							break;
+						}
+
+						found_loop_dictator = true;
+
+						if (!reg_org->is_predictable_loop_dictator(i))
+						{
+							break_reduced_loop_pattern(7, reduced_loop->discard());
+							break;
+						}
+
+						u32 cond_val_incr = static_cast<s32>(reg_org->IMM);
+
+						if (reg_org->mod1_type == spu_itype::AI || reg_org->mod1_type == spu_itype::AHI)
+						{
+							reduced_loop->cond_val_incr_is_immediate = true;
+							reduced_loop->cond_val_incr = static_cast<s32>(reg_org->IMM);
+						}
+						else if (reg_org->mod1_type == spu_itype::A)
+						{
+							reduced_loop->cond_val_incr_is_immediate = false;
+
+							const u32 op_ra = spu_opcode_t{reg->IMM}.ra;
+							const u32 op_rb = spu_opcode_t{reg->IMM}.rb;
+
+							if (!(op_ra == reg_index || op_rb == reg_index))
+							{
+								break_reduced_loop_pattern(25, reduced_loop->discard());
+								break;
+							}
+
+							const u32 incr_arg_reg = reg_index == op_ra ? op_rb : op_ra;
+
+							if (!reduced_loop->is_reg_null(incr_arg_reg))
+							{
+								break_reduced_loop_pattern(26, reduced_loop->discard());
+								break;
+							}
+
+							reduced_loop->cond_val_incr = incr_arg_reg;
+						}
+						else
+						{
+							break_reduced_loop_pattern(28, reduced_loop->discard());
+							break;
+						}
+
+						reduced_loop->cond_val_incr_before_cond = cond_val_incr_before_cond; 
+
+						u64 cmp_mask = 0;
+						compare_direction cmp_direction{};
+
+						if (!ends_with_comparison)
+						{
+							if (is_jump_zero)
+							{
+								// Infinite or single-time "loop"
+								break_reduced_loop_pattern(3, reduced_loop->discard());
+								break;
+							}
+
+							cmp_mask = is_u16_jump ? u16{umax} : u32{umax};
+							reduced_loop->cond_val_min = 0;
+							reduced_loop->cond_val_is_immediate = true;
+							cmp_direction = CMP_NOT_EQUAL;
+						}
+						else if (!should_have_argument_dictator)
+						{
+							reduced_loop->cond_val_min = reg->IMM;
+							reduced_loop->cond_val_is_immediate = true;
+
+							const auto cmp_optype = reg->reverse1_type() == spu_itype::XSBH ? reg->reverse2_type() : reg->reverse1_type();
+
+							switch (cmp_optype)
+							{
+							case spu_itype::CEQI:
+							case spu_itype::CEQHI:
+							case spu_itype::CEQBI:
+							{
+								cmp_direction = CMP_EQUAL;
+								break;
+							}
+							case spu_itype::CGTI:
+							case spu_itype::CGTHI:
+							case spu_itype::CGTBI:
+							{
+								cmp_direction = CMP_SGREATER;
+								break;
+							}
+							case spu_itype::CLGTI:
+							case spu_itype::CLGTHI:
+							case spu_itype::CLGTBI:
+							{
+								cmp_direction = CMP_LGREATER;
+								break;
+							}
+							default:
+							{
+								break_reduced_loop_pattern(21, reduced_loop->discard());
+							}
+							}
+
+							switch (cmp_optype)
+							{
+							case spu_itype::CEQI:
+							case spu_itype::CGTI:
+							case spu_itype::CLGTI:
+							{
+								cmp_mask = u32{umax};
+								break;
+							}
+							case spu_itype::CLGTHI:
+							case spu_itype::CEQHI:
+							case spu_itype::CGTHI:
+							{
+								cmp_mask = u16{umax};
+								break;
+							}
+							case spu_itype::CEQBI:
+							case spu_itype::CGTBI:
+							case spu_itype::CLGTBI:
+							{
+								cmp_mask = u8{umax};
+								break;
+							}
+							default: break_reduced_loop_pattern(21, reduced_loop->discard());
+							}
+
+							if (is_jump_zero)
+							{
+								cmp_direction = compare_direction{cmp_direction ^ CMP_NEGATE_FLAG};
+							}
+
+							if (cmp_direction == CMP_EQUAL2 || cmp_direction == CMP_NOT_EQUAL2)
+							{
+								// Fixup (no sense in remembering the turnaround for euqality comparison)
+								cmp_direction = compare_direction{cmp_direction & ~CMP_TURNAROUND_FLAG};
+							}
+						}
+						else
+						{
+							const u32 op_ra = spu_opcode_t{reg->IMM}.ra;
+							const u32 op_rb = spu_opcode_t{reg->IMM}.rb;
+
+							if (!(op_ra == reg_index || op_rb == reg_index))
+							{
+								break_reduced_loop_pattern(20, reduced_loop->discard());
+								break;
+							}
+
+							const auto cmp_optype = reg->reverse1_type() == spu_itype::XSBH ? reg->reverse2_type() : reg->reverse1_type();
+							
+							switch (cmp_optype)
+							{
+							case spu_itype::CEQ:
+							case spu_itype::CEQH:
+							case spu_itype::CEQB:
+							{
+								cmp_direction = CMP_EQUAL;
+								break;
+							}
+							case spu_itype::CGT:
+							case spu_itype::CGTH:
+							case spu_itype::CGTB:
+							{
+								cmp_direction = CMP_SGREATER;
+								break;
+							}
+							case spu_itype::CLGT:
+							case spu_itype::CLGTH:
+							case spu_itype::CLGTB:
+							{
+								cmp_direction = CMP_LGREATER;
+								break;
+							}
+							default: ensure(false);
+							}
+
+							switch (cmp_optype)
+							{
+							case spu_itype::CEQ:
+							case spu_itype::CGT:
+							case spu_itype::CLGT:
+							{
+								cmp_mask = u32{umax};
+								break;
+							}
+							case spu_itype::CLGTH:
+							case spu_itype::CEQH:
+							case spu_itype::CGTH:
+							{
+								cmp_mask = u16{umax};
+								break;
+							}
+							case spu_itype::CEQB:
+							case spu_itype::CGTB:
+							case spu_itype::CLGTB:
+							{
+								cmp_mask = u8{umax};
+								break;
+							}
+							default: ensure(false);
+							}
+
+							if (op_ra != i)
+							{
+								// Compare is on the oppsoite direction
+								// This variation exists only via register mode (due to lack of SPU opcodes)
+								cmp_direction = compare_direction{cmp_direction ^ CMP_TURNAROUND_FLAG};
+							}
+
+							if (is_jump_zero)
+							{
+								cmp_direction = compare_direction{cmp_direction ^ CMP_NEGATE_FLAG};
+							}
+
+							if (cmp_direction == CMP_EQUAL2 || cmp_direction == CMP_NOT_EQUAL2)
+							{
+								// Fixup (no sense in remembering the turnaround for euqality comparison)
+								cmp_direction = compare_direction{cmp_direction & ~CMP_TURNAROUND_FLAG};
+							}
+
+							// The loop dictator is the register that is not the argument
+							const u32 loop_arg_reg = reg_index == op_ra ? op_rb : op_ra;
+							const u32 loop_dict_reg = reg_index == op_ra ? op_ra : op_rb;
+							reduced_loop->cond_val_is_immediate = false;
+
+							if (found_loop_argument_for_dictator)
+							{
+								ensure(loop_arg_reg == reduced_loop->cond_val_register_argument_idx);
+							}
+							else
+							{
+								reduced_loop->cond_val_register_argument_idx = loop_arg_reg;
+							}
+
+							if (!reduced_loop->is_reg_null(loop_arg_reg))
+							{
+								break_reduced_loop_pattern(27, reduced_loop->discard());
+								break;
+							}
+
+							found_loop_argument_for_dictator = true;
+						}
+
+						if (cmp_direction == CMP_EQUAL)
+						{
+							// Infinite or single-time "loop"
+							break_reduced_loop_pattern(18, reduced_loop->discard());
+							break;
+						}
+
+						if (cmp_mask == u16{umax} && !is_u16_jump)
+						{
+							break_reduced_loop_pattern(14, reduced_loop->discard());
+							break;
+						}
+
+						if (cmp_mask == u8{umax})
+						{
+							bool instructions_ok = false;
+
+							if (is_u16_jump)
+							{
+								// If ANDI(0xff) is used, although unlikely, it fine as well for 16-bits
+								instructions_ok = FN(x == spu_itype::XSBH || x == spu_itype::ANDI)(!cond_val_incr_before_cond ? reg->mod2_type : reg->mod3_type);
+							}
+							else
+							{
+								instructions_ok = FN(x == spu_itype::ANDI)(!cond_val_incr_before_cond ? reg->mod2_type : reg->mod3_type);
+							}
+
+							if (!instructions_ok)
+							{
+								break_reduced_loop_pattern(15, reduced_loop->discard());
+								break;
+							}
+						}
+
+						reduced_loop->cond_val_compare = cmp_direction;
+						reduced_loop->cond_val_mask = cmp_mask;
+						reduced_loop->cond_val_register_idx = reg_index;
+
+						// if (!should_have_argument_dictator && reg->regs.count() == 1)
+						// {
+						// 	break;
+						// }
+
+						// if (found_loop_argument_for_dictator && reg->regs.count() == 2)
+						// {
+						// 	break;
+						// }
+					}
+				}
+
+				if (!found_loop_dictator)
+				{
+					break_reduced_loop_pattern(16, reduced_loop->discard());
+				}
+
+				if (should_have_argument_dictator && !found_loop_argument_for_dictator)
+				{
+					break_reduced_loop_pattern(17, reduced_loop->discard());
+				}
+
+				if (reduced_loop->active)
+				{
+					ensure(reduced_loop->cond_val_register_idx != umax);
+
+					if (reduced_loop->is_two_block_loop)
+					{
+						reduced_loop->has_cond_state = true;
+						break;
+					}
+
+					for (const auto& [reg_num, reg] : reduced_loop->regs)
+					{
+						if (reg.is_loop_dictator(reg_num))
+						{
+							if (reg.is_non_predictable_loop_dictator(reg_num))
+							{
+								//break_reduced_loop_pattern(13, reduced_loop->discard());
+								reduced_loop->is_constant_expression = false;
+							}
+
+							reduced_loop->loop_dicts.set(reg_num);
+						}
+					}
+
+					for (u32 i = 0; i < s_reg_max; i++)
+					{
+						const auto& b = ::at32(m_bbs, reduced_loop->loop_pc); 
+						const auto& b2 = ::at32(m_bbs, bpc); 
+
+						if (!reduced_loop->loop_dicts.test(i))
+						{
+							if (b.reg_use.test(i) || (!b.reg_mod.test(i) && b2.reg_use.test(i)))
+							{
+								if ((b.reg_use.test(i) && b.reg_mod.test(i)) || b2.reg_mod.test(i))
+								{
+									reduced_loop->is_constant_expression = false;
+									reduced_loop->loop_writes.set(i);
+								}
+								else
+								{
+									reduced_loop->loop_args.set(i);
+								}
+							}
+						}
+					}
+
+					reduced_loop_all.emplace(reduced_loop->loop_pc, *reduced_loop);
+					reduced_loop->discard();
+				}
+
+				break;
+			}
+
 			break;
 		}
 
@@ -5929,17 +7066,49 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		case spu_itype::HLGTI:
 		case spu_itype::LNOP:
 		case spu_itype::NOP:
-		case spu_itype::MTSPR:
 		case spu_itype::FSCRWR:
 		{
 			// Do nothing
 			break;
 		}
-
+		
+		case spu_itype::MTSPR:
+		{
+			break_all_patterns(99);
+			break;
+		}
+	
 		case spu_itype::WRCH:
 		{
 			break_channel_pattern(56, rchcnt_loop->discard());
 
+			if (reduced_loop->active)
+			{
+				switch (op.ra)
+				{
+				case MFC_EAL:
+				case MFC_LSA:
+				case MFC_TagID:
+				case MFC_Size:
+				case MFC_EAH:
+				case SPU_WrDec:
+				case SPU_WrSRR0:
+				case SPU_WrEventAck:
+				case SPU_Set_Bkmk_Tag:
+				case SPU_PM_Start_Ev:
+				case SPU_PM_Stop_Ev:
+				case MFC_WrTagMask:
+				{
+					break;
+				}
+				default:
+				{
+					break_reduced_loop_pattern(18, reduced_loop->discard());
+					break;
+				}
+				}
+			}
+
 			switch (op.ra)
 			{
 			case MFC_EAL:
@@ -6202,6 +7371,14 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			const bool is_read = type == spu_itype::RDCH;
 			bool invalidate = true;
 
+			if (!is_read || op.ra != SPU_RdDec)
+			{
+				if (reduced_loop->active)
+				{
+					break_reduced_loop_pattern(17, reduced_loop->discard());
+				}
+			}
+
 			const auto it = rchcnt_loop_all.find(pos);
 
 			if (it != rchcnt_loop_all.end())
@@ -7121,7 +8298,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					rb = op.rb;
 				}
 
-				if (type & spu_itype::_quadrop && m_use_rc.test(pos / 4))
+				if (m_use_rc.test(pos / 4))
 				{
 					rc = op.rc;
 				}
@@ -7169,6 +8346,11 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		{
 			for (u32 next_target : ::at32(m_targets, pos))
 			{
+				if (next_target == SPU_LS_SIZE)
+				{
+					continue;
+				}
+
 				add_block(next_target);
 			}
 
@@ -7353,6 +8535,64 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		}
 	}
 
+	for (const auto& [loop_pc, pattern] : reduced_loop_all)
+	{
+		if (!pattern.active || pattern.loop_pc == SPU_LS_SIZE)
+		{
+			continue;
+		}
+
+		if (inst_attr attr = m_inst_attrs[(loop_pc - entry_point) / 4]; attr == inst_attr::none)
+		{
+			add_pattern(inst_attr::reduced_loop, loop_pc - result.entry_point, 0, std::make_shared<reduced_loop_t>(pattern));
+
+			std::string regs = "{";
+
+			for (const auto& [reg_num, reg] : pattern.regs)
+			{
+				if (reg.is_loop_dictator(reg_num))
+				{
+					if (regs.size() != 1)
+					{
+						regs += ",";
+					}
+
+					fmt::append(regs, " r%u", reg_num);
+				}
+			}
+
+			for (u32 i = 0; i < s_reg_max; i++)
+			{
+				if (pattern.loop_writes.test(i))
+				{
+					if (regs.size() != 1)
+					{
+						regs += ",";
+					}
+
+					fmt::append(regs, " r%u-w", i);
+				}
+
+				if (pattern.loop_args.test(i))
+				{
+					if (regs.size() != 1)
+					{
+						regs += ",";
+					}
+
+					fmt::append(regs, " r%u-r", i);
+				}
+			}
+
+			regs += " }";
+
+			spu_log.success("Reduced Loop Pattern Detected! (REGS: %s, DICT: r%d, ARG: %s, Incr: %s (%s), CMP/Size: %s/%u, loop_pc=0x%x, 0x%x-%s)", regs, pattern.cond_val_register_idx
+				, pattern.cond_val_is_immediate ? fmt::format("0x%x", pattern.cond_val_min) : fmt::format("r%d", pattern.cond_val_register_argument_idx)
+				, pattern.cond_val_incr_is_immediate ? fmt::format("%d", static_cast<s32>(pattern.cond_val_incr)) : fmt::format("r%d", pattern.cond_val_incr), pattern.cond_val_incr_before_cond ? "BEFORE" : "AFTER"
+				, pattern.cond_val_compare, std::popcount(pattern.cond_val_mask), loop_pc, entry_point, func_hash);
+		}
+	}
+
 	if (likely_putllc_loop && !had_putllc_evaluation)
 	{
 		spu_log.notice("Likely missed PUTLLC16 patterns. (entry=0x%x)", entry_point);
@@ -7386,7 +8626,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 	return result;
 }
 
-void spu_recompiler_base::dump(const spu_program& result, std::string& out)
+void spu_recompiler_base::dump(const spu_program& result, std::string& out, u32 block_min, u32 block_max)
 {
 	SPUDisAsm dis_asm(cpu_disasm_mode::dump, reinterpret_cast<const u8*>(result.data.data()), result.lower_bound);
 
@@ -7409,10 +8649,18 @@ void spu_recompiler_base::dump(const spu_program& result, std::string& out)
 		hash = "N/A";
 	}
 
-	fmt::append(out, "========== SPU BLOCK 0x%05x (size %u, %s) ==========\n\n", result.entry_point, result.data.size(), hash);
+	if (block_min == 0)
+	{
+		fmt::append(out, "========== SPU BLOCK 0x%05x (size %u, %s) ==========\n\n", result.entry_point, result.data.size(), hash);
+	}
 
 	for (auto& bb : m_bbs)
 	{
+		if (bb.first < block_min || bb.first >= block_max)
+		{
+			continue;
+		}
+
 		if (m_block_info[bb.first / 4])
 		{
 			fmt::append(out, "A: [0x%05x] %s  [%s]\n", bb.first, m_entry_info[bb.first / 4] ? (m_ret_info[bb.first / 4] ? "Chunk" : "Entry") : "Block", spu_block_hash{(hash_start & -65536) + bb.first / 4});
@@ -8435,9 +9683,9 @@ std::array<reg_state_t, s_reg_max>& block_reg_info::evaluate_start_state(const s
 	return walkby_state;
 }
 
-void spu_recompiler_base::add_pattern(inst_attr attr, u32 start, u64 info)
+void spu_recompiler_base::add_pattern(inst_attr attr, u32 start, u64 info, std::shared_ptr<void> info_ptr)
 {
-	m_patterns[start] = pattern_info{info};
+	m_patterns[start] = pattern_info{info, info_ptr};
 	m_inst_attrs[start / 4] = attr;
 }
 
diff --git a/rpcs3/Emu/Cell/SPUOpcodes.h b/rpcs3/Emu/Cell/SPUOpcodes.h
index cea4513e3f..93e56e48da 100644
--- a/rpcs3/Emu/Cell/SPUOpcodes.h
+++ b/rpcs3/Emu/Cell/SPUOpcodes.h
@@ -24,6 +24,20 @@ union spu_opcode_t
 	bf_t<u32, 7, 16> i16; // 9..24
 	bf_t<s32, 7, 16> si16; // 9..24, signed
 	bf_t<u32, 7, 18> i18; // 7..24
+
+	// For 16-bit instructions in the context of 32-bits
+	u32 duplicate_si10() const
+	{
+		const u32 _16 = static_cast<u16>(static_cast<s16>(si10));
+		return (_16 << 16) | _16;
+	}
+
+	// For 8-bit instructions in the context of 32-bits
+	u32 duplicate_duplicate_si10() const
+	{
+		const u32 _8 = static_cast<u8>(si10 & 0xff);
+		return (_8 << 24) | (_8 << 16) | (_8 << 8) | _8;
+	}
 };
 
 constexpr u32 spu_branch_target(u32 pc, u32 imm = 0)
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 57d842e69d..4348e7e08a 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -4,6 +4,7 @@
 #include "Utilities/lockless.h"
 #include "Utilities/address_range.h"
 #include "SPUThread.h"
+#include "SPUAnalyser.h"
 #include <vector>
 #include <bitset>
 #include <memory>
@@ -201,6 +202,25 @@ public:
 		__bitset_enum_max
 	};
 
+	enum compare_direction : u32
+	{
+		CMP_TURNAROUND_FLAG = 0x1,
+		CMP_NEGATE_FLAG = 0x100,
+		CMP_SLESS = 0,
+		CMP_SGREATER = CMP_SLESS | CMP_TURNAROUND_FLAG,
+		CMP_EQUAL,
+		CMP_EQUAL2 = CMP_EQUAL | CMP_TURNAROUND_FLAG,
+		CMP_LLESS,
+		CMP_LGREATER = CMP_LLESS | CMP_TURNAROUND_FLAG,
+		CMP_SGREATER_EQUAL = CMP_SLESS | CMP_NEGATE_FLAG,
+		CMP_SLOWER_EQUAL = CMP_SGREATER | CMP_NEGATE_FLAG,
+		CMP_NOT_EQUAL = CMP_EQUAL | CMP_NEGATE_FLAG,
+		CMP_NOT_EQUAL2 = CMP_NOT_EQUAL | CMP_TURNAROUND_FLAG,
+		CMP_LGREATER_EQUAL = CMP_LLESS | CMP_NEGATE_FLAG,
+		CMP_LLOWER_EQUAL = CMP_LGREATER | CMP_NEGATE_FLAG,
+		CMP_UNKNOWN,
+	};
+
 	struct reg_state_t
 	{
 		bs_t<vf> flag{+vf::is_null};
@@ -273,6 +293,399 @@ public:
 		static u32 alloc_tag(bool reset = false) noexcept;
 	};
 
+	struct reduced_loop_t
+	{
+		bool active = false; // Single block loop detected
+		bool failed = false;
+		u32 loop_pc = SPU_LS_SIZE;
+		u32 loop_end = SPU_LS_SIZE;
+
+		// False: single-block loop
+		// True: loop with a trailing block of aftermath (iteration update) stuff (like for (u32 i = 0; i < 10; /*update*/ i++))
+		bool is_two_block_loop = false;
+		bool has_cond_state = false;
+
+		// Loop stay-in state requirement
+		u64 cond_val_mask = umax;
+		u64 cond_val_min = 0;
+		u64 cond_val_size = 0;
+		compare_direction cond_val_compare{};
+		u64 cond_val_incr = 0;
+		bool cond_val_incr_is_immediate = false;
+		u64 cond_val_register_argument_idx = umax;
+		u64 cond_val_register_idx = umax;
+		bool cond_val_incr_before_cond = false;
+		bool cond_val_incr_before_cond_taken_in_account = false;
+		bool cond_val_is_immediate = false;
+
+		// Loop attributes
+		bool is_constant_expression = false;
+		bool is_secret = false;
+
+		struct supplemental_condition_t
+		{
+			u64 immediate_value = umax;
+			u64 type_size = 0;
+			compare_direction val_compare{};
+		};
+
+		// Supplemental loop condition:
+		// Inner conditions that depend on extrnal values (not produced inside the loop)
+		// all should evaluate to false in order for the optimization to work (at the moment)
+		// So succeeding can be treated linearly 
+		u64 expected_sup_conds = 0;
+		u64 current_sup_conds_index = 0;
+		std::vector<supplemental_condition_t> sup_conds;
+
+		void take_cond_val_incr_before_cond_into_account()
+		{
+			if (cond_val_is_immediate && cond_val_incr_before_cond_taken_in_account && !cond_val_incr_before_cond_taken_in_account)
+			{
+				cond_val_min -= cond_val_incr;
+				cond_val_min &= cond_val_mask;
+				cond_val_incr_before_cond_taken_in_account = true;
+			}
+		}
+
+		std::bitset<s_reg_max> loop_args;
+		std::bitset<s_reg_max> loop_dicts;
+		std::bitset<s_reg_max> loop_writes;
+
+		struct origin_t
+		{
+			std::bitset<s_reg_max> regs{};
+			u32 modified = 0;
+			spu_itype_t mod1_type = spu_itype::UNK;
+			spu_itype_t mod2_type = spu_itype::UNK;
+			spu_itype_t mod3_type = spu_itype::UNK;
+			u32 IMM = 0;
+
+private:
+			// Internal, please access using fixed order
+			spu_itype_t access_type(u32 i) const
+			{
+				if (i > modified)
+				{
+					return spu_itype::UNK;
+				}
+
+				switch (i)
+				{
+				case 1: return mod1_type;
+				case 2: return mod2_type;
+				case 3: return mod3_type;
+				default: return spu_itype::UNK;
+				}
+
+				return spu_itype::UNK;
+			}
+public:
+
+			spu_itype_t reverse1_type()
+			{
+				return access_type(modified); 
+			}
+
+			spu_itype_t reverse2_type()
+			{
+				return access_type(modified - 1); 
+			}
+
+			spu_itype_t reverse3_type()
+			{
+				return access_type(modified - 2);
+			}
+
+			origin_t& join_with_this(const origin_t& rhs)
+			{
+				regs |= rhs.regs;
+				return *this;
+			}
+
+			origin_t& join_with_this(u32 rhs)
+			{
+				regs.set(rhs);
+				return *this;
+			}
+
+			origin_t& add_register_origin(u32 reg_val)
+			{
+				regs.set(reg_val);
+				return *this;
+			}
+
+			bool is_single_reg_access(u32 reg_val) const
+			{
+				if (!modified)
+				{
+					return true;
+				}
+
+				return regs.count() == 1 && regs.test(reg_val);
+			}
+
+			bool is_loop_dictator(u32 reg_val, bool test_predictable = false, bool should_predictable = true) const
+			{
+				if (!modified)
+				{
+					return false;
+				}
+
+				if (regs.count() >= 1 && regs.test(reg_val))
+				{
+					if (!test_predictable)
+					{
+						return true;
+					}
+
+					if (modified > 1)
+					{
+						return should_predictable ^ true;
+					}
+
+					switch (mod1_type)
+					{
+					case spu_itype::A:
+					{
+						if (regs.count() == 2)
+						{
+							return should_predictable;
+						}
+
+						return should_predictable ^ true;
+					}
+					case spu_itype::AI:
+					case spu_itype::AHI:
+					{
+						if (IMM && regs.count() == 1)
+						{
+							return should_predictable;
+						}
+
+						return should_predictable ^ true;
+					}
+					default: break;
+					}
+
+					return should_predictable ^ true;
+				}
+
+				return false;
+			}
+
+			bool is_predictable_loop_dictator(u32 reg_val) const
+			{
+				return is_loop_dictator(reg_val, true, true);
+			}
+
+			bool is_non_predictable_loop_dictator(u32 reg_val) const
+			{
+				return is_loop_dictator(reg_val, true, false);
+			}
+
+			bool is_null(u32 reg_val) const noexcept
+			{
+				if (modified)
+				{
+					return false;
+				}
+
+				if (regs.count() - (regs.test(reg_val) ? 1 : 0))
+				{
+					return false;
+				}
+
+				return true;
+			}
+
+			origin_t& add_instruction_modifier(spu_itype_t inst_type, u32 imm = 0)
+			{
+				if (inst_type == spu_itype::UNK)
+				{
+					mod1_type = spu_itype::UNK;
+					mod2_type = spu_itype::UNK;
+					mod3_type = spu_itype::UNK;
+					IMM = umax;
+					modified = 1;
+					return *this;
+				}
+
+				if (modified == 1)
+				{
+					if (modified == 3)
+					{
+						mod1_type = spu_itype::UNK;
+						mod2_type = spu_itype::UNK;
+						mod3_type = spu_itype::UNK;
+						IMM = umax;
+						modified = 1;
+						return *this;
+					}
+
+					bool is_ok = false;
+					switch (inst_type)
+					{
+					case spu_itype::XSBH:
+					{
+						const auto prev_type = modified == 1 ? mod1_type : mod2_type;
+						is_ok &= mod1_type == spu_itype::CEQB || mod1_type == spu_itype::CEQBI || mod1_type == spu_itype::CGTB || mod1_type == spu_itype::CGTBI || mod1_type == spu_itype::CLGTB || mod1_type == spu_itype::CLGTBI;
+						break;
+					}
+					case spu_itype::ANDI:
+					{
+						const auto prev_type = modified == 1 ? mod1_type : mod2_type;
+						is_ok &= mod1_type == spu_itype::CEQB || mod1_type == spu_itype::CEQBI || mod1_type == spu_itype::CGTB || mod1_type == spu_itype::CGTBI || mod1_type == spu_itype::CLGTB || mod1_type == spu_itype::CLGTBI;
+						is_ok &= (spu_opcode_t{imm}.si10 & 0xff) == 0xff;
+						break;
+					}
+					case spu_itype::CEQ:
+					case spu_itype::CEQH:
+					case spu_itype::CEQB:
+					case spu_itype::CGT:
+					case spu_itype::CGTH:
+					case spu_itype::CGTB:
+					case spu_itype::CLGT:
+					case spu_itype::CLGTH:
+					case spu_itype::CLGTB:
+					{
+						is_ok = modified == 1 && (mod1_type == spu_itype::AI || mod1_type == spu_itype::AHI);
+						IMM = imm;
+						break;
+					}
+					case spu_itype::CEQI:
+					case spu_itype::CEQHI:
+					case spu_itype::CEQBI:
+					case spu_itype::CGTI:
+					case spu_itype::CGTHI:
+					case spu_itype::CGTBI:
+					case spu_itype::CLGTI:
+					case spu_itype::CLGTHI:
+					case spu_itype::CLGTBI:
+					{
+						is_ok = modified == 1 && (mod1_type == spu_itype::AI || mod1_type == spu_itype::AHI);
+						IMM = spu_opcode_t{imm}.si10;
+						break;
+					}
+					}
+
+					if (!is_ok)
+					{
+						mod1_type = spu_itype::UNK;
+						mod2_type = spu_itype::UNK;
+						mod3_type = spu_itype::UNK;
+						IMM = umax;
+						modified = 1;
+						return *this;
+					}
+
+					(modified == 1 ? mod2_type : mod3_type) = inst_type;
+					modified++;
+					return *this;
+				}
+
+				mod1_type = inst_type;
+				modified = 1;
+
+				switch (inst_type)
+				{
+				case spu_itype::AHI:
+				{
+					IMM = spu_opcode_t{imm}.duplicate_si10();
+					return *this;
+				}
+				case spu_itype::AI:
+				case spu_itype::ORI:
+				case spu_itype::XORI:
+				case spu_itype::ANDI:
+				
+				case spu_itype::CEQI:
+				case spu_itype::CEQHI:
+				case spu_itype::CEQBI:
+				case spu_itype::CGTI:
+				case spu_itype::CGTHI:
+				case spu_itype::CGTBI:
+				case spu_itype::CLGTI:
+				case spu_itype::CLGTHI:
+				case spu_itype::CLGTBI:
+				{
+					IMM = spu_opcode_t{imm}.si10;
+					return *this;
+				}
+				case spu_itype::ILA:
+				{
+					IMM = spu_opcode_t{imm}.i18;
+					return *this;
+				}
+				case spu_itype::IOHL:
+				case spu_itype::ILH:
+				case spu_itype::ILHU:
+				{
+					IMM = spu_opcode_t{imm}.i16;
+					return *this;
+				}
+				default:
+				{
+					IMM = imm;
+					break;
+				}
+				}
+
+				return *this;
+			}
+		};
+
+		static origin_t make_reg(u32 reg_val) noexcept
+		{
+			origin_t org{};
+			org.add_register_origin(reg_val);
+			return org;
+		}
+
+		const origin_t* find_reg(u32 reg_val) const noexcept
+		{
+			for (auto& pair : regs)
+			{
+				if (pair.first == reg_val)
+				{
+					return &pair.second;
+				}
+			}
+
+			return nullptr;
+		}
+
+		origin_t* find_reg(u32 reg_val) noexcept
+		{
+			return const_cast<origin_t*>(std::as_const(*this).find_reg(reg_val));
+		}
+
+		bool is_reg_null(u32 reg_val) const noexcept
+		{
+			if (const auto reg_found = find_reg(reg_val))
+			{
+				return reg_found->is_null(reg_val);
+			}
+
+			return true;
+		}
+
+		origin_t get_reg(u32 reg_val) noexcept
+		{
+			const auto org = find_reg(reg_val);
+			return org ? *org : regs.emplace_back(reg_val, std::remove_reference_t<decltype(*org)>{}).second;
+		}
+
+		std::vector<std::pair<u8, origin_t>> regs;
+
+		// Return old state for error reporting
+		reduced_loop_t discard()
+		{
+			const reduced_loop_t old = *this;
+			*this = reduced_loop_t{};
+			return old;
+		}
+	};
+
 protected:
 	spu_runtime* m_spurt{};
 
@@ -391,18 +804,23 @@ protected:
 		putllc16,
 		putllc0,
 		rchcnt_loop,
+		reduced_loop,
 	};
 
 	std::vector<inst_attr> m_inst_attrs;
 
 	struct pattern_info
 	{
-		u64 info;
+		// Info via integral
+		u64 info{};
+
+		// Info via additional erased-typed pointer
+		std::shared_ptr<void> info_ptr;
 	};
 
-	std::unordered_map<u32, pattern_info> m_patterns;
+	std::map<u32, pattern_info> m_patterns;
 
-	void add_pattern(inst_attr attr, u32 start, u64 info);
+	void add_pattern(inst_attr attr, u32 start, u64 info, std::shared_ptr<void> info_ptr = nullptr);
 
 private:
 	// For private use
@@ -435,7 +853,7 @@ public:
 	spu_program analyse(const be_t<u32>* ls, u32 entry_point, std::map<u32, std::vector<u32>>* out_target_list = nullptr);
 
 	// Print analyser internal state
-	void dump(const spu_program& result, std::string& out);
+	void dump(const spu_program& result, std::string& out, u32 block_min = 0, u32 block_max = SPU_LS_SIZE);
 
 	// Get SPU Runtime
 	spu_runtime& get_runtime()

From 2e4ee9c9b699976d1bb4856227e92b9fb3e60c02 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Tue, 10 Feb 2026 18:45:17 +0200
Subject: [PATCH 33/98] SPU LLVM: Implement reduced loop

---
 rpcs3/Emu/CPU/CPUTranslator.h          |   9 +
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp |   2 +
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp   | 576 ++++++++++++++++++++++++-
 rpcs3/Emu/Cell/SPUOpcodes.h            |   1 +
 rpcs3/Emu/Cell/SPUThread.cpp           |  61 ++-
 5 files changed, 639 insertions(+), 10 deletions(-)

diff --git a/rpcs3/Emu/CPU/CPUTranslator.h b/rpcs3/Emu/CPU/CPUTranslator.h
index 9b9804fd39..4a0028c571 100644
--- a/rpcs3/Emu/CPU/CPUTranslator.h
+++ b/rpcs3/Emu/CPU/CPUTranslator.h
@@ -3951,6 +3951,15 @@ public:
 		erase_stores({args.value...});
 	}
 
+	// Debug breakpoint
+	void debugtrap()
+	{
+		const auto _rty = llvm::Type::getVoidTy(m_context);
+		const auto type = llvm::FunctionType::get(_rty, {}, false);
+		const auto func = llvm::cast<llvm::Function>(m_ir->GetInsertBlock()->getParent()->getParent()->getOrInsertFunction("llvm.debugtrap", type).getCallee());
+		m_ir->CreateCall(func);
+	}
+
 	template <typename T, typename U>
 	static auto pshufb(T&& a, U&& b)
 	{
diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 4b52ce8c43..eff272753a 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -8544,6 +8544,8 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 		if (inst_attr attr = m_inst_attrs[(loop_pc - entry_point) / 4]; attr == inst_attr::none)
 		{
+			const u64 hash = loop_pc / 4 + read_from_ptr<be_t<u64>>(func_hash.data());
+
 			add_pattern(inst_attr::reduced_loop, loop_pc - result.entry_point, 0, std::make_shared<reduced_loop_t>(pattern));
 
 			std::string regs = "{";
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 856a039e5e..103f48085d 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -139,7 +139,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 		spu_recompiler_base::block_info* bb{};
 
 		// Current block's entry block
-		llvm::BasicBlock* block;
+		llvm::BasicBlock* block{};
 
 		// Final block (for PHI nodes, set after completion)
 		llvm::BasicBlock* block_end{};
@@ -155,6 +155,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 		// Store instructions
 		std::array<llvm::StoreInst*, s_reg_max> store{};
+		bool block_wide_reg_store_elimination = false;
 
 		// Store reordering/elimination protection
 		std::array<usz, s_reg_max> store_context_last_id = fill_array<usz>(0); // Protects against illegal forward ordering
@@ -364,7 +365,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 			{
 				if (i != s_reg_lr && i != s_reg_sp && (i < s_reg_80 || i > s_reg_127))
 				{
-					m_block->reg[i] = m_ir->CreateLoad(get_reg_type(i), init_reg_fixed(i));
+					m_block->reg[i] = get_reg_fixed(i, get_reg_type(i));
 				}
 			}
 
@@ -709,6 +710,11 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 		if (!reg)
 		{
+			if (m_block && m_block->block_wide_reg_store_elimination)
+			{
+				fmt::throw_exception("Unexpected load: [%s] at 0x%x (gpr=r%d)", m_hash, m_pos, index);
+			}
+
 			// Load register value if necessary
 			reg = m_finfo && m_finfo->load[index] ? m_finfo->load[index] : m_ir->CreateLoad(get_reg_type(index), init_reg_fixed(index));
 		}
@@ -920,6 +926,14 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 		if (m_block)
 		{
+			if (m_block->block_wide_reg_store_elimination)
+			{
+				// Don't save registers for the current block iteration
+				// Affected optimizations:
+				// 1. Single-block reduced loop
+				return;
+			}
+
 			// Keep the store's location in history of gpr preservaions
 			m_block->store_context_last_id[index] = m_block->store_context_ctr[index];
 			m_block->store_context_first_id[index] = std::min<usz>(m_block->store_context_first_id[index], m_block->store_context_ctr[index]);
@@ -2059,6 +2073,43 @@ public:
 				bool need_check = false;
 				m_block->bb = &bb;
 
+				// [1gJ45f2-0x00a40]: 16.4982% (113258)
+				// [ZsQTud1-0x0924c]: 6.1202% (42014)
+				// [ZsQTud1-0x08e54]: 5.6610% (38862)
+				// [0000000-0x3fffc]: 4.3764% (30043)
+				// [Zh4tpJM-0x00bcc]: 3.7908% (26023)
+				// [CFt8hXu-0x063b8]: 3.6177% (24835)
+				// [8YJCUjv-0x0ad18]: 3.2417% (22254)
+				// [Try3XHn-0x0f018]: 2.3721% (16284)
+				// [s6ti9iu-0x07678]: 1.8464% (12675)
+				// [oyxkAPv-0x0c22c]: 1.7776% (12203)
+				// [Q0jLqH4-0x00324]: 1.6015% (10994)
+				static const std::array<std::pair<std::string, u32>, 4> to_nop
+				{
+					{ }
+				};
+
+				bool found_block = false;
+
+				for (auto& [hash, pos] : to_nop)
+				{
+					if (m_hash.find(hash) <= 2 && baddr == pos)
+					{
+						found_block = true;
+						break;
+					}
+				}
+
+				if (found_block)
+				{
+					for (u32 i = 0; i < 100; i++)
+					{
+						auto value = m_ir->CreateLoad(get_type<f32>(), spu_ptr(&spu_thread::last_getllar_lsa));
+						auto mod_val = m_ir->CreateFDiv(value, llvm::ConstantFP::get(value->getType(), 1.1 + i));
+						m_ir->CreateStore(value, spu_ptr(&spu_thread::last_getllar_lsa));
+					}
+				}
+
 				if (!bb.preds.empty())
 				{
 					// Initialize registers and build PHI nodes if necessary
@@ -2174,6 +2225,485 @@ public:
 					check_state(baddr);
 				}
 
+				const bool is_reduced_loop = m_inst_attrs[(baddr - start) / 4] == inst_attr::reduced_loop;
+				const auto reduced_loop_info = is_reduced_loop ? std::static_pointer_cast<reduced_loop_t>(ensure(m_patterns.at(baddr - start).info_ptr)) : nullptr;
+
+				BasicBlock* block_optimization_phi_parent =  nullptr;
+				const auto block_optimization_inner = is_reduced_loop ? BasicBlock::Create(m_context, fmt::format("b-loop-it-0x%x", m_pos), m_function) : nullptr;
+				const auto block_optimization_exit_early = is_reduced_loop ? BasicBlock::Create(m_context, fmt::format("b-loop-exit-0x%x", m_pos), m_function) : nullptr;
+				const auto block_optimization_next = is_reduced_loop ? BasicBlock::Create(m_context, fmt::format("b2-0x%x", m_pos), m_function) : nullptr;
+
+				std::array<llvm::PHINode*, s_reg_max> reduced_loop_phi_nodes{};
+				std::array<llvm::Value*, s_reg_max> reduced_loop_init_regs{};
+
+				auto make_reduced_loop_condition = [&](llvm::BasicBlock* optimization_block, bool is_second_time, u32 reserve_iterations)
+				{
+					llvm::ICmpInst::Predicate compare{};
+
+					switch (reduced_loop_info->cond_val_compare)
+					{
+					case CMP_SLESS:  compare = ICmpInst::ICMP_SLT; break;
+					case CMP_SGREATER: compare = ICmpInst::ICMP_SGT; break;
+					case CMP_EQUAL: compare = ICmpInst::ICMP_EQ; break;
+					case CMP_LLESS: compare = ICmpInst::ICMP_ULT; break;
+					case CMP_LGREATER: compare = ICmpInst::ICMP_UGT; break;
+					case CMP_SGREATER_EQUAL: compare = ICmpInst::ICMP_SGE; break;
+					case CMP_SLOWER_EQUAL: compare = ICmpInst::ICMP_SLE; break;
+					case CMP_NOT_EQUAL: compare = ICmpInst::ICMP_NE; break;
+					case CMP_LGREATER_EQUAL: compare = ICmpInst::ICMP_UGE; break;
+					case CMP_LLOWER_EQUAL: compare = ICmpInst::ICMP_ULE; break;
+					{
+						break;
+					}
+					case CMP_UNKNOWN:
+					case CMP_NOT_EQUAL2:
+					case CMP_EQUAL2:
+					default:
+					{
+						ensure(false);
+						break;
+					}
+					}
+
+					llvm::Value* loop_dictator_before_adjustment{};
+					llvm::Value* loop_dictator_after_adjustment{};
+
+					spu_opcode_t reg_target{};
+					reg_target.rt = reduced_loop_info->cond_val_register_idx;
+
+					if (reg_target.rt != reduced_loop_info->cond_val_register_idx)
+					{
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition register index: 0x%llx", reduced_loop_info->cond_val_register_idx);
+					}
+
+					if (!m_block->reg[reg_target.rt])
+					{
+						m_block->reg[reg_target.rt] = reduced_loop_init_regs[reg_target.rt];
+					}
+
+					switch (reduced_loop_info->cond_val_mask)
+					{
+					case u8{umax}:
+					{
+						loop_dictator_before_adjustment = get_scalar(get_vr<u8[16]>(reg_target.rt)).eval(m_ir);
+						break;
+					}
+					case u16{umax}:
+					{
+						loop_dictator_before_adjustment = get_scalar(get_vr<u16[8]>(reg_target.rt)).eval(m_ir);
+						break;
+					}
+					case u32{umax}:
+					{
+						loop_dictator_before_adjustment = get_scalar(get_vr<u32[4]>(reg_target.rt)).eval(m_ir);
+						break;
+					}
+					case u64{umax}:
+					{
+						ensure(false); // TODO
+						loop_dictator_before_adjustment = get_scalar(get_vr<u64[2]>(reg_target.rt)).eval(m_ir);
+						break;
+					}
+					default:
+					{
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition bit mask: 0x%llx", reduced_loop_info->cond_val_mask);
+					}
+					}
+
+					const u32 type_bits = std::popcount(reduced_loop_info->cond_val_mask);
+
+					llvm::Value* cond_val_incr = nullptr;
+
+					if (reduced_loop_info->cond_val_incr_is_immediate)
+					{
+						cond_val_incr = m_ir->getIntN(type_bits, reduced_loop_info->cond_val_incr & reduced_loop_info->cond_val_mask);
+					}
+					else
+					{
+						spu_opcode_t reg_incr{};
+						reg_incr.rt = reduced_loop_info->cond_val_incr;
+
+						if (reg_incr.rt != reduced_loop_info->cond_val_incr)
+						{
+							fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal increment arguemnt register index: 0x%llx", reduced_loop_info->cond_val_incr);
+						}
+						switch (reduced_loop_info->cond_val_mask)
+						{
+						case u8{umax}:
+						{
+							cond_val_incr = get_scalar(get_vr<u8[16]>(reg_incr.rt)).eval(m_ir);
+							break;
+						}
+						case u16{umax}:
+						{
+							cond_val_incr = get_scalar(get_vr<u16[8]>(reg_incr.rt)).eval(m_ir);
+							break;
+						}
+						case u32{umax}:
+						{
+							cond_val_incr = get_scalar(get_vr<u32[4]>(reg_incr.rt)).eval(m_ir);
+							break;
+						}
+						case u64{umax}:
+						{
+							ensure(false); // TODO
+							cond_val_incr = get_scalar(get_vr<u64[2]>(reg_incr.rt)).eval(m_ir);
+							break;
+						}
+						}
+					}
+
+					if (reduced_loop_info->cond_val_incr_before_cond && !reduced_loop_info->cond_val_incr_before_cond_taken_in_account)
+					{
+						loop_dictator_after_adjustment = m_ir->CreateAdd(loop_dictator_before_adjustment, cond_val_incr);
+					}
+					else
+					{
+						loop_dictator_after_adjustment = loop_dictator_before_adjustment;
+					}
+
+					llvm::Value* loop_argument = nullptr;
+
+					if (reduced_loop_info->cond_val_is_immediate)
+					{
+						loop_argument = m_ir->CreateTrunc(m_ir->getInt64(reduced_loop_info->cond_val_min & reduced_loop_info->cond_val_mask), loop_dictator_before_adjustment->getType());
+					}
+					else
+					{
+						spu_opcode_t reg_target2{};
+						reg_target2.rt = reduced_loop_info->cond_val_register_argument_idx;
+
+						if (reg_target2.rt != reduced_loop_info->cond_val_register_argument_idx)
+						{
+							fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition arguemnt register index: 0x%llx", reduced_loop_info->cond_val_register_argument_idx);
+						}
+
+						switch (reduced_loop_info->cond_val_mask)
+						{
+						case u8{umax}:
+						{
+							loop_argument = get_scalar(get_vr<u8[16]>(reg_target2.rt)).eval(m_ir);
+							break;
+						}
+						case u16{umax}:
+						{
+							loop_argument = get_scalar(get_vr<u16[8]>(reg_target2.rt)).eval(m_ir);
+							break;
+						}
+						case u32{umax}:
+						{
+							loop_argument = get_scalar(get_vr<u32[4]>(reg_target2.rt)).eval(m_ir);
+							break;
+						}
+						case u64{umax}:
+						{
+							ensure(false); // TODO
+							loop_argument = get_scalar(get_vr<u64[2]>(reg_target2.rt)).eval(m_ir);
+							break;
+						}
+						}
+					}
+
+					llvm::Value* condition = nullptr;
+
+					if (reserve_iterations == 1)
+					{
+						condition = m_ir->CreateICmp(compare, loop_dictator_after_adjustment, loop_argument);
+					}
+					// else if ((reduced_loop_info->cond_val_compare == CMP_LGREATER || (reduced_loop_info->cond_val_compare == CMP_LGREATER_EQUAL && reduced_loop_info->cond_val_is_immediate && reduced_loop_info->cond_val_incr)) && cond_val_incr->getSExtValue() < 0)
+					// {
+					// 	const auto cond_val_incr_multiplied = m_ir->CreateMul(cond_val_incr, reserve_iterations - 1);
+					// 	condition = m_ir->CreateICmp(compare, select(m_ir->CreateICmpUGE(cond_val_incr_multiplied, loop_dictator_after_adjustment), m_ir->CreateAdd(loop_dictator_after_adjustment, cond_val_incr_multiplied), m_ir->getIntN(type_bits, 0)), loop_argument);
+					// }
+					else
+					{
+						//debugtrap();
+
+						llvm::Value* prev_it = loop_dictator_after_adjustment;
+
+						for (u32 i = 0; i < reserve_iterations; i++)
+						{
+							if (i)
+							{
+								prev_it = m_ir->CreateAdd(prev_it, cond_val_incr);
+							}
+
+							const auto also_cond = m_ir->CreateICmp(compare, prev_it, loop_argument);
+							condition = condition ? m_ir->CreateAnd(condition, also_cond) : also_cond;
+						}
+					}
+
+					if (!is_second_time)
+					{
+						for (u32 i = 0, count = 0, prev_i = umax;; i++)
+						{
+							const bool is_last = !(count <= 20 && i < s_reg_max);
+
+							if (is_last || m_block->is_gpr_not_NaN_hint(i))
+							{
+								count++;
+
+								if (prev_i == umax)
+								{
+									if (!is_last)
+									{
+										prev_i = i;
+										continue;
+									}
+
+									break;
+								}
+
+								auto access_gpr = [&](u32 index)
+								{
+									spu_opcode_t op_arg{};
+									op_arg.ra = index;
+									return get_vr<u32[4]>(op_arg.ra);
+								};
+
+								// OR LSB to convert infinity to NaN
+								llvm::Value* arg1 = bitcast<f32[4]>(access_gpr(prev_i) | splat<u32[4]>(1)).eval(m_ir);
+								llvm::Value* arg2 = is_last ? arg1 : bitcast<f32[4]>(access_gpr(i) | splat<u32[4]>(1)).eval(m_ir);
+
+								llvm::Value* acc = m_ir->CreateSExt(m_ir->CreateFCmpUNO(arg1, arg2), get_type<s32[4]>());
+
+								// Pattern for PTEST
+								acc = m_ir->CreateBitCast(acc, get_type<u64[2]>());
+
+								llvm::Value* elem = m_ir->CreateExtractElement(acc, u64{0});
+
+								for (u64 i = 1; i < 2; i++)
+								{
+									elem = m_ir->CreateOr(elem, m_ir->CreateExtractElement(acc, i));
+								}
+
+								// Compare result with zero
+								const auto cond_nans = m_ir->CreateICmpEQ(elem, m_ir->getInt64(0));
+								condition = m_ir->CreateAnd(cond_nans, condition);
+								prev_i = umax;
+							}
+						}
+					}
+
+					//condition = m_ir->getInt1(0);
+
+					m_ir->CreateCondBr(condition, optimization_block, block_optimization_next);
+				};
+
+				if (is_reduced_loop)
+				{
+					for (u32 i = 0; i < s_reg_max; i++)
+					{
+						llvm::Type* type = g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::accurate && bb.reg_maybe_xf[i] ? get_type<f64[4]>() : get_reg_type(i);
+
+						if (i < reduced_loop_info->loop_dicts.size() && (reduced_loop_info->loop_dicts.test(i) || reduced_loop_info->loop_writes.test(i)))
+						{
+							// Connect registers which are used and then modified by the block
+							auto value = m_block->reg[i];
+
+							if (!value || value->getType() != type)
+							{
+								value = get_reg_fixed(i, type);
+							}
+
+							reduced_loop_init_regs[i] = value;
+						}
+						else if (i < reduced_loop_info->loop_dicts.size() && reduced_loop_info->loop_args.test(i))
+						{
+							// Load registers used as arguments of the loop
+							if (!m_block->reg[i])
+							{
+								m_block->reg[i] = get_reg_fixed(i, type);
+							}
+						}
+					}
+
+					const auto prev_insert_block = m_ir->GetInsertBlock();
+
+					block_optimization_phi_parent = prev_insert_block;
+	
+					make_reduced_loop_condition(block_optimization_inner, false, 2);
+					m_ir->SetInsertPoint(block_optimization_inner);
+
+					for (u32 i = 0; i < s_reg_max; i++)
+					{
+						if (auto init_val = reduced_loop_init_regs[i])
+						{
+							llvm::Type* type = g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::accurate && bb.reg_maybe_xf[i] ? get_type<f64[4]>() : get_reg_type(i);
+
+							const auto _phi = m_ir->CreatePHI(init_val->getType(), 2, fmt::format("reduced_0x%05x_r%u", baddr, i));
+							_phi->addIncoming(init_val, prev_insert_block);
+
+							reduced_loop_phi_nodes[i] = _phi;
+							m_block->reg[i] = _phi;
+						}
+					}
+
+					m_block->block_wide_reg_store_elimination = true;
+				}
+
+				// Instructions emitting optimizations: Loop iteration is not the last
+				m_pos = baddr;
+
+				// Masked opcodde -> register modification times
+				std::map<u32, std::pair<llvm::Value*, std::array<u32, 3>>> masked_times;
+				std::array<u32, s_reg_max + 1> reg_states{};
+				u32 s_reg_state{1};
+
+				for (u32 iteration_emit = 0; is_reduced_loop; m_pos += 4)
+				{
+					if (m_pos != baddr && m_block_info[m_pos / 4] && reduced_loop_info->loop_end < m_pos)
+					{
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Exit(1) too early at 0x%x", m_pos);
+					}
+
+					if (!(m_pos >= start && m_pos < end))
+					{
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Exit(2) too early at 0x%x", m_pos);
+					}
+
+					if (m_ir->GetInsertBlock()->getTerminator())
+					{
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Exit(3) too early at 0x%x", m_pos);
+					}
+
+					const u32 op = std::bit_cast<be_t<u32>>(func.data[(m_pos - start) / 4]);
+					const auto itype = g_spu_itype.decode(op);
+
+					if (itype & spu_itype::branch)
+					{
+						bool branches_back = false;
+
+						for (u32 dest : op_branch_targets(m_pos, spu_opcode_t{op}))
+						{
+							branches_back = branches_back || dest == baddr;
+						}
+
+						if (!branches_back)
+						{
+							continue;
+						}
+
+						iteration_emit++;
+
+						if (iteration_emit < 2)
+						{
+							// Reset mpos (with fixup)
+							m_pos = baddr - 4;
+							continue;
+						}
+
+						// Optimization block body
+						const auto block_inner = m_ir->GetInsertBlock();
+
+						std::array<llvm::Value*, s_reg_max> block_reg_results{};
+
+						for (u32 i = 0; i < s_reg_max; i++)
+						{
+							if (auto phi = reduced_loop_phi_nodes[i])
+							{
+								const auto type = phi->getType() == get_type<f64[4]>() ? get_type<f64[4]>() : get_reg_type(i);
+								block_reg_results[i] = ensure(get_reg_fixed(i, type));
+								phi->addIncoming(block_reg_results[i], block_inner);
+							}
+						}
+
+						ensure(!!m_block->reg[reduced_loop_info->cond_val_register_idx]);
+						make_reduced_loop_condition(block_optimization_inner, true, 2);
+						m_ir->SetInsertPoint(block_optimization_next);
+						m_block->block_wide_reg_store_elimination = false;
+
+						for (u32 i = 0; i < s_reg_max; i++)
+						{
+							if (const auto loop_value = block_reg_results[i])
+							{
+								const auto phi = m_ir->CreatePHI(loop_value->getType(), 2, fmt::format("redres_0x%05x_r%u", baddr, i));
+
+								phi->addIncoming(loop_value, block_inner);
+								phi->addIncoming(reduced_loop_init_regs[i], block_optimization_phi_parent);
+								m_block->reg[i] = phi;
+							}
+						}
+
+							
+						break;
+					}
+
+					if (!op)
+					{
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: [%s] Unexpected fallthrough to 0x%x (chunk=0x%x, entry=0x%x)", m_hash, m_pos, m_entry, m_function_queue[0]);
+					}
+
+					const auto [reg_rt, reg_access, masked_op] = op_register_targets(m_pos, spu_opcode_t{op});
+
+					bool erased = false;
+
+					const auto inst_times = std::array<u32, 3>{reg_states[reg_access[0]], reg_states[reg_access[1]], reg_states[reg_access[2]]};
+
+					// Try to reuse the reult of the previous iteration (if argumnent registers have not been modified)
+					if (reg_rt < 128 && masked_times.count(masked_op) && masked_times[masked_op].first && m_inst_attrs[(m_pos - start) / 4] == inst_attr::none)
+					{
+						auto times = masked_times[masked_op].second;
+
+						bool is_ok = true;
+						for (u32 regi = 0; regi < 3; regi++)
+						{
+							if (reg_access[regi] < 128 && times[regi] != inst_times[regi])
+							{
+								is_ok = false;
+							}
+						}
+
+						if (is_ok)
+						{
+							m_block->reg[reg_rt] = masked_times[masked_op].first;
+							erased = true;
+						}
+					}
+
+					if (reg_rt < 128)
+					{
+						reg_states[reg_rt] = s_reg_state++;
+					}
+
+					if (erased)
+					{
+						continue;
+					}
+
+					m_next_op = 0;
+
+					masked_times[masked_op] = {};
+
+					switch (m_inst_attrs[(m_pos - start) / 4])
+					{
+					case inst_attr::putllc0:
+					{
+						putllc0_pattern(func, m_patterns.at(m_pos - start).info);
+						continue;
+					}
+					case inst_attr::putllc16:
+					{
+						putllc16_pattern(func, m_patterns.at(m_pos - start).info);
+						continue;
+					}
+					case inst_attr::omit:
+					{
+						// TODO
+						continue;
+					}
+					default: break;
+					}
+
+					// Execute recompiler function (TODO)
+					(this->*decode(op))({op});
+
+					if (reg_rt < 128 && itype & spu_itype::pure && reg_rt != reg_access[0] && reg_rt != reg_access[1] && reg_rt != reg_access[2])
+					{
+						masked_times[masked_op] = {ensure(m_block->reg[reg_rt]), inst_times};
+					}
+				}
+
 				// Emit instructions
 				for (m_pos = baddr; m_pos >= start && m_pos < end && !m_ir->GetInsertBlock()->getTerminator(); m_pos += 4)
 				{
@@ -7824,13 +8354,51 @@ public:
 			}
 		}
 
-		value_t<u64> addr = eval(zext<u64>(extract(get_vr(op.ra), 3) & 0x3fff0) + (get_imm<u64>(op.si10) << 4));
+		const auto a = get_vr(op.ra);
+
+		if (auto [ok, x, y] = match_expr(a, match<u32[4]>() + match<u32[4]>()); ok)
+		{
+			if (auto [ok1, data] = get_const_vector(x.value, m_pos + 1); ok1 && data._u32[3] % 16 == 0)
+			{
+				value_t<u64> addr = eval(zext<u64>(extract(y, 3) & 0x3fff0) + ((get_imm<u64>(op.si10) << 4) + splat<u64>(data._u32[3] & 0x3fff0)));
+				make_store_ls(addr, get_vr<u8[16]>(op.rt));
+				return;
+			}
+
+			if (auto [ok2, data] = get_const_vector(y.value, m_pos + 2); ok2 && data._u32[3] % 16 == 0)
+			{
+				value_t<u64> addr = eval(zext<u64>(extract(x, 3) & 0x3fff0) + ((get_imm<u64>(op.si10) << 4) + splat<u64>(data._u32[3] & 0x3fff0)));
+				make_store_ls(addr, get_vr<u8[16]>(op.rt));
+				return;
+			}
+		}
+
+		value_t<u64> addr = eval(zext<u64>(extract(a, 3) & 0x3fff0) + (get_imm<u64>(op.si10) << 4));
 		make_store_ls(addr, get_vr<u8[16]>(op.rt));
 	}
 
 	void LQD(spu_opcode_t op)
 	{
-		value_t<u64> addr = eval(zext<u64>(extract(get_vr(op.ra), 3) & 0x3fff0) + (get_imm<u64>(op.si10) << 4));
+		const auto a = get_vr(op.ra);
+
+		if (auto [ok, x1, y1] = match_expr(a, match<u32[4]>() + match<u32[4]>()); ok)
+		{
+			if (auto [ok1, data] = get_const_vector(x1.value, m_pos + 1); ok1 && data._u32[3] % 16 == 0)
+			{
+				value_t<u64> addr = eval(zext<u64>(extract(y1, 3) & 0x3fff0) + ((get_imm<u64>(op.si10) << 4) + splat<u64>(data._u32[3] & 0x3fff0)));
+				set_vr(op.rt, make_load_ls(addr));
+				return;
+			}
+
+			if (auto [ok2, data] = get_const_vector(y1.value, m_pos + 2); ok2 && data._u32[3] % 16 == 0)
+			{
+				value_t<u64> addr = eval(zext<u64>(extract(x1, 3) & 0x3fff0) + ((get_imm<u64>(op.si10) << 4) + splat<u64>(data._u32[3] & 0x3fff0)));
+				set_vr(op.rt, make_load_ls(addr));
+				return;
+			}
+		}
+
+		value_t<u64> addr = eval(zext<u64>(extract(a, 3) & 0x3fff0) + (get_imm<u64>(op.si10) << 4));
 		set_vr(op.rt, make_load_ls(addr));
 	}
 
diff --git a/rpcs3/Emu/Cell/SPUOpcodes.h b/rpcs3/Emu/Cell/SPUOpcodes.h
index 93e56e48da..42d76792a2 100644
--- a/rpcs3/Emu/Cell/SPUOpcodes.h
+++ b/rpcs3/Emu/Cell/SPUOpcodes.h
@@ -56,6 +56,7 @@ constexpr u32 spu_decode(u32 inst)
 }
 
 std::array<u32, 2> op_branch_targets(u32 pc, spu_opcode_t op);
+std::tuple<u32, std::array<u32, 3>, u32> op_register_targets(u32 /*pc*/, spu_opcode_t op);
 
 // SPU decoder object. D provides functions. T is function pointer type returned.
 template <typename D, typename T = decltype(&D::UNK)>
diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp
index b9a77d7696..e4346bc3df 100644
--- a/rpcs3/Emu/Cell/SPUThread.cpp
+++ b/rpcs3/Emu/Cell/SPUThread.cpp
@@ -495,7 +495,8 @@ void do_cell_atomic_128_store(u32 addr, const void* to_write);
 
 extern thread_local u64 g_tls_fault_spu;
 
-const spu_decoder<spu_itype> s_spu_itype;
+const extern spu_decoder<spu_itype> g_spu_itype;
+const extern spu_decoder<spu_iflag> g_spu_iflag;
 
 namespace vm
 {
@@ -598,7 +599,7 @@ std::array<u32, 2> op_branch_targets(u32 pc, spu_opcode_t op)
 {
 	std::array<u32, 2> res{spu_branch_target(pc + 4), umax};
 
-	switch (const auto type = s_spu_itype.decode(op.opcode))
+	switch (const auto type = g_spu_itype.decode(op.opcode))
 	{
 	case spu_itype::BR:
 	case spu_itype::BRA:
@@ -639,6 +640,54 @@ std::array<u32, 2> op_branch_targets(u32 pc, spu_opcode_t op)
 	return res;
 }
 
+std::tuple<u32, std::array<u32, 3>, u32> op_register_targets(u32 /*pc*/, spu_opcode_t op)
+{
+	std::tuple<u32, std::array<u32, 3>, u32> result{u32{umax}, std::array<u32, 3>{128, 128, 128}, op.opcode};
+
+	const auto type = g_spu_itype.decode(op.opcode);
+
+	if (type & spu_itype::zregmod)
+	{
+		std::get<2>(result) = 0;
+		return result;
+	}
+
+	std::get<0>(result) = type & spu_itype::_quadrop ? op.rt4 : op.rt;
+
+	spu_opcode_t op_masked = op;
+
+	if (type & spu_itype::_quadrop)
+	{
+		op_masked.rt4 = 0;
+	}
+	else
+	{
+		op_masked.rt = 0;
+	}
+
+	std::get<2>(result) = op_masked.opcode;
+
+	if (auto iflags = g_spu_iflag.decode(op.opcode))
+	{
+		if (+iflags & +spu_iflag::use_ra)
+		{
+			std::get<1>(result)[0] = op.ra;
+		}
+
+		if (+iflags & +spu_iflag::use_rb)
+		{
+			std::get<1>(result)[1] = op.rb;
+		}
+
+		if (+iflags & +spu_iflag::use_rc)
+		{
+			std::get<1>(result)[2] = op.rc;
+		}
+	}
+
+	return result;
+}
+
 void spu_int_ctrl_t::set(u64 ints)
 {
 	// leave only enabled interrupts
@@ -988,7 +1037,7 @@ std::vector<std::pair<u32, u32>> spu_thread::dump_callstack_list() const
 					passed[i / 4] = true;
 
 					const spu_opcode_t op{_ref<u32>(i)};
-					const auto type = s_spu_itype.decode(op.opcode);
+					const auto type = g_spu_itype.decode(op.opcode);
 
 					if (start == 0 && type == spu_itype::STQD && op.ra == 1u && op.rt == 0u)
 					{
@@ -3761,7 +3810,7 @@ bool spu_thread::is_exec_code(u32 addr, std::span<const u8> ls_ptr, u32 base_add
 
 		const u32 addr0 = spu_branch_target(addr);
 		const spu_opcode_t op{read_from_ptr<be_t<u32>>(ls_ptr, addr0 - base_addr)};
-		const auto type = s_spu_itype.decode(op.opcode);
+		const auto type = g_spu_itype.decode(op.opcode);
 
 		if (type == spu_itype::UNK || !op.opcode)
 		{
@@ -3907,7 +3956,7 @@ bool spu_thread::is_exec_code(u32 addr, std::span<const u8> ls_ptr, u32 base_add
 				// Test the validity of a single instruction of the optional target
 				// This function can't be too slow and is unlikely to improve results by a great deal
 				const u32 op0 = read_from_ptr<be_t<u32>>(ls_ptr, route_pc - base_addr);
-				const spu_itype::type type0 = s_spu_itype.decode(op0);
+				const spu_itype::type type0 = g_spu_itype.decode(op0);
 
 				if (type0 == spu_itype::UNK || !op0)
 				{
@@ -6878,7 +6927,7 @@ spu_exec_object spu_thread::capture_memory_as_elf(std::span<spu_memory_segment_d
 			const u32 op = read_from_ptr<be_t<u32>>(all_data, pc0 - 4);
 
 			// Try to find function entry (if they are placed sequentially search for BI $LR of previous function)
-			if (!op || op == 0x35000000u || s_spu_itype.decode(op) == spu_itype::UNK)
+			if (!op || op == 0x35000000u || g_spu_itype.decode(op) == spu_itype::UNK)
 			{
 				if (is_exec_code(pc0, { all_data.data(), SPU_LS_SIZE }))
 					break;

From fbdbf8addf1ebfc1d51ef0a68f9fc44d59ec5b84 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Tue, 24 Feb 2026 15:16:25 +0200
Subject: [PATCH 34/98] SPU LLVM: CEQHI pattern

---
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp | 48 ++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 103f48085d..59f43cd6dd 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -6286,11 +6286,59 @@ public:
 
 	void CEQI(spu_opcode_t op)
 	{
+		// CEQHI following a comparison instruction (compare-equal negation)
+		if (!m_interp_magn && !op.si10 && match_vr<s32[4]>(op.ra, [&](auto c, auto MT)
+		{
+			using VT = typename decltype(MT)::type;
+			using VT_HALF = s16[8];
+
+			if (auto [ok, a, b] = match_expr(c, bitcast<VT>(sext<VT_HALF>(match<VT_HALF>() == match<VT_HALF>())) << 16 >> 16); ok && m_block->block_wide_reg_store_elimination)
+			{
+				set_vr(op.rt, bitcast<VT>(sext<VT_HALF>(a != b)) << 16 >> 16);
+				return true;
+			}
+
+			if (auto [ok, a, b] = match_expr(c, sext<VT>(MT == MT)); ok)
+			{
+				set_vr(op.rt, sext<VT>(a != b));
+				return true;
+			}
+
+			return false;
+		}))
+		{
+			return;
+		}
+
 		set_vr(op.rt, sext<s32[4]>(get_vr(op.ra) == get_imm(op.si10)));
 	}
 
 	void CEQHI(spu_opcode_t op)
 	{
+		// CEQHI following a comparison instruction (compare-equal negation)
+		if (!m_interp_magn && !op.si10 && match_vr<s16[8]>(op.ra, [&](auto c, auto MT)
+		{
+			using VT = typename decltype(MT)::type;
+			using VT_HALF = s8[16];
+
+			if (auto [ok, a, b] = match_expr(c, bitcast<VT>(sext<VT_HALF>(match<VT_HALF>() == match<VT_HALF>())) << 8 >> 8); ok && m_block->block_wide_reg_store_elimination)
+			{
+				set_vr(op.rt, bitcast<VT>(sext<VT_HALF>(a != b)) << 8 >> 8);
+				return true;
+			}
+
+			if (auto [ok, a, b] = match_expr(c, sext<VT>(match<VT>() == match<VT>())); ok)
+			{
+				set_vr(op.rt, sext<VT>(a != b));
+				return true;
+			}
+
+			return false;
+		}))
+		{
+			return;
+		}
+
 		set_vr(op.rt, sext<s16[8]>(get_vr<u16[8]>(op.ra) == get_imm<u16[8]>(op.si10)));
 	}
 

From 49abd6d8e56256a7d49fdc3fbd8c17efa6faf419 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Wed, 25 Feb 2026 16:56:35 +0200
Subject: [PATCH 35/98] SPU LLVM: Allow the reuse of address from LQX/STQX

---
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 59f43cd6dd..71217fb0bf 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -8319,12 +8319,18 @@ public:
 			{
 				data._u32[3] %= SPU_LS_SIZE;
 
-				if (data._u32[3] % 0x10 == 0)
+				if (const u32 remainder = data._u32[3] % 0x10; remainder == 0)
 				{
 					value_t<u64> addr = eval(splat<u64>(data._u32[3]) + zext<u64>(extract(pair.second, 3) & 0x3fff0));
 					make_store_ls(addr, get_vr<u8[16]>(op.rt));
 					return;
 				}
+				else
+				{
+					value_t<u64> addr = eval(splat<u64>(data._u32[3] - remainder) + zext<u64>((extract(pair.second, 3) + remainder) & 0x3fff0));
+					make_store_ls(addr, get_vr<u8[16]>(op.rt));
+					return;
+				}
 			}
 		}
 
@@ -8343,12 +8349,18 @@ public:
 			{
 				data._u32[3] %= SPU_LS_SIZE;
 
-				if (data._u32[3] % 0x10 == 0)
+				if (const u32 remainder = data._u32[3] % 0x10; remainder == 0)
 				{
 					value_t<u64> addr = eval(splat<u64>(data._u32[3]) + zext<u64>(extract(pair.second, 3) & 0x3fff0));
 					set_vr(op.rt, make_load_ls(addr));
 					return;
 				}
+				else
+				{
+					value_t<u64> addr = eval(splat<u64>(data._u32[3] - remainder) + zext<u64>((extract(pair.second, 3) + remainder) & 0x3fff0));
+					set_vr(op.rt, make_load_ls(addr));
+					return;
+				}
 			}
 		}
 

From e1eae3ee4959ca7373f999350e7b562d17f212db Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Sun, 8 Mar 2026 14:54:58 +0200
Subject: [PATCH 36/98] Add floating ppoint hint

---
 rpcs3/Emu/Cell/SPUAnalyser.h           | 24 ++++++++++++------------
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 21 +++++++++++++--------
 rpcs3/Emu/Cell/SPURecompiler.h         |  7 +++++--
 3 files changed, 30 insertions(+), 22 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUAnalyser.h b/rpcs3/Emu/Cell/SPUAnalyser.h
index 59560cd182..a6c788faad 100644
--- a/rpcs3/Emu/Cell/SPUAnalyser.h
+++ b/rpcs3/Emu/Cell/SPUAnalyser.h
@@ -158,6 +158,15 @@ struct spu_itype
 		CUFLT,
 		FRDS, // xfloat_tag last
 
+		CFLTS,
+		CFLTU,
+		FCEQ,
+		FCMEQ,
+		FCGT,
+		FCMGT, // floating_tag last
+		FSCRWR,
+		FSCRRD,
+
 		DFA,
 		DFS,
 		DFM,
@@ -167,20 +176,11 @@ struct spu_itype
 		DFNMA,
 		FESD,
 
-		CFLTS,
-		CFLTU,
-		FCEQ,
-		FCMEQ,
-		FCGT,
-		FCMGT,
-		FSCRWR,
-		FSCRRD,
-
 		DFCEQ,
 		DFCMEQ,
 		DFCGT,
 		DFCMGT,
-		DFTSV, // floating_tag last
+		DFTSV,
 
 		SHLH, // shiftrot_tag first
 		SHLHI,
@@ -248,10 +248,10 @@ struct spu_itype
 		return value >= BR && value <= BISL;
 	}
 
-	// Test for floating point instruction
+	// Test for floating point instruction (32-bit float)
 	friend constexpr bool operator &(type value, floating_tag)
 	{
-		return value >= FMA && value <= DFTSV;
+		return value >= FMA && value <= FCMGT;
 	}
 
 	// Test for 4-op instruction
diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index eff272753a..9da576f009 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -3933,7 +3933,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 			const auto type = g_spu_itype.decode(op.opcode);
 
-			u8 reg_save = 255;
+			u8 reg_save = s_reg_max;
 
 			if (type == spu_itype::STQD && op.ra == s_reg_sp && !block.reg_mod[op.rt] && !block.reg_use[op.rt])
 			{
@@ -3953,7 +3953,12 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					// Register reg use only if it happens before reg mod
 					if (!block.reg_mod[reg])
 					{
-						block.reg_use.set(reg);
+						if (type & spu_itype::floating)
+						{
+							block.reg_maybe_float.set(reg);
+						}
+
+						block.reg_use[reg]++;
 
 						if (reg_save != reg && block.reg_save_dom[reg])
 						{
@@ -3970,7 +3975,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				for (u8 reg : {s_reg_mfc_lsa, s_reg_mfc_tag, s_reg_mfc_size})
 				{
 					if (!block.reg_mod[reg])
-						block.reg_use.set(reg);
+						block.reg_use[reg]++;
 				}
 			}
 
@@ -4024,7 +4029,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 						if (i == s_reg_lr || (i >= 2 && i < s_reg_80) || i > s_reg_127)
 						{
 							if (!block.reg_mod[i])
-								block.reg_use.set(i);
+								block.reg_use[i]++;
 
 							if (!is_tail)
 							{
@@ -6353,9 +6358,9 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 					if (!reduced_loop->loop_dicts.test(i))
 					{
-						if (b.reg_use.test(i) || (!b.reg_mod.test(i) && b2.reg_use.test(i)))
+						if (b.reg_use[i] || (!b.reg_mod.test(i) && b2.reg_use[i]))
 						{
-							if ((b.reg_use.test(i) && b.reg_mod.test(i)) || b2.reg_mod.test(i))
+							if ((b.reg_use[i] && b.reg_mod.test(i)) || b2.reg_mod.test(i))
 							{
 								reduced_loop->is_constant_expression = false;
 								reduced_loop->loop_writes.set(i);
@@ -7032,9 +7037,9 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 						if (!reduced_loop->loop_dicts.test(i))
 						{
-							if (b.reg_use.test(i) || (!b.reg_mod.test(i) && b2.reg_use.test(i)))
+							if (b.reg_use[i] || (!b.reg_mod.test(i) && b2.reg_use[i]))
 							{
-								if ((b.reg_use.test(i) && b.reg_mod.test(i)) || b2.reg_mod.test(i))
+								if ((b.reg_use[i] && b.reg_mod.test(i)) || b2.reg_mod.test(i))
 								{
 									reduced_loop->is_constant_expression = false;
 									reduced_loop->loop_writes.set(i);
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 4348e7e08a..00d89127d6 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -739,8 +739,11 @@ protected:
 		// Set if the initial register value in this block may be xfloat
 		std::bitset<s_reg_max> reg_maybe_xf{};
 
-		// Bit mask of the registers used (before modified)
-		std::bitset<s_reg_max> reg_use{};
+		// Set if register is used in floating pont instruction
+		std::bitset<s_reg_max> reg_maybe_float{};
+
+		// Number of times registers are used (before modified)
+		std::array<u32, s_reg_max> reg_use{};
 
 		// Bit mask of the trivial (u32 x 4) constant value resulting in this block
 		std::bitset<s_reg_max> reg_const{};

From 37a07ae5451273fa101687784f9df8b8b4603557 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Sun, 8 Mar 2026 15:36:58 +0200
Subject: [PATCH 37/98] SPU LLVM: Optimize FM, FMA and FCGT in Reduced Loop

---
 rpcs3/Emu/CPU/CPUTranslator.h          |  32 ++++++
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp |   5 +
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp   | 130 ++++++++++++++++---------
 rpcs3/Emu/Cell/SPURecompiler.h         |   3 +
 4 files changed, 124 insertions(+), 46 deletions(-)

diff --git a/rpcs3/Emu/CPU/CPUTranslator.h b/rpcs3/Emu/CPU/CPUTranslator.h
index 4a0028c571..738932808d 100644
--- a/rpcs3/Emu/CPU/CPUTranslator.h
+++ b/rpcs3/Emu/CPU/CPUTranslator.h
@@ -567,6 +567,32 @@ struct llvm_placeholder_t
 	}
 };
 
+template <typename T, typename U = llvm_common_t<llvm_value_t<T>>>
+struct llvm_place_stealer_t
+{
+	// TODO: placeholder extracting actual constant values (u64, f64, vector, etc)
+
+	using type = T;
+
+	static constexpr bool is_ok = true;
+
+	llvm::Value* eval(llvm::IRBuilder<>*) const
+	{
+		return nullptr;
+	}
+
+	std::tuple<> match(llvm::Value*& value, llvm::Module*) const
+	{
+		if (value && value->getType() == llvm_value_t<T>::get_type(value->getContext()))
+		{
+			return {};
+		}
+
+		value = nullptr;
+		return {};
+	}
+};
+
 template <typename T, bool ForceSigned = false>
 struct llvm_const_int
 {
@@ -3227,6 +3253,12 @@ public:
 		return {};
 	}
 
+	template <typename T>
+	static llvm_place_stealer_t<T> match_stealer()
+	{
+		return {};
+	}
+
 	template <typename T>
 		requires requires { typename llvm_common_t<T>; }
 	static auto match_expr(llvm::Value* v, llvm::Module* _m, T&& expr)
diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 9da576f009..96d4afa95e 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -3958,6 +3958,11 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 							block.reg_maybe_float.set(reg);
 						}
 
+						if (type == spu_itype::SHUFB && reg == op.rc)
+						{
+							block.reg_maybe_shuffle_mask.set(reg);
+						}
+
 						block.reg_use[reg]++;
 
 						if (reg_save != reg && block.reg_save_dom[reg])
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 71217fb0bf..baecbd3135 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -175,6 +175,11 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 			const usz first_id = store_context_first_id[i];
 			return counter != 1 && first_id != umax && counter < first_id;
 		}
+
+		bool is_gpr_not_NaN_hint(u32 i) const noexcept
+		{
+			return block_wide_reg_store_elimination && bb->reg_maybe_float[i] && bb->reg_use[i] >= 3 && !bb->reg_mod[i];
+		}
 	};
 
 	struct function_info
@@ -1692,7 +1697,7 @@ public:
 
 		// Emit state check
 		const auto pstate = spu_ptr(&spu_thread::state);
-		m_ir->CreateCondBr(m_ir->CreateICmpNE(m_ir->CreateLoad(get_type<u32>(), pstate), m_ir->getInt32(0)), label_stop, label_test, m_md_unlikely);
+		m_ir->CreateCondBr(m_ir->CreateICmpNE(spu_context_attr(m_ir->CreateLoad(get_type<u32>(), pstate)), m_ir->getInt32(0)), label_stop, label_test, m_md_unlikely);
 
 		// Emit code check
 		u32 check_iterations = 0;
@@ -6915,8 +6920,13 @@ public:
 		return eval(bitcast<f32[4]>(min(bitcast<u32[4]>(v),splat<u32[4]>(0xff7fffff))));
 	}
 
-	value_t<f32[4]> clamp_smax(value_t<f32[4]> v)
+	value_t<f32[4]> clamp_smax(value_t<f32[4]> v, u32 gpr = s_reg_max)
 	{
+		if (m_block && gpr < s_reg_max && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(gpr))
+		{
+			return v;
+		}
+
 		if (m_use_avx512)
 		{
 			if (is_input_positive(v))
@@ -6936,16 +6946,6 @@ public:
 		return eval(clamp_positive_smax(clamp_negative_smax(v)));
 	}
 
-	// FMA favouring zeros
-	value_t<f32[4]> xmuladd(value_t<f32[4]> a, value_t<f32[4]> b, value_t<f32[4]> c)
-	{
-		const auto ma = eval(sext<s32[4]>(fcmp_uno(a != fsplat<f32[4]>(0.))));
-		const auto mb = eval(sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.))));
-		const auto ca = eval(bitcast<f32[4]>(bitcast<s32[4]>(a) & mb));
-		const auto cb = eval(bitcast<f32[4]>(bitcast<s32[4]>(b) & ma));
-		return eval(fmuladd(ca, cb, c));
-	}
-
 	// Checks for postive and negative zero, or Denormal (treated as zero)
 	// If sign is +-1 check equality againts all sign bits
 	bool is_spu_float_zero(v128 a, int sign = 0)
@@ -7032,12 +7032,6 @@ public:
 		set_vr(op.rt, frsqest(get_vr<f32[4]>(op.ra)));
 	}
 
-	template <typename T, typename U>
-	static llvm_calli<s32[4], T, U> fcgt(T&& a, U&& b)
-	{
-		return {"spu_fcgt", {std::forward<T>(a), std::forward<U>(b)}};
-	}
-
 	void FCGT(spu_opcode_t op)
 	{
 		if (g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::accurate)
@@ -7046,11 +7040,8 @@ public:
 			return;
 		}
 
-		register_intrinsic("spu_fcgt", [&](llvm::CallInst* ci)
+		const auto fcgt = [&](value_t<f32[4]> a, value_t<f32[4]> b)
 		{
-			const auto a = value<f32[4]>(ci->getOperand(0));
-			const auto b = value<f32[4]>(ci->getOperand(1));
-
 			const value_t<f32[4]> ab[2]{a, b};
 
 			std::bitset<2> safe_int_compare(0);
@@ -7082,6 +7073,16 @@ public:
 				}
 			}
 
+			if (m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.ra))
+			{
+				safe_finite_compare.set(0);
+			}
+
+			if (m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.rb))
+			{
+				safe_finite_compare.set(1);
+			}
+
 			if (safe_int_compare.any())
 			{
 				return eval(sext<s32[4]>(bitcast<s32[4]>(a) > bitcast<s32[4]>(b)));
@@ -7101,7 +7102,7 @@ public:
 			const auto bi = eval(bitcast<s32[4]>(b));
 
 			return eval(sext<s32[4]>(fcmp_uno(a != b) & select((ai & bi) >= 0, ai > bi, ai < bi)));
-		});
+		};
 
 		set_vr(op.rt, fcgt(get_vr<f32[4]>(op.ra), get_vr<f32[4]>(op.rb)));
 	}
@@ -7198,12 +7199,6 @@ public:
 		set_vr(op.rt, fa(get_vr<f32[4]>(op.ra), get_vr<f32[4]>(op.rb)));
 	}
 
-	template <typename T, typename U>
-	static llvm_calli<f32[4], T, U> fs(T&& a, U&& b)
-	{
-		return {"spu_fs", {std::forward<T>(a), std::forward<U>(b)}};
-	}
-
 	void FS(spu_opcode_t op)
 	{
 		if (g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::accurate)
@@ -7212,29 +7207,26 @@ public:
 			return;
 		}
 
-		register_intrinsic("spu_fs", [&](llvm::CallInst* ci)
+		const auto fs = [&](value_t<f32[4]> a, value_t<f32[4]> b)
 		{
-			const auto a = value<f32[4]>(ci->getOperand(0));
-			const auto b = value<f32[4]>(ci->getOperand(1));
-
 			if (g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::approximate)
 			{
-				const auto bc = clamp_smax(b); // for #4478
+				const auto bc = clamp_smax(b, op.rb); // for #4478
 				return eval(a - bc);
 			}
 			else
 			{
 				return eval(a - b);
 			}
-		});
+		};
 
 		set_vr(op.rt, fs(get_vr<f32[4]>(op.ra), get_vr<f32[4]>(op.rb)));
 	}
 
-	template <typename T, typename U>
-	static llvm_calli<f32[4], T, U> fm(T&& a, U&& b)
+	template <typename T, typename U, typename V = llvm_place_stealer_t<u32>, typename W = llvm_place_stealer_t<u32>>
+	static auto fm(T&& a, U&& b, V&& a_not_nan = match_stealer<u32>(), W&& b_not_nan = match_stealer<u32>())
 	{
-		return llvm_calli<f32[4], T, U>{"spu_fm", {std::forward<T>(a), std::forward<U>(b)}}.set_order_equality_hint(1, 1);
+		return llvm_calli<f32[4], T, U, V, W>{"spu_fm", {std::forward<T>(a), std::forward<U>(b), a_not_nan, b_not_nan}}.set_order_equality_hint(1, 1, 2, 3);
 	}
 
 	void FM(spu_opcode_t op)
@@ -7249,14 +7241,27 @@ public:
 		{
 			const auto a = value<f32[4]>(ci->getOperand(0));
 			const auto b = value<f32[4]>(ci->getOperand(1));
+			const bool a_notnan = llvm::cast<llvm::ConstantInt>(ci->getOperand(2))->getZExtValue() != 0;
+			const bool b_notnan = llvm::cast<llvm::ConstantInt>(ci->getOperand(3))->getZExtValue() != 0;
 
 			if (g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::approximate)
 			{
-				if (a.value == b.value)
+				if (a.value == b.value || (a_notnan && b_notnan))
 				{
 					return eval(a * b);
 				}
 
+				if (a_notnan)
+				{
+					const auto ma = sext<s32[4]>(fcmp_uno(a != fsplat<f32[4]>(0.)));
+					return eval(bitcast<f32[4]>(bitcast<s32[4]>(a * b) & ma));
+				}
+				else if (b_notnan)
+				{
+					const auto mb = sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.)));
+					return eval(bitcast<f32[4]>(bitcast<s32[4]>(a * b) & mb));
+				}
+
 				const auto ma = sext<s32[4]>(fcmp_uno(a != fsplat<f32[4]>(0.)));
 				const auto mb = sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.)));
 				return eval(bitcast<f32[4]>(bitcast<s32[4]>(a * b) & ma & mb));
@@ -7267,10 +7272,13 @@ public:
 			}
 		});
 
+		const u32 a_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.ra) ? 1 : 0;
+		const u32 b_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.rb) ? 1 : 0;
+
 		if (op.ra == op.rb && !m_interp_magn)
 		{
 			const auto a = get_vr<f32[4]>(op.ra);
-			set_vr(op.rt, fm(a, a));
+			set_vr(op.rt, fm(a, a, splat<u32>(a_notnan), splat<u32>(a_notnan)));
 			return;
 		}
 
@@ -7309,7 +7317,7 @@ public:
 			}
 		}
 
-		set_vr(op.rt, fm(a, b));
+		set_vr(op.rt, fm(a, b, splat<u32>(a_notnan), splat<u32>(b_notnan)));
 	}
 
 	template <typename T>
@@ -7602,10 +7610,10 @@ public:
 		set_vr(op.rt4, fnms(get_vr<f32[4]>(op.ra), get_vr<f32[4]>(op.rb), get_vr<f32[4]>(op.rc)));
 	}
 
-	template <typename T, typename U, typename V>
-	static llvm_calli<f32[4], T, U, V> fma(T&& a, U&& b, V&& c)
+	template <typename T, typename U, typename V, typename W = llvm_place_stealer_t<u32>, typename X = llvm_place_stealer_t<u32>>
+	static llvm_calli<f32[4], T, U, V, W, X> fma(T&& a, U&& b, V&& c, W&& d = match_stealer<u32>(), X&& e = match_stealer<u32>())
 	{
-		return llvm_calli<f32[4], T, U, V>{"spu_fma", {std::forward<T>(a), std::forward<U>(b), std::forward<V>(c)}}.set_order_equality_hint(1, 1, 0);
+		return llvm_calli<f32[4], T, U, V, W, X>{"spu_fma", {std::forward<T>(a), std::forward<U>(b), std::forward<V>(c), std::forward<W>(d), std::forward<X>(e)}}.set_order_equality_hint(1, 1, 2, 3, 4);
 	}
 
 	template <typename T, typename U>
@@ -7624,14 +7632,35 @@ public:
 			return;
 		}
 
+		
 		register_intrinsic("spu_fma", [&](llvm::CallInst* ci)
 		{
 			const auto a = value<f32[4]>(ci->getOperand(0));
 			const auto b = value<f32[4]>(ci->getOperand(1));
 			const auto c = value<f32[4]>(ci->getOperand(2));
-
+			const bool a_notnan = llvm::cast<llvm::ConstantInt>(ci->getOperand(3))->getZExtValue() != 0;
+			const bool b_notnan = llvm::cast<llvm::ConstantInt>(ci->getOperand(4))->getZExtValue() != 0;
+			
 			if (g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::approximate)
 			{
+				if (a.value == b.value || (a_notnan && b_notnan))
+				{
+					return fma32x4(a, b, c);
+				}
+
+				if (a_notnan)
+				{
+					const auto ma = sext<s32[4]>(fcmp_uno(a != fsplat<f32[4]>(0.)));
+					const auto cb = bitcast<f32[4]>(bitcast<s32[4]>(b) & ma);
+					return fma32x4(a, eval(cb), c);
+				}
+				else if (b_notnan)
+				{
+					const auto mb = sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.)));
+					const auto ca = bitcast<f32[4]>(bitcast<s32[4]>(a) & mb);
+					return fma32x4(eval(ca), b, c);
+				}
+
 				const auto ma = sext<s32[4]>(fcmp_uno(a != fsplat<f32[4]>(0.)));
 				const auto mb = sext<s32[4]>(fcmp_uno(b != fsplat<f32[4]>(0.)));
 				const auto ca = bitcast<f32[4]>(bitcast<s32[4]>(a) & mb);
@@ -7680,6 +7709,9 @@ public:
 		const auto [a, b, c] = get_vrs<f32[4]>(op.ra, op.rb, op.rc);
 		static const auto MT = match<f32[4]>();
 
+		const u32 a_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.ra) ? 1 : 0;
+		const u32 b_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.rb) ? 1 : 0;
+
 		auto check_sqrt_pattern_for_float = [&](f32 float_value) -> bool
 		{
 			auto match_fnms = [&](f32 float_value)
@@ -7875,7 +7907,13 @@ public:
 			spu_log.todo("[%s:0x%05x] Unmatched spu_rsqrte(c) found in FMA", m_hash, m_pos);
 		}
 
-		set_vr(op.rt4, fma(a, b, c));
+		if (!m_interp_magn && op.ra == op.rb)
+		{
+			set_vr(op.rt4, fma(a, a, c, splat<u32>(a_notnan), splat<u32>(a_notnan)));
+			return;
+		}
+
+		set_vr(op.rt4, fma(a, b, c, splat<u32>(a_notnan), splat<u32>(b_notnan)));
 	}
 
 	template <typename T, typename U, typename V>
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 00d89127d6..1fd295f2f6 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -742,6 +742,9 @@ protected:
 		// Set if register is used in floating pont instruction
 		std::bitset<s_reg_max> reg_maybe_float{};
 
+		// Set if register is used as shuffle mask
+		std::bitset<s_reg_max> reg_maybe_shuffle_mask{};
+
 		// Number of times registers are used (before modified)
 		std::array<u32, s_reg_max> reg_use{};
 

From 619fe7b14e102119795eb1fd6e183aeb32c225cd Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Tue, 10 Mar 2026 17:13:44 +0200
Subject: [PATCH 38/98] SPU LLVM: Classify SPU memory and context memory
 instructions

---
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp | 65 +++++++++++++++++++++++++---
 1 file changed, 58 insertions(+), 7 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index baecbd3135..9c543915bf 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -132,6 +132,8 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 	llvm::MDNode* m_md_unlikely;
 	llvm::MDNode* m_md_likely;
+	llvm::MDNode* m_md_spu_memory_domain;
+	llvm::MDNode* m_md_spu_context_domain;
 
 	struct block_info
 	{
@@ -555,6 +557,40 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 		return _ptr(m_thread, ::offset32(offset_args...));
 	}
 
+	template <typename T>
+	T* spu_mem_attr(T* inst)
+	{
+		if (auto load_inst = llvm::dyn_cast<llvm::LoadInst>(inst))
+		{
+			load_inst->setMetadata(llvm::LLVMContext::MD_noalias, m_md_spu_context_domain);
+			load_inst->setMetadata(llvm::LLVMContext::MD_alias_scope, m_md_spu_memory_domain);
+		}
+		else if (auto store_inst = llvm::dyn_cast<llvm::StoreInst>(inst))
+		{
+			store_inst->setMetadata(llvm::LLVMContext::MD_noalias, m_md_spu_context_domain);
+			store_inst->setMetadata(llvm::LLVMContext::MD_alias_scope, m_md_spu_memory_domain);
+		}
+
+		return inst;
+	}
+
+	template <typename T>
+	T* spu_context_attr(T* inst)
+	{
+		if (auto load_inst = llvm::dyn_cast<llvm::LoadInst>(inst))
+		{
+			load_inst->setMetadata(llvm::LLVMContext::MD_alias_scope, m_md_spu_context_domain);
+			load_inst->setMetadata(llvm::LLVMContext::MD_noalias, m_md_spu_memory_domain);
+		}
+		else if (auto store_inst = llvm::dyn_cast<llvm::StoreInst>(inst))
+		{
+			store_inst->setMetadata(llvm::LLVMContext::MD_alias_scope, m_md_spu_context_domain);
+			store_inst->setMetadata(llvm::LLVMContext::MD_noalias, m_md_spu_memory_domain);
+		}
+
+		return inst;
+	}
+
 	// Return default register type
 	llvm::Type* get_reg_type(u32 index)
 	{
@@ -722,6 +758,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 			// Load register value if necessary
 			reg = m_finfo && m_finfo->load[index] ? m_finfo->load[index] : m_ir->CreateLoad(get_reg_type(index), init_reg_fixed(index));
+			spu_context_attr(reg);
 		}
 
 		if (reg->getType() == get_type<f64[4]>())
@@ -955,6 +992,8 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 		// Write register to the context
 		_store = m_ir->CreateStore(is_xfloat ? double_to_xfloat(saved_value) : m_ir->CreateBitCast(value, get_reg_type(index)), addr);
+
+		spu_context_attr(_store);
 	}
 
 	template <typename T, uint I>
@@ -1065,7 +1104,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 	// Update PC for current or explicitly specified instruction address
 	void update_pc(u32 target = -1)
 	{
-		m_ir->CreateStore(m_ir->CreateAnd(get_pc(target + 1 ? target : m_pos), 0x3fffc), spu_ptr(&spu_thread::pc))->setVolatile(true);
+		spu_context_attr(m_ir->CreateStore(m_ir->CreateAnd(get_pc(target + 1 ? target : m_pos), 0x3fffc), spu_ptr(&spu_thread::pc)))->setVolatile(true);
 	}
 
 	// Call cpu_thread::check_state if necessary and return or continue (full check)
@@ -1074,7 +1113,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 		const auto pstate = spu_ptr(&spu_thread::state);
 		const auto _body = llvm::BasicBlock::Create(m_context, "", m_function);
 		const auto check = llvm::BasicBlock::Create(m_context, "", m_function);
-		m_ir->CreateCondBr(m_ir->CreateICmpEQ(m_ir->CreateLoad(get_type<u32>(), pstate, true), m_ir->getInt32(0)), _body, check, m_md_likely);
+		m_ir->CreateCondBr(m_ir->CreateICmpEQ(spu_context_attr(m_ir->CreateLoad(get_type<u32>(), pstate, true)), m_ir->getInt32(0)), _body, check, m_md_likely);
 		m_ir->SetInsertPoint(check);
 		update_pc(addr);
 
@@ -1085,14 +1124,14 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 		if (may_be_unsafe_for_savestate)
 		{
-			m_ir->CreateStore(m_ir->getInt8(1), spu_ptr(&spu_thread::unsavable))->setVolatile(true);
+			spu_context_attr(m_ir->CreateStore(m_ir->getInt8(1), spu_ptr(&spu_thread::unsavable)))->setVolatile(true);
 		}
 
 		m_ir->CreateCall(m_test_state, {m_thread});
 
 		if (may_be_unsafe_for_savestate)
 		{
-			m_ir->CreateStore(m_ir->getInt8(0), spu_ptr(&spu_thread::unsavable))->setVolatile(true);
+			spu_context_attr(m_ir->CreateStore(m_ir->getInt8(0), spu_ptr(&spu_thread::unsavable)))->setVolatile(true);
 		}
 
 		m_ir->CreateBr(_body);
@@ -1528,6 +1567,16 @@ public:
 			m_md_likely = llvm::MDTuple::get(m_context, {md_name, md_high, md_low});
 			m_md_unlikely = llvm::MDTuple::get(m_context, {md_name, md_low, md_high});
 
+			const auto domain = llvm::MDNode::getDistinct(m_context, {llvm::MDString::get(m_context, "SPU_mem")});
+			const auto scope = llvm::MDNode::get(m_context, {llvm::MDString::get(m_context, "SPU_mem_scope"), domain}); 
+
+			m_md_spu_memory_domain = llvm::MDNode::get(m_context, scope);
+
+			const auto domain2 = llvm::MDNode::getDistinct(m_context, {llvm::MDString::get(m_context, "SPU_ctx")});
+			const auto scope2 = llvm::MDNode::get(m_context, {llvm::MDString::get(m_context, "SPU_ctx_scope"), domain2}); 
+
+			m_md_spu_context_domain = llvm::MDNode::get(m_context, scope2);
+
 			// Initialize transform passes
 			clear_transforms();
 #ifdef ARCH_ARM64
@@ -3175,6 +3224,8 @@ public:
 
 									m_ir->SetInsertPoint(ins);
 									auto si = llvm::cast<StoreInst>(m_ir->Insert(bs->clone()));
+									spu_context_attr(si);
+
 									if (b2->store[i] == nullptr)
 									{
 										// Protect against backwards ordering now
@@ -3240,7 +3291,7 @@ public:
 										continue;
 
 									m_ir->SetInsertPoint(ins);
-									m_ir->Insert(bs->clone());
+									m_ir->Insert(spu_context_attr(bs->clone()));
 								}
 
 								bs->eraseFromParent();
@@ -8336,13 +8387,13 @@ public:
 	void make_store_ls(value_t<u64> addr, value_t<u8[16]> data)
 	{
 		const auto bswapped = byteswap(data);
-		m_ir->CreateStore(bswapped.eval(m_ir), _ptr(m_lsptr, addr.value));
+		spu_mem_attr(m_ir->CreateStore(bswapped.eval(m_ir), _ptr(m_lsptr, addr.value)));
 	}
 
 	auto make_load_ls(value_t<u64> addr)
 	{
 		value_t<u8[16]> data;
-		data.value = m_ir->CreateLoad(get_type<u8[16]>(), _ptr(m_lsptr, addr.value));
+		data.value = spu_mem_attr(m_ir->CreateLoad(get_type<u8[16]>(), _ptr(m_lsptr, addr.value)));
 		return byteswap(data);
 	}
 

From e83034624b58a22d644213b26735a2934e13658c Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Wed, 11 Mar 2026 16:11:45 +0200
Subject: [PATCH 39/98] SPU Debugger: Measure rate of block ran

---
 rpcs3/Emu/CPU/CPUThread.cpp      |  7 ++--
 rpcs3/Emu/CPU/CPUThread.h        |  2 +-
 rpcs3/Emu/Cell/PPUThread.cpp     |  9 ++---
 rpcs3/Emu/Cell/PPUThread.h       |  2 +-
 rpcs3/Emu/Cell/SPUThread.cpp     | 59 +++++++++++++++++++++++++++++---
 rpcs3/Emu/Cell/SPUThread.h       |  2 +-
 rpcs3/Emu/RSX/RSXThread.cpp      |  6 ++--
 rpcs3/Emu/RSX/RSXThread.h        |  2 +-
 rpcs3/rpcs3qt/debugger_frame.cpp |  5 ++-
 rpcs3/rpcs3qt/debugger_frame.h   |  2 ++
 10 files changed, 73 insertions(+), 23 deletions(-)

diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp
index 3ab011aa04..eb6f3498a2 100644
--- a/rpcs3/Emu/CPU/CPUThread.cpp
+++ b/rpcs3/Emu/CPU/CPUThread.cpp
@@ -1322,8 +1322,9 @@ extern std::shared_ptr<CPUDisAsm> make_disasm(const cpu_thread* cpu, shared_ptr<
 void cpu_thread::dump_all(std::string& ret) const
 {
 	std::any func_data;
+	std::any misc_data;
 
-	ret += dump_misc();
+	dump_misc(ret, misc_data);
 	ret += '\n';
 	dump_regs(ret, func_data);
 	ret += '\n';
@@ -1371,9 +1372,9 @@ std::vector<std::pair<u32, u32>> cpu_thread::dump_callstack_list() const
 	return {};
 }
 
-std::string cpu_thread::dump_misc() const
+void cpu_thread::dump_misc(std::string& ret, std::any& /*custom_data*/) const
 {
-	return fmt::format("%s[0x%x]; State: %s\n", get_class() == thread_class::ppu ? "PPU" : get_class() == thread_class::spu ? "SPU" : "RSX", id, state.load());
+	fmt::append(ret, "%s[0x%x]; State: %s\n", get_class() == thread_class::ppu ? "PPU" : get_class() == thread_class::spu ? "SPU" : "RSX", id, state.load());
 }
 
 bool cpu_thread::suspend_work::push(cpu_thread* _this) noexcept
diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h
index 5e3484f7f5..88995f5e3b 100644
--- a/rpcs3/Emu/CPU/CPUThread.h
+++ b/rpcs3/Emu/CPU/CPUThread.h
@@ -176,7 +176,7 @@ public:
 	virtual std::vector<std::pair<u32, u32>> dump_callstack_list() const;
 
 	// Get CPU dump of misc information
-	virtual std::string dump_misc() const;
+	virtual void dump_misc(std::string& ret, std::any& /*custom_data*/) const;
 
 	// Thread entry point function
 	virtual void cpu_task() = 0;
diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp
index 4d690b344d..0062bc2825 100644
--- a/rpcs3/Emu/Cell/PPUThread.cpp
+++ b/rpcs3/Emu/Cell/PPUThread.cpp
@@ -1364,9 +1364,7 @@ void ppu_thread::dump_regs(std::string& ret, std::any& custom_data) const
 		u32 preferred_cr_field_index = 7;
 	};
 
-	dump_registers_data_t* func_data = nullptr;
-
-	func_data = std::any_cast<dump_registers_data_t>(&custom_data);
+	dump_registers_data_t* func_data = std::any_cast<dump_registers_data_t>(&custom_data);
 
 	if (!func_data)
 	{
@@ -2039,9 +2037,9 @@ std::vector<std::pair<u32, u32>> ppu_thread::dump_callstack_list() const
 	return call_stack_list;
 }
 
-std::string ppu_thread::dump_misc() const
+void ppu_thread::dump_misc(std::string& ret, std::any& custom_data) const
 {
-	std::string ret = cpu_thread::dump_misc();
+	cpu_thread::dump_misc(ret, custom_data);
 
 	if (ack_suspend)
 	{
@@ -2096,7 +2094,6 @@ std::string ppu_thread::dump_misc() const
 	{
 		ret += '\n';
 	}
-	return ret;
 }
 
 void ppu_thread::dump_all(std::string& ret) const
diff --git a/rpcs3/Emu/Cell/PPUThread.h b/rpcs3/Emu/Cell/PPUThread.h
index 97c705aed5..cf5b91c487 100644
--- a/rpcs3/Emu/Cell/PPUThread.h
+++ b/rpcs3/Emu/Cell/PPUThread.h
@@ -145,7 +145,7 @@ public:
 	virtual void dump_regs(std::string&, std::any& custom_data) const override;
 	virtual std::string dump_callstack() const override;
 	virtual std::vector<std::pair<u32, u32>> dump_callstack_list() const override;
-	virtual std::string dump_misc() const override;
+	virtual void dump_misc(std::string& ret, std::any& custom_data) const override;
 	virtual void dump_all(std::string&) const override;
 	virtual void cpu_task() override final;
 	virtual void cpu_sleep() override;
diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp
index e4346bc3df..60e0f99cca 100644
--- a/rpcs3/Emu/Cell/SPUThread.cpp
+++ b/rpcs3/Emu/Cell/SPUThread.cpp
@@ -1139,11 +1139,62 @@ std::vector<std::pair<u32, u32>> spu_thread::dump_callstack_list() const
 	return call_stack_list;
 }
 
-std::string spu_thread::dump_misc() const
+void spu_thread::dump_misc(std::string& ret, std::any& custom_data) const
 {
-	std::string ret = cpu_thread::dump_misc();
+	cpu_thread::dump_misc(ret, custom_data);
 
-	fmt::append(ret, "Block Weight: %u (Retreats: %u)", block_counter, block_failure);
+	struct dump_misc_data_t
+	{
+		u32 cpu_id = umax;
+		u64 last_read_time = umax;
+		u64 last_block_counter = umax;
+		u64 update_count = 0;
+
+		std::pair<u64, u64> update(u64 current_block_counter, u64 current_timestamp = get_system_time())
+		{
+			const u64 diff_time = current_timestamp <= last_read_time ? 0 : current_timestamp - last_read_time;
+			const u64 diff_block = current_block_counter <= last_block_counter ? 0 : current_block_counter - last_block_counter;
+
+			if (last_read_time == umax || update_count >= 1000)
+			{
+				last_read_time = current_timestamp;
+				last_block_counter = current_block_counter;
+				update_count = 0;
+			}
+			else if (diff_time >= 100000 && diff_block >= 100)
+			{
+				// Update values to measure rate (but not fully so rate can be measured later)
+				last_read_time += diff_time / 10 * 9;
+				last_block_counter += diff_block / 10 * 9;
+				update_count++;
+			}
+
+			return {diff_time, diff_block};
+		}
+	};
+
+	dump_misc_data_t* func_data = std::any_cast<dump_misc_data_t>(&custom_data);
+
+	if (!func_data)
+	{
+		custom_data.reset();
+		custom_data = std::make_any<dump_misc_data_t>();
+		func_data = ensure(std::any_cast<dump_misc_data_t>(&custom_data));
+	}
+
+	if (func_data->cpu_id != this->id)
+	{
+		*func_data = {};
+		func_data->cpu_id = this->id;
+	}
+
+	const u64 current_block_counter = atomic_storage<u64>::load(block_counter);
+
+	const auto [diff_time, diff_block] = func_data->update(current_block_counter);
+
+	const u64 rate_of_diff = diff_block ? std::max<u64>(1, utils::rational_mul<u64>(diff_block, 1'000'000, std::max<u64>(diff_time, 1))) : 0;
+
+	fmt::append(ret, "Block Weight: log10(%u/second): %.1f (Retreats: %u)", rate_of_diff, std::log10(std::max<u64>(rate_of_diff, 10)), block_failure);
 
 	if (u64 hash = atomic_storage<u64>::load(block_hash))
 	{
@@ -1194,8 +1245,6 @@ std::string spu_thread::dump_misc() const
 			break;
 		}
 	}
-
-	return ret;
 }
 
 void spu_thread::cpu_on_stop()
diff --git a/rpcs3/Emu/Cell/SPUThread.h b/rpcs3/Emu/Cell/SPUThread.h
index 9596f7b006..889d6f291c 100644
--- a/rpcs3/Emu/Cell/SPUThread.h
+++ b/rpcs3/Emu/Cell/SPUThread.h
@@ -630,7 +630,7 @@ public:
 	virtual void dump_regs(std::string&, std::any& custom_data) const override;
 	virtual std::string dump_callstack() const override;
 	virtual std::vector<std::pair<u32, u32>> dump_callstack_list() const override;
-	virtual std::string dump_misc() const override;
+	virtual void dump_misc(std::string& ret, std::any& custom_data) const override;
 	virtual void cpu_task() override final;
 	virtual void cpu_on_stop() override;
 	virtual void cpu_return() override;
diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp
index 6ffa8f2e9a..5158ce9a29 100644
--- a/rpcs3/Emu/RSX/RSXThread.cpp
+++ b/rpcs3/Emu/RSX/RSXThread.cpp
@@ -2774,9 +2774,9 @@ namespace rsx
 		recovered_fifo_cmds_history.push({fifo_ctrl->last_cmd(), current_time});
 	}
 
-	std::string thread::dump_misc() const
+	void thread::dump_misc(std::string& ret, std::any& custom_data) const
 	{
-		std::string ret = cpu_thread::dump_misc();
+		cpu_thread::dump_misc(ret, custom_data);
 
 		const auto flags = +state;
 
@@ -2789,8 +2789,6 @@ namespace rsx
 		{
 			fmt::append(ret, "\n");
 		}
-
-		return ret;
 	}
 
 	std::vector<std::pair<u32, u32>> thread::dump_callstack_list() const
diff --git a/rpcs3/Emu/RSX/RSXThread.h b/rpcs3/Emu/RSX/RSXThread.h
index cdeaa9f419..2438fc0f57 100644
--- a/rpcs3/Emu/RSX/RSXThread.h
+++ b/rpcs3/Emu/RSX/RSXThread.h
@@ -122,7 +122,7 @@ namespace rsx
 		std::unique_ptr<FIFO::FIFO_control> fifo_ctrl;
 		atomic_t<bool> rsx_thread_running{ false };
 		std::vector<std::pair<u32, u32>> dump_callstack_list() const override;
-		std::string dump_misc() const override;
+		void dump_misc(std::string& ret, std::any& custom_data) const override;
 
 	protected:
 		FIFO::flattening_helper m_flattener;
diff --git a/rpcs3/rpcs3qt/debugger_frame.cpp b/rpcs3/rpcs3qt/debugger_frame.cpp
index 0859e19856..db4efa1aae 100644
--- a/rpcs3/rpcs3qt/debugger_frame.cpp
+++ b/rpcs3/rpcs3qt/debugger_frame.cpp
@@ -1469,8 +1469,11 @@ void debugger_frame::WritePanels(cpu_thread* cpu)
 
 	int loc = m_misc_state->verticalScrollBar()->value();
 	int hloc = m_misc_state->horizontalScrollBar()->value();
+
+	m_last_misc_state.clear();
+	cpu->dump_misc(m_last_misc_state, m_dump_misc_func_data);
 	m_misc_state->clear();
-	m_misc_state->setPlainText(QString::fromStdString(cpu->dump_misc()));
+	m_misc_state->setPlainText(QString::fromStdString(m_last_misc_state));
 	m_misc_state->verticalScrollBar()->setValue(loc);
 	m_misc_state->horizontalScrollBar()->setValue(hloc);
 
diff --git a/rpcs3/rpcs3qt/debugger_frame.h b/rpcs3/rpcs3qt/debugger_frame.h
index eb22d74680..abe7ec11cc 100644
--- a/rpcs3/rpcs3qt/debugger_frame.h
+++ b/rpcs3/rpcs3qt/debugger_frame.h
@@ -69,7 +69,9 @@ class debugger_frame : public custom_dock_widget
 	u32 m_last_pc = -1;
 	std::vector<char> m_last_query_state;
 	std::string m_last_reg_state;
+	std::string m_last_misc_state;
 	std::any m_dump_reg_func_data;
+	std::any m_dump_misc_func_data;
 	std::vector<std::function<cpu_thread*()>> m_threads_info;
 	u32 m_last_step_over_breakpoint = -1;
 	u64 m_ui_update_ctr = 0;

From 9a0a5a1735d8f3cbfa95287ead33763effd8383f Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Mon, 16 Mar 2026 08:18:53 +0200
Subject: [PATCH 40/98] LLVM: Try to reuse BitCasts

---
 rpcs3/Emu/CPU/CPUTranslator.cpp      | 58 +++++++++++++++++++++++++++-
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp |  2 +-
 2 files changed, 57 insertions(+), 3 deletions(-)

diff --git a/rpcs3/Emu/CPU/CPUTranslator.cpp b/rpcs3/Emu/CPU/CPUTranslator.cpp
index 08e8e9ad30..22413f62b8 100644
--- a/rpcs3/Emu/CPU/CPUTranslator.cpp
+++ b/rpcs3/Emu/CPU/CPUTranslator.cpp
@@ -225,12 +225,66 @@ llvm::Value* cpu_translator::bitcast(llvm::Value* val, llvm::Type* type) const
 		fmt::throw_exception("cpu_translator::bitcast(): incompatible type sizes (%u vs %u)", s1, s2);
 	}
 
-	if (const auto c1 = llvm::dyn_cast<llvm::Constant>(val))
+	if (val->getType() == type)
+	{
+		return val;
+	}
+
+	llvm::CastInst* i;
+	llvm::Value* source_val = val;
+
+	// Try to reuse older bitcasts
+	while ((i = llvm::dyn_cast_or_null<llvm::CastInst>(source_val)) && i->getOpcode() == llvm::Instruction::BitCast)
+	{
+		source_val = i->getOperand(0);
+
+		if (source_val->getType() == type)
+		{
+			return source_val;
+		}
+	}
+
+	for (auto it = source_val->use_begin(); it != source_val->use_end(); ++it)
+	{
+		llvm::Value* it_val = *it;
+
+		if (!it_val)
+		{
+			continue;
+		}
+
+		llvm::CastInst* bci = llvm::dyn_cast_or_null<llvm::CastInst>(it_val);
+
+		// Walk through bitcasts
+		while (bci && bci->getOpcode() == llvm::Instruction::BitCast)
+		{
+			if (bci->getParent() != m_ir->GetInsertBlock())
+			{
+				break;
+			}
+
+			if (bci->getType() == type)
+			{
+				return bci;
+			}
+
+			if (bci->use_begin() == bci->use_end())
+			{
+				break;
+			}
+
+			bci = llvm::dyn_cast_or_null<llvm::CastInst>(*bci->use_begin());
+		}
+	}
+
+	// Do bitcast on the source
+
+	if (const auto c1 = llvm::dyn_cast<llvm::Constant>(source_val))
 	{
 		return ensure(llvm::ConstantFoldCastOperand(llvm::Instruction::BitCast, c1, type, m_module->getDataLayout()));
 	}
 
-	return m_ir->CreateBitCast(val, type);
+	return m_ir->CreateBitCast(source_val, type);
 }
 
 template <>
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 9c543915bf..7511b2ae7b 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -991,7 +991,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 		}
 
 		// Write register to the context
-		_store = m_ir->CreateStore(is_xfloat ? double_to_xfloat(saved_value) : m_ir->CreateBitCast(value, get_reg_type(index)), addr);
+		_store = m_ir->CreateStore(is_xfloat ? double_to_xfloat(saved_value) : bitcast(value, get_reg_type(index)), addr);
 
 		spu_context_attr(_store);
 	}

From 4ced11e5332ee415b06d7dec6ff533c7e1fd0af5 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Thu, 19 Mar 2026 10:49:55 +0200
Subject: [PATCH 41/98] SPU Analyzer: Add pure opcode tag

---
 rpcs3/Emu/Cell/SPUAnalyser.h | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/rpcs3/Emu/Cell/SPUAnalyser.h b/rpcs3/Emu/Cell/SPUAnalyser.h
index a6c788faad..1598551c7d 100644
--- a/rpcs3/Emu/Cell/SPUAnalyser.h
+++ b/rpcs3/Emu/Cell/SPUAnalyser.h
@@ -13,6 +13,7 @@ struct spu_itype
 	static constexpr struct quadrop_tag{} _quadrop{}; // 4-op Instructions
 	static constexpr struct xfloat_tag{} xfloat{}; // Instructions producing xfloat values
 	static constexpr struct zregmod_tag{} zregmod{}; // Instructions not modifying any GPR
+	static constexpr struct pure_tag{} pure{}; // Instructions that always produce the same values as long as arguments are equal
 
 	enum class type : unsigned char
 	{
@@ -301,6 +302,12 @@ struct spu_itype
 	{
 		return (value >= HEQ && value <= STQR) || (value >= BR && value <= BIHNZ);
 	}
+
+	// Test for instructions which always produce the same values as long as arguments and immediate values are equal
+	friend constexpr bool operator &(type value, pure_tag)
+	{
+		return (value >= ILH && value <= CLGTI);
+	}
 };
 
 using spu_itype_t = spu_itype::type;

From bb3e2689d4fa7ba43011ac98dae1b10a55807437 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Tue, 24 Mar 2026 19:47:32 +0200
Subject: [PATCH 42/98] Thread.cpp: Fix game exit on access violation

Fixes game closing in Twisted Metal.
This commit also aloows to debug such states by using cpu_flag::req_exit as a broker
---
 Utilities/Thread.cpp               | 87 +++++++++++++++++++++++-------
 rpcs3/Emu/CPU/CPUThread.cpp        | 12 ++++-
 rpcs3/Emu/CPU/CPUThread.h          |  3 +-
 rpcs3/Emu/Cell/Modules/cellGem.cpp |  6 +++
 rpcs3/Emu/System.cpp               | 14 +++--
 rpcs3/rpcs3qt/debugger_frame.cpp   | 11 ++--
 rpcs3/rpcs3qt/main_window.cpp      |  4 +-
 7 files changed, 107 insertions(+), 30 deletions(-)

diff --git a/Utilities/Thread.cpp b/Utilities/Thread.cpp
index 6395c32505..9514ed9cdf 100644
--- a/Utilities/Thread.cpp
+++ b/Utilities/Thread.cpp
@@ -107,7 +107,7 @@ thread_local u64 g_tls_fault_rsx = 0;
 thread_local u64 g_tls_fault_spu = 0;
 thread_local u64 g_tls_wait_time = 0;
 thread_local u64 g_tls_wait_fail = 0;
-thread_local bool g_tls_access_violation_recovered = false;
+thread_local u64 g_tls_access_violation_recovered = umax;
 extern thread_local std::string(*g_tls_log_prefix)();
 
 namespace stx
@@ -1269,7 +1269,7 @@ namespace rsx
 	extern std::function<bool(u32 addr, bool is_writing)> g_access_violation_handler;
 }
 
-bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noexcept
+bool handle_access_violation(u32 addr, bool is_writing, bool is_exec, ucontext_t* context) noexcept
 {
 	g_tls_fault_all++;
 
@@ -1305,7 +1305,7 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 		}
 	} spu_protection{cpu};
 
-	if (addr < RAW_SPU_BASE_ADDR && vm::check_addr(addr) && rsx::g_access_violation_handler)
+	if (!is_exec && addr < RAW_SPU_BASE_ADDR && vm::check_addr(addr) && rsx::g_access_violation_handler)
 	{
 		bool state_changed = false;
 
@@ -1371,7 +1371,7 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 	{
 		auto thread = idm::get_unlocked<named_thread<spu_thread>>(spu_thread::find_raw_spu((addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET));
 
-		if (!thread)
+		if (!thread || is_exec)
 		{
 			break;
 		}
@@ -1503,7 +1503,9 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 	static_cast<void>(context);
 #endif /* ARCH_ */
 
-	if (vm::check_addr(addr, is_writing ? vm::page_writable : vm::page_readable))
+	const auto required_page_perms = (is_writing ? vm::page_writable : vm::page_readable) + (is_exec ? vm::page_executable : 0);
+
+	if (vm::check_addr(addr, required_page_perms))
 	{
 		return true;
 	}
@@ -1511,9 +1513,7 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 	// Hack: allocate memory in case the emulator is stopping
 	const auto hack_alloc = [&]()
 	{
-		g_tls_access_violation_recovered = true;
-
-		if (vm::check_addr(addr, is_writing ? vm::page_writable : vm::page_readable))
+		if (vm::check_addr(addr, required_page_perms))
 		{
 			return true;
 		}
@@ -1525,17 +1525,45 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 			return false;
 		}
 
+		extern void ppu_register_range(u32 addr, u32 size);
+
+		bool reprotected = false;
+
 		if (vm::writer_lock mlock; area->flags & vm::preallocated || vm::check_addr(addr, 0))
 		{
 			// For allocated memory with protection lower than required (such as protection::no or read-only while writing to it)
 			utils::memory_protect(vm::base(addr & -0x1000), 0x1000, utils::protection::rw);
+			reprotected = true;
+		}
+
+		if (reprotected)
+		{
+			if (is_exec && !vm::check_addr(addr, vm::page_executable))
+			{
+				ppu_register_range(addr & -0x10000, 0x10000);
+			}
+
+			g_tls_access_violation_recovered = addr;
 			return true;
 		}
 
-		return area->falloc(addr & -0x10000, 0x10000) || vm::check_addr(addr, is_writing ? vm::page_writable : vm::page_readable);
+		const bool allocated = area->falloc(addr & -0x10000, 0x10000);
+
+		if (allocated)
+		{
+			if (is_exec && !vm::check_addr(addr, vm::page_executable))
+			{
+				ppu_register_range(addr & -0x10000, 0x10000);
+			}
+
+			g_tls_access_violation_recovered = addr;
+			return true;
+		}
+
+		return false;
 	};
 
-	if (cpu && (cpu->get_class() == thread_class::ppu || cpu->get_class() == thread_class::spu))
+	if (cpu && (cpu->get_class() == thread_class::ppu || cpu->get_class() == thread_class::spu) && !is_exec)
 	{
 		vm::temporary_unlock(*cpu);
 		u32 pf_port_id = 0;
@@ -1678,7 +1706,7 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 
 		if (cpu->get_class() == thread_class::spu)
 		{
-			if (!g_tls_access_violation_recovered)
+			if (g_tls_access_violation_recovered != addr)
 			{
 				vm_log.notice("\n%s", dump_useful_thread_info());
 				vm_log.always()("[%s] Access violation %s location 0x%x (%s)", cpu->get_name(), is_writing ? "writing" : "reading", addr, (is_writing && vm::check_addr(addr)) ? "read-only memory" : "unmapped memory");
@@ -1714,10 +1742,10 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 
 	// Note: a thread may access violate more than once after hack_alloc recovery
 	// Do not log any further access violations in this case.
-	if (!g_tls_access_violation_recovered)
+	if (g_tls_access_violation_recovered != addr)
 	{
 		vm_log.notice("\n%s", dump_useful_thread_info());
-		vm_log.fatal("Access violation %s location 0x%x (%s)", is_writing ? "writing" : (cpu && cpu->get_class() == thread_class::ppu && cpu->get_pc() == addr ? "executing" : "reading"), addr, (is_writing && vm::check_addr(addr)) ? "read-only memory" : "unmapped memory");
+		vm_log.fatal("Access violation %s location 0x%x (%s)", is_writing ? "writing" : (is_exec ? "executing" : "reading"), addr, (is_writing && vm::check_addr(addr)) ? "read-only memory" : "unmapped memory");
 	}
 
 	while (Emu.IsPausedOrReady())
@@ -1766,8 +1794,13 @@ bool handle_access_violation(u32 addr, bool is_writing, ucontext_t* context) noe
 		}
 	}
 
-	if (Emu.IsStopped() && !hack_alloc())
+	if (Emu.IsStopped())
 	{
+		while (!hack_alloc())
+		{
+			thread_ctrl::wait_for(1000);
+		}
+
 		return false;
 	}
 
@@ -1806,6 +1839,7 @@ static LONG exception_handler(PEXCEPTION_POINTERS pExp) noexcept
 	if (pExp->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && !is_executing)
 	{
 		u32 addr = 0;
+		bool is_exec = false;
 
 		if (auto [addr0, ok] = vm::try_get_addr(ptr); ok)
 		{
@@ -1813,14 +1847,21 @@ static LONG exception_handler(PEXCEPTION_POINTERS pExp) noexcept
 		}
 		else if (const usz exec64 = (ptr - vm::g_exec_addr) / 2; exec64 <= u32{umax})
 		{
+			is_exec = true;
 			addr = static_cast<u32>(exec64);
 		}
-		else
+		else if (const usz exec64 = (ptr - vm::g_exec_addr - vm::g_exec_addr_seg_offset); exec64 <= u32{umax})
 		{
+			is_exec = true;
+			addr = static_cast<u32>(exec64);
+		}
+		else 
+		{
+			std::this_thread::sleep_for(1ms);
 			return EXCEPTION_CONTINUE_SEARCH;
 		}
 
-		if (thread_ctrl::get_current() && handle_access_violation(addr, is_writing, pExp->ContextRecord))
+		if (thread_ctrl::get_current() && handle_access_violation(addr, is_writing, is_exec, pExp->ContextRecord))
 		{
 			return EXCEPTION_CONTINUE_EXECUTION;
 		}
@@ -2027,12 +2068,13 @@ static void signal_handler(int /*sig*/, siginfo_t* info, void* uct) noexcept
 #endif
 
 	const u64 exec64 = (reinterpret_cast<u64>(info->si_addr) - reinterpret_cast<u64>(vm::g_exec_addr)) / 2;
+	const u64 exec64_2 = (reinterpret_cast<u64>(info->si_addr) - reinterpret_cast<u64>(vm::g_exec_addr)) - vm::g_exec_addr_seg_offset;
 	const auto cause = is_executing ? "executing" : is_writing ? "writing" : "reading";
 
 	if (auto [addr, ok] = vm::try_get_addr(info->si_addr); ok && !is_executing)
 	{
 		// Try to process access violation
-		if (thread_ctrl::get_current() && handle_access_violation(addr, is_writing, context))
+		if (thread_ctrl::get_current() && handle_access_violation(addr, is_writing, false, context))
 		{
 			return;
 		}
@@ -2040,7 +2082,14 @@ static void signal_handler(int /*sig*/, siginfo_t* info, void* uct) noexcept
 
 	if (exec64 < 0x100000000ull && !is_executing)
 	{
-		if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(exec64), is_writing, context))
+		if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(exec64), is_writing, true, context))
+		{
+			return;
+		}
+	}
+	else if (exec64_2 < 0x100000000ull && !is_executing)
+	{
+		if (thread_ctrl::get_current() && handle_access_violation(static_cast<u32>(exec64_2), is_writing, true, context))
 		{
 			return;
 		}
@@ -2359,7 +2408,7 @@ thread_base::native_entry thread_base::finalize(u64 _self) noexcept
 	g_tls_fault_spu = 0;
 	g_tls_wait_time = 0;
 	g_tls_wait_fail = 0;
-	g_tls_access_violation_recovered = false;
+	g_tls_access_violation_recovered = umax;
 
 	g_tls_log_prefix = []() -> std::string { return {}; };
 
diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp
index eb6f3498a2..4bd5fc9157 100644
--- a/rpcs3/Emu/CPU/CPUThread.cpp
+++ b/rpcs3/Emu/CPU/CPUThread.cpp
@@ -888,6 +888,14 @@ bool cpu_thread::check_state() noexcept
 				store = true;
 			}
 
+			if (flags & cpu_flag::req_exit)
+			{
+				// A request for the thread to quit has been made
+				flags -= cpu_flag::req_exit;
+				flags += cpu_flag::exit;
+				store = true;
+			}
+
 			// Can't process dbg_step if we only paused temporarily
 			if (cpu_can_stop && flags & cpu_flag::dbg_step)
 			{
@@ -1157,13 +1165,13 @@ void cpu_thread::notify()
 
 cpu_thread& cpu_thread::operator=(thread_state)
 {
-	if (state & cpu_flag::exit)
+	if (state & (cpu_flag::exit + cpu_flag::req_exit))
 	{
 		// Must be notified elsewhere or self-raised
 		return *this;
 	}
 
-	const auto old = state.fetch_add(cpu_flag::exit);
+	const auto old = state.fetch_add(cpu_flag::req_exit);
 
 	if (old & cpu_flag::wait && old.none_of(cpu_flag::again + cpu_flag::exit))
 	{
diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h
index 88995f5e3b..e723fd2d4b 100644
--- a/rpcs3/Emu/CPU/CPUThread.h
+++ b/rpcs3/Emu/CPU/CPUThread.h
@@ -29,6 +29,7 @@ enum class cpu_flag : u32
 	yield, // Thread is being requested to yield its execution time if it's running
 	preempt, // Thread is being requested to preempt the execution of all CPU threads
 
+	req_exit, // Request the thread to exit
 	dbg_global_pause, // Emulation paused
 	dbg_pause, // Thread paused
 	dbg_step, // Thread forced to pause after one step (one instruction, etc)
@@ -39,7 +40,7 @@ enum class cpu_flag : u32
 // Test stopped state
 constexpr bool is_stopped(bs_t<cpu_flag> state)
 {
-	return !!(state & (cpu_flag::stop + cpu_flag::exit + cpu_flag::again));
+	return !!(state & (cpu_flag::stop + cpu_flag::exit + cpu_flag::again + cpu_flag::req_exit));
 }
 
 // Test paused state
diff --git a/rpcs3/Emu/Cell/Modules/cellGem.cpp b/rpcs3/Emu/Cell/Modules/cellGem.cpp
index d45dace1ca..f9f5ea4100 100644
--- a/rpcs3/Emu/Cell/Modules/cellGem.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellGem.cpp
@@ -1774,6 +1774,12 @@ public:
 
 	shared_mutex mutex;
 
+	gem_tracker& operator=(thread_state) noexcept
+	{
+		wake_up_tracker();
+		return *this;
+	}
+
 private:
 	atomic_t<u32> m_wake_up_tracker = 0;
 	atomic_t<u32> m_tracker_done = 0;
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index 42854504f7..7818bd20d5 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -49,6 +49,7 @@
 
 #include <memory>
 #include <regex>
+#include <shared_mutex>
 
 #include "Utilities/JIT.h"
 
@@ -3075,7 +3076,7 @@ void Emulator::GracefulShutdown(bool allow_autoexit, bool async_op, bool savesta
 		std::vector<stx::shared_ptr<named_thread<ppu_thread>>> ppu_thread_list;
 
 		// If EXITGAME signal is not read, force kill after a second.
-		constexpr int loop_timeout_ms = 50;
+		constexpr int loop_timeout_ms = 16;
 		int kill_timeout_ms = 1000;
 		int elapsed_ms = 0;
 
@@ -3092,8 +3093,10 @@ void Emulator::GracefulShutdown(bool allow_autoexit, bool async_op, bool savesta
 				Resume();
 			}, nullptr, true, read_counter);
 
+			std::shared_lock rlock(id_manager::g_mutex, std::defer_lock); 
+
 			// Check if the EXITGAME signal was read. We allow the game to terminate itself if that's the case.
-			if (!read_sysutil_signal && read_counter != get_sysutil_cb_manager_read_count())
+			if (!read_sysutil_signal && read_counter != get_sysutil_cb_manager_read_count() && rlock.try_lock())
 			{
 				sys_log.notice("The game received the exit request. Waiting for it to terminate itself...");
 				kill_timeout_ms += 5000; // Grant a couple more seconds
@@ -3103,7 +3106,12 @@ void Emulator::GracefulShutdown(bool allow_autoexit, bool async_op, bool savesta
 				idm::select<named_thread<ppu_thread>>([&](u32 id, cpu_thread&)
 				{
 					ppu_thread_list.emplace_back(idm::get_unlocked<named_thread<ppu_thread>>(id));
-				});
+				}, idm::unlocked);
+			}
+
+			if (rlock)
+			{
+				rlock.unlock();
 			}
 
 			if (static_cast<u64>(info) != m_stop_ctr || Emu.IsStopped())
diff --git a/rpcs3/rpcs3qt/debugger_frame.cpp b/rpcs3/rpcs3qt/debugger_frame.cpp
index db4efa1aae..b8ed1d642f 100644
--- a/rpcs3/rpcs3qt/debugger_frame.cpp
+++ b/rpcs3/rpcs3qt/debugger_frame.cpp
@@ -872,7 +872,7 @@ std::function<cpu_thread*()> debugger_frame::make_check_cpu(cpu_thread* cpu, boo
 {
 	constexpr cpu_thread* null_cpu = nullptr;
 
-	if (Emu.IsStopped())
+	if (Emu.IsStopped(true))
 	{
 		return []() { return null_cpu; };
 	}
@@ -921,7 +921,7 @@ std::function<cpu_thread*()> debugger_frame::make_check_cpu(cpu_thread* cpu, boo
 
 	return [cpu, type, shared = std::move(shared), emulation_id = Emu.GetEmulationIdentifier()]() mutable -> cpu_thread*
 	{
-		if (emulation_id != Emu.GetEmulationIdentifier() || Emu.IsStopped())
+		if (emulation_id != Emu.GetEmulationIdentifier() || Emu.IsStopped(true))
 		{
 			// Invalidate all data after Emu.Kill()
 			shared.reset();
@@ -1040,7 +1040,7 @@ void debugger_frame::UpdateUnitList()
 	const u64 emulation_id = static_cast<std::underlying_type_t<Emulator::stop_counter_t>>(Emu.GetEmulationIdentifier());
 	const u64 threads_created = cpu_thread::g_threads_created;
 	const u64 threads_deleted = cpu_thread::g_threads_deleted;
-	const system_state emu_state = Emu.GetStatus();
+	const system_state emu_state = Emu.GetStatus(false);
 
 	std::unique_lock<shared_mutex> lock{id_manager::g_mutex, std::defer_lock};
 
@@ -1077,6 +1077,11 @@ void debugger_frame::UpdateUnitList()
 	{
 		std::function<cpu_thread*()> func_cpu = make_check_cpu(std::addressof(cpu), true);
 
+		if (cpu.state & cpu_flag::exit)
+		{
+			return;
+		}
+
 		// Space at the end is to pad a gap on the right
 		cpu_list.emplace_back(QString::fromStdString((id >> 24 == 0x55 ? "RSX[0x55555555]" : cpu.get_name()) + ' '), std::move(func_cpu));
 
diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index 8f9324d73e..94157571e8 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -128,7 +128,7 @@ extern void qt_events_aware_op(int repeat_duration_ms, std::function<bool()> wra
 			}
 			else
 			{
-				QTimer::singleShot(repeat_duration_ms, *check_iteration);
+				QTimer::singleShot(repeat_duration_ms, event_loop, *check_iteration);
 			}
 		});
 
@@ -138,7 +138,7 @@ extern void qt_events_aware_op(int repeat_duration_ms, std::function<bool()> wra
 			event_loop = new QEventLoop();
 
 			// Queue event initially
-			QTimer::singleShot(0, *check_iteration);
+			QTimer::singleShot(0, event_loop, *check_iteration);
 
 			// Event loop
 			event_loop->exec();

From 72b872df661abb94e867f3d4e3003d4178ae3ae5 Mon Sep 17 00:00:00 2001
From: capriots <29807355+capriots@users.noreply.github.com>
Date: Fri, 27 Mar 2026 14:47:26 +0100
Subject: [PATCH 43/98] cellDmuxPamf: fix freezing FMVs in some games

- Delays demuxing a bit to let the game finish initializing FMV
playback.
- Also includes the missing half of #18450 which I forgot to Commit ^^"
- Sets cellDmuxPamf to HLE by default again
---
 rpcs3/Emu/Cell/Modules/cellAdec.cpp      | 86 ++++++++++++------------
 rpcs3/Emu/Cell/Modules/cellAdec.h        | 30 ++++-----
 rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp | 54 +++++++--------
 rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp  | 70 ++++++++++---------
 rpcs3/Emu/Cell/lv2/sys_prx.cpp           |  2 +-
 5 files changed, 123 insertions(+), 119 deletions(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellAdec.cpp b/rpcs3/Emu/Cell/Modules/cellAdec.cpp
index f5cb90be7e..0d0c4481e9 100644
--- a/rpcs3/Emu/Cell/Modules/cellAdec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellAdec.cpp
@@ -296,7 +296,7 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 
 		cmd_queue.pop(cmd);
 
-		ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex) == CELL_OK); // Error code isn't checked on LLE
 
 		cellAdec.trace("Command type: %d", static_cast<u32>(cmd.type.get()));
 
@@ -307,7 +307,7 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 		{
 		case LpcmDecCmdType::start_seq:
 			// LLE sends a command to the SPU thread. The SPU thread consumes the command without doing anything, however
-			error_occurred |= static_cast<u32>(sys_mutex_unlock(ppu, output_mutex) != CELL_OK);
+			error_occurred |= static_cast<u32>(lv2_syscall<sys_mutex_unlock>(ppu, output_mutex) != CELL_OK);
 			break;
 
 		case LpcmDecCmdType::end_seq:
@@ -324,11 +324,11 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 			// Doesn't do anything else
 			notify_seq_done.cbFunc(ppu, notify_seq_done.cbArg);
 
-			error_occurred |= static_cast<u32>(sys_mutex_unlock(ppu, output_mutex) != CELL_OK);
+			error_occurred |= static_cast<u32>(lv2_syscall<sys_mutex_unlock>(ppu, output_mutex) != CELL_OK);
 			break;
 		}
 		case LpcmDecCmdType::close:
-			ensure(sys_mutex_unlock(ppu, output_mutex) == CELL_OK); // Error code isn't checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, output_mutex) == CELL_OK); // Error code isn't checked on LLE
 			return;
 
 		case LpcmDecCmdType::decode_au:
@@ -685,7 +685,7 @@ void LpcmDecContext::exec(ppu_thread& ppu)
 			notify_au_done.cbFunc(ppu, cmd.pcm_handle, notify_au_done.cbArg);
 
 			output_locked = true;
-			error_occurred |= static_cast<u32>(sys_mutex_unlock(ppu, output_mutex) != CELL_OK);
+			error_occurred |= static_cast<u32>(lv2_syscall<sys_mutex_unlock>(ppu, output_mutex) != CELL_OK);
 
 			const vm::var<CellAdecLpcmInfo> bsi_info{{ lpcm_param->channelNumber, lpcm_param->sampleRate, static_cast<u32>(output_size) }};
 
@@ -710,7 +710,7 @@ error_code LpcmDecContext::send_command(ppu_thread& ppu, auto&&... args)
 
 	if (cmd_queue.full())
 	{
-		ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
 		return CELL_ADEC_ERROR_BUSY;
 	}
 
@@ -722,20 +722,20 @@ error_code LpcmDecContext::send_command(ppu_thread& ppu, auto&&... args)
 
 	if (error_code ret = lv2_syscall<sys_mutex_lock>(ppu, queue_mutex, 0); ret != CELL_OK)
 	{
-		ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
 		return ret;
 	}
 
 	cmd_queue.emplace(type, std::forward<decltype(args)>(args)...);
 
-	if (error_code ret = sys_mutex_unlock(ppu, queue_mutex); ret != CELL_OK
+	if (error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex); ret != CELL_OK
 		|| (ret = cmd_available.release(ppu)) != CELL_OK)
 	{
-		ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
 		return ret;
 	}
 
-	return sys_mutex_unlock(ppu, queue_size_mutex);
+	return lv2_syscall<sys_mutex_unlock>(ppu, queue_size_mutex);
 }
 
 inline error_code LpcmDecContext::release_output(ppu_thread& ppu)
@@ -752,7 +752,7 @@ inline error_code LpcmDecContext::release_output(ppu_thread& ppu)
 		return ret; // LLE doesn't unlock the mutex
 	}
 
-	return sys_mutex_unlock(ppu, output_mutex);
+	return lv2_syscall<sys_mutex_unlock>(ppu, output_mutex);
 }
 
 void lpcmDecEntry(ppu_thread& ppu, vm::ptr<LpcmDecContext> lpcm_dec)
@@ -820,13 +820,13 @@ error_code _CellAdecCoreOpOpenExt_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext>
 	const vm::var<sys_mutex_attribute_t> queue_mutex_attr{{ SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, { "_adem06"_u64 } }};
 	const vm::var<sys_cond_attribute_t> cond_attr{{ SYS_SYNC_NOT_PROCESS_SHARED, 0, 0, { "_adec03"_u64 } }};
 
-	error_code ret = sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::queue_size_mutex), mutex_attr);
-	ret = ret ? ret : sys_cond_create(ppu, handle.ptr(&LpcmDecContext::queue_size_cond), handle->queue_size_mutex, cond_attr);
-	ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::unk_mutex), mutex_attr);
-	ret = ret ? ret : sys_cond_create(ppu, handle.ptr(&LpcmDecContext::unk_cond), handle->unk_mutex, cond_attr);
-	ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::output_mutex), output_mutex_attr);
-	ret = ret ? ret : sys_cond_create(ppu, handle.ptr(&LpcmDecContext::output_consumed), handle->output_mutex, cond_attr);
-	ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::queue_mutex), queue_mutex_attr);
+	error_code ret = lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&LpcmDecContext::queue_size_mutex), mutex_attr);
+	ret = ret ? ret : lv2_syscall<sys_cond_create>(ppu, handle.ptr(&LpcmDecContext::queue_size_cond), handle->queue_size_mutex, cond_attr);
+	ret = ret ? ret : lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&LpcmDecContext::unk_mutex), mutex_attr);
+	ret = ret ? ret : lv2_syscall<sys_cond_create>(ppu, handle.ptr(&LpcmDecContext::unk_cond), handle->unk_mutex, cond_attr);
+	ret = ret ? ret : lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&LpcmDecContext::output_mutex), output_mutex_attr);
+	ret = ret ? ret : lv2_syscall<sys_cond_create>(ppu, handle.ptr(&LpcmDecContext::output_consumed), handle->output_mutex, cond_attr);
+	ret = ret ? ret : lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&LpcmDecContext::queue_mutex), queue_mutex_attr);
 	ret = ret ? ret : handle->release_output(ppu);
 	ret = ret ? ret : handle->cmd_available.init(ppu, handle.ptr(&LpcmDecContext::cmd_available), 0);
 	ret = ret ? ret : handle->reserved2.init(ppu, handle.ptr(&LpcmDecContext::reserved2), 0);
@@ -844,8 +844,8 @@ error_code _CellAdecCoreOpOpenExt_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext>
 	const auto entry = g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(lpcmDecEntry));
 
 	ret = ppu_execute<&sys_ppu_thread_create>(ppu, handle.ptr(&LpcmDecContext::thread_id), entry, handle.addr(), +res->ppuThreadPriority, +res->ppuThreadStackSize, SYS_PPU_THREAD_CREATE_JOINABLE, +_name);
-	ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::spurs_queue_pop_mutex), mutex_attr);
-	ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::spurs_queue_push_mutex), mutex_attr);
+	ret = ret ? ret : lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&LpcmDecContext::spurs_queue_pop_mutex), mutex_attr);
+	ret = ret ? ret : lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&LpcmDecContext::spurs_queue_push_mutex), mutex_attr);
 
 	return ret;
 }
@@ -875,14 +875,14 @@ error_code _CellAdecCoreOpClose_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> ha
 	{
 		handle->cmd_queue.emplace(LpcmDecCmdType::close);
 
-		if (error_code ret = sys_mutex_unlock(ppu, handle->queue_mutex); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, handle->queue_mutex); ret != CELL_OK)
 		{
 			return ret; // LLE doesn't unlock the queue size mutex
 		}
 
 		if (error_code ret = handle->cmd_available.release(ppu); ret != CELL_OK)
 		{
-			ensure(sys_mutex_unlock(ppu, handle->queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, handle->queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
 			return ret;
 		}
 	}
@@ -893,29 +893,29 @@ error_code _CellAdecCoreOpClose_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> ha
 			cmd.type = LpcmDecCmdType::close;
 		}
 
-		if (error_code ret = sys_mutex_unlock(ppu, handle->queue_mutex); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, handle->queue_mutex); ret != CELL_OK)
 		{
 			return ret; // LLE doesn't unlock the queue size mutex
 		}
 	}
 
-	error_code ret = sys_mutex_unlock(ppu, handle->queue_size_mutex);
+	error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, handle->queue_size_mutex);
 	ret = ret ? ret : handle->release_output(ppu);
 
 	vm::var<u64> thread_ret;
-	ret = ret ? ret : sys_ppu_thread_join(ppu, static_cast<u32>(handle->thread_id), +thread_ret);
+	ret = ret ? ret : lv2_syscall<sys_ppu_thread_join>(ppu, static_cast<u32>(handle->thread_id), +thread_ret);
 
-	ret = ret ? ret : sys_cond_destroy(ppu, handle->queue_size_cond);
-	ret = ret ? ret : sys_cond_destroy(ppu, handle->unk_cond);
-	ret = ret ? ret : sys_cond_destroy(ppu, handle->output_consumed);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->queue_mutex);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->queue_size_mutex);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->unk_mutex);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->output_mutex);
+	ret = ret ? ret : lv2_syscall<sys_cond_destroy>(ppu, handle->queue_size_cond);
+	ret = ret ? ret : lv2_syscall<sys_cond_destroy>(ppu, handle->unk_cond);
+	ret = ret ? ret : lv2_syscall<sys_cond_destroy>(ppu, handle->output_consumed);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->queue_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->queue_size_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->unk_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->output_mutex);
 	ret = ret ? ret : handle->cmd_available.finalize(ppu);
 	ret = ret ? ret : handle->reserved2.finalize(ppu);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->spurs_queue_pop_mutex);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->spurs_queue_push_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->spurs_queue_pop_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->spurs_queue_push_mutex);
 
 	return ret;
 }
@@ -1095,7 +1095,7 @@ error_code AdecContext::link_frame(ppu_thread& ppu, s32 pcm_handle)
 
 	if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
 	{
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return CELL_ADEC_ERROR_FATAL;
 	}
 
@@ -1115,11 +1115,11 @@ error_code AdecContext::link_frame(ppu_thread& ppu, s32 pcm_handle)
 	}
 	else
 	{
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return CELL_ADEC_ERROR_FATAL;
 	}
 
-	ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 	return CELL_OK;
 }
 
@@ -1129,13 +1129,13 @@ error_code AdecContext::unlink_frame(ppu_thread& ppu, s32 pcm_handle)
 
 	if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
 	{
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return CELL_ADEC_ERROR_FATAL;
 	}
 
 	if (frames_head == -1 || frames_tail == -1)
 	{
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return CELL_ADEC_ERROR_FATAL;
 	}
 
@@ -1146,7 +1146,7 @@ error_code AdecContext::unlink_frame(ppu_thread& ppu, s32 pcm_handle)
 	{
 		if (pcm_handle != frames_tail)
 		{
-			ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 			return CELL_ADEC_ERROR_FATAL;
 		}
 
@@ -1171,7 +1171,7 @@ error_code AdecContext::unlink_frame(ppu_thread& ppu, s32 pcm_handle)
 		frames[prev].next = next;
 	}
 
-	ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 	return CELL_OK;
 }
 
@@ -1557,7 +1557,7 @@ error_code adecOpen(ppu_thread& ppu, vm::ptr<CellAdecType> type, vm::cptr<CellAd
 		frames[i].prev = 0;
 	}
 
-	ensure(sys_mutex_create(ppu, _this.ptr(&AdecContext::mutex), _this.ptr(&AdecContext::mutex_attribute)) == CELL_OK); // Error code isn't checked on LLE
+	ensure(lv2_syscall<sys_mutex_create>(ppu, _this.ptr(&AdecContext::mutex), _this.ptr(&AdecContext::mutex_attribute)) == CELL_OK); // Error code isn't checked on LLE
 
 	*handle = _this;
 
@@ -1626,7 +1626,7 @@ error_code cellAdecClose(ppu_thread& ppu, vm::ptr<AdecContext> handle)
 		return ret;
 	}
 
-	if (error_code ret = sys_mutex_destroy(ppu, handle->mutex); ret != CELL_OK)
+	if (error_code ret = lv2_syscall<sys_mutex_destroy>(ppu, handle->mutex); ret != CELL_OK)
 	{
 		return ret;
 	}
diff --git a/rpcs3/Emu/Cell/Modules/cellAdec.h b/rpcs3/Emu/Cell/Modules/cellAdec.h
index 33dd356ee5..2216561516 100644
--- a/rpcs3/Emu/Cell/Modules/cellAdec.h
+++ b/rpcs3/Emu/Cell/Modules/cellAdec.h
@@ -524,10 +524,10 @@ public:
 		this->size = 0;
 
 		const vm::var<sys_mutex_attribute_t> mutex_attr = {{ SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, { "_adem07"_u64 } }};
-		ensure(sys_mutex_create(ppu, _this.ptr(&AdecOutputQueue::mutex), mutex_attr) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_create>(ppu, _this.ptr(&AdecOutputQueue::mutex), mutex_attr) == CELL_OK); // Error code isn't checked on LLE
 
 		const vm::var<sys_cond_attribute_t> cond_attr = {{ SYS_SYNC_NOT_PROCESS_SHARED, 0, 0, { "_adec05"_u64 } }};
-		ensure(sys_cond_create(ppu, _this.ptr(&AdecOutputQueue::cond), mutex, cond_attr) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_cond_create>(ppu, _this.ptr(&AdecOutputQueue::cond), mutex, cond_attr) == CELL_OK); // Error code isn't checked on LLE
 
 		for (s32 i = 0; i < 4; i++)
 		{
@@ -537,12 +537,12 @@ public:
 
 	error_code finalize(ppu_thread& ppu) const
 	{
-		if (error_code ret = sys_cond_destroy(ppu, cond); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_cond_destroy>(ppu, cond); ret != CELL_OK)
 		{
 			return ret;
 		}
 
-		if (error_code ret = sys_mutex_destroy(ppu, mutex); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_mutex_destroy>(ppu, mutex); ret != CELL_OK)
 		{
 			return ret;
 		}
@@ -556,7 +556,7 @@ public:
 
 		if (entries[back].state != 0xff)
 		{
-			ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 			return true; // LLE returns the result of the comparison above
 		}
 
@@ -567,7 +567,7 @@ public:
 		back = (back + 1) & 3;
 		size++;
 
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return CELL_OK;
 	}
 
@@ -582,7 +582,7 @@ public:
 
 		if (entries[front].state == 0xff)
 		{
-			ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 			return nullptr;
 		}
 
@@ -594,7 +594,7 @@ public:
 		front = (front + 1) & 3;
 		size--;
 
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return ret;
 	}
 
@@ -602,7 +602,7 @@ public:
 	{
 		ensure(lv2_syscall<sys_mutex_lock>(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
 		const entry& ret = entries[front];
-		ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
 		return ret;
 	}
 };
@@ -721,22 +721,22 @@ public:
 		const vm::var<sys_mutex_attribute_t> mutex_attr{{ SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, { "_adem01"_u64 } }};
 		const vm::var<sys_cond_attribute_t> cond_attr{{ SYS_SYNC_NOT_PROCESS_SHARED, 0, 0, { "_adec01"_u64 } }};
 
-		if (error_code ret = sys_mutex_create(ppu, _this.ptr(&LpcmDecSemaphore::mutex), mutex_attr); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_mutex_create>(ppu, _this.ptr(&LpcmDecSemaphore::mutex), mutex_attr); ret != CELL_OK)
 		{
 			return ret;
 		}
 
-		return sys_cond_create(ppu, _this.ptr(&LpcmDecSemaphore::cond), mutex, cond_attr);
+		return lv2_syscall<sys_cond_create>(ppu, _this.ptr(&LpcmDecSemaphore::cond), mutex, cond_attr);
 	}
 
 	error_code finalize(ppu_thread& ppu) const
 	{
-		if (error_code ret = sys_cond_destroy(ppu, cond); ret != CELL_OK)
+		if (error_code ret = lv2_syscall<sys_cond_destroy>(ppu, cond); ret != CELL_OK)
 		{
 			return ret;
 		}
 
-		return sys_mutex_destroy(ppu, mutex);
+		return lv2_syscall<sys_mutex_destroy>(ppu, mutex);
 	}
 
 	error_code release(ppu_thread& ppu)
@@ -753,7 +753,7 @@ public:
 			return ret; // LLE doesn't unlock the mutex
 		}
 
-		return sys_mutex_unlock(ppu, mutex);
+		return lv2_syscall<sys_mutex_unlock>(ppu, mutex);
 	}
 
 	error_code acquire(ppu_thread& ppu, lpcm_dec_state& savestate)
@@ -793,7 +793,7 @@ public:
 
 		value--;
 
-		return sys_mutex_unlock(ppu, mutex);
+		return lv2_syscall<sys_mutex_unlock>(ppu, mutex);
 	}
 };
 
diff --git a/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp b/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp
index 15e0069408..fb3191bcb4 100644
--- a/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellAtracXdec.cpp
@@ -317,12 +317,12 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 				return;
 			}
 
-			ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex) == CELL_OK);
 		}
 
 		cmd_queue.pop(cmd);
 
-		ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK);
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex) == CELL_OK);
 
 		savestate = atracxdec_state::checking_run_thread_1;
 		label2_check_run_thread_1_state:
@@ -336,11 +336,11 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 
 		if (!run_thread)
 		{
-			ensure(sys_mutex_unlock(ppu, run_thread_mutex) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, run_thread_mutex) == CELL_OK);
 			return;
 		}
 
-		ensure(sys_mutex_unlock(ppu, run_thread_mutex) == CELL_OK);
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, run_thread_mutex) == CELL_OK);
 
 		savestate = atracxdec_state::executing_cmd;
 		label3_execute_cmd_state:
@@ -426,12 +426,12 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 
 			if (!run_thread)
 			{
-				ensure(sys_mutex_unlock(ppu, run_thread_mutex) == CELL_OK);
-				ensure(sys_mutex_unlock(ppu, output_mutex) == CELL_OK);
+				ensure(lv2_syscall<sys_mutex_unlock>(ppu, run_thread_mutex) == CELL_OK);
+				ensure(lv2_syscall<sys_mutex_unlock>(ppu, output_mutex) == CELL_OK);
 				return;
 			}
 
-			ensure(sys_mutex_unlock(ppu, run_thread_mutex) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, run_thread_mutex) == CELL_OK);
 
 			savestate = atracxdec_state::decoding;
 			label6_decode_state:
@@ -645,7 +645,7 @@ void AtracXdecContext::exec(ppu_thread& ppu)
 			notify_au_done.cbFunc(ppu, cmd.pcm_handle, notify_au_done.cbArg);
 
 			output_locked = true;
-			ensure(sys_mutex_unlock(ppu, output_mutex) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, output_mutex) == CELL_OK);
 
 			const u32 output_size = decoded_samples_num * (decoder.bw_pcm & 0x7fu) * decoder.nch_out;
 
@@ -692,20 +692,20 @@ error_code AtracXdecContext::send_command(ppu_thread& ppu, auto&&... args)
 			// Close command is only sent if the queue is empty on LLE
 			if (!cmd_queue.empty())
 			{
-				ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK);
+				ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex) == CELL_OK);
 				return {};
 			}
 		}
 
 		if (cmd_queue.full())
 		{
-			ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK);
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex) == CELL_OK);
 			return CELL_ADEC_ERROR_ATX_BUSY;
 		}
 
 		cmd_queue.emplace(std::forward<AtracXdecCmdType>(type), std::forward<decltype(args)>(args)...);
 
-		ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK);
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, queue_mutex) == CELL_OK);
 	}
 
 	ensure(lv2_syscall<sys_cond_signal>(ppu, queue_not_empty) == CELL_OK);
@@ -779,25 +779,25 @@ error_code _CellAdecCoreOpOpenExt_atracx(ppu_thread& ppu, vm::ptr<AtracXdecConte
 	const vm::var<sys_mutex_attribute_t> mutex_attr{{ SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, { "_atd001"_u64 } }};
 	const vm::var<sys_cond_attribute_t> cond_attr{{ SYS_SYNC_NOT_PROCESS_SHARED, 0, 0, { "_atd002"_u64 } }};
 
-	ensure(sys_mutex_create(ppu, handle.ptr(&AtracXdecContext::queue_mutex), mutex_attr) == CELL_OK);
-	ensure(sys_cond_create(ppu, handle.ptr(&AtracXdecContext::queue_not_empty), handle->queue_mutex, cond_attr) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&AtracXdecContext::queue_mutex), mutex_attr) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_create>(ppu, handle.ptr(&AtracXdecContext::queue_not_empty), handle->queue_mutex, cond_attr) == CELL_OK);
 
 	mutex_attr->name_u64 = "_atd003"_u64;
 	cond_attr->name_u64 = "_atd004"_u64;
 
-	ensure(sys_mutex_create(ppu, handle.ptr(&AtracXdecContext::run_thread_mutex), mutex_attr) == CELL_OK);
-	ensure(sys_cond_create(ppu, handle.ptr(&AtracXdecContext::run_thread_cond), handle->run_thread_mutex, cond_attr) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&AtracXdecContext::run_thread_mutex), mutex_attr) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_create>(ppu, handle.ptr(&AtracXdecContext::run_thread_cond), handle->run_thread_mutex, cond_attr) == CELL_OK);
 
 	mutex_attr->name_u64 = "_atd005"_u64;
 	cond_attr->name_u64 = "_atd006"_u64;
 
-	ensure(sys_mutex_create(ppu, handle.ptr(&AtracXdecContext::output_mutex), mutex_attr) == CELL_OK);
-	ensure(sys_cond_create(ppu, handle.ptr(&AtracXdecContext::output_consumed), handle->output_mutex, cond_attr) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&AtracXdecContext::output_mutex), mutex_attr) == CELL_OK);
+	ensure(lv2_syscall<sys_cond_create>(ppu, handle.ptr(&AtracXdecContext::output_consumed), handle->output_mutex, cond_attr) == CELL_OK);
 
 	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->output_mutex, 0) == CELL_OK);
 	handle->output_locked = false;
 	ensure(lv2_syscall<sys_cond_signal>(ppu, handle->output_consumed) == CELL_OK);
-	ensure(sys_mutex_unlock(ppu, handle->output_mutex) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, handle->output_mutex) == CELL_OK);
 
 	const vm::var<char[]> _name = vm::make_str("HLE ATRAC3plus decoder");
 	const auto entry = g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(atracXdecEntry));
@@ -831,24 +831,24 @@ error_code _CellAdecCoreOpClose_atracx(ppu_thread& ppu, vm::ptr<AtracXdecContext
 
 	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->run_thread_mutex, 0) == CELL_OK);
 	handle->run_thread = false;
-	ensure(sys_mutex_unlock(ppu, handle->run_thread_mutex) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, handle->run_thread_mutex) == CELL_OK);
 
 	handle->send_command<AtracXdecCmdType::close>(ppu);
 
 	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->output_mutex, 0) == CELL_OK);
 	handle->output_locked = false;
-	ensure(sys_mutex_unlock(ppu, handle->output_mutex) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, handle->output_mutex) == CELL_OK);
 	ensure(lv2_syscall<sys_cond_signal>(ppu, handle->output_consumed) == CELL_OK);
 
 	vm::var<u64> thread_ret;
 	ensure(lv2_syscall<sys_ppu_thread_join>(ppu, static_cast<u32>(handle->thread_id), +thread_ret) == CELL_OK);
 
-	error_code ret = sys_cond_destroy(ppu, handle->queue_not_empty);
-	ret = ret ? ret : sys_cond_destroy(ppu, handle->run_thread_cond);
-	ret = ret ? ret : sys_cond_destroy(ppu, handle->output_consumed);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->queue_mutex);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->run_thread_mutex);
-	ret = ret ? ret : sys_mutex_destroy(ppu, handle->output_mutex);
+	error_code ret = lv2_syscall<sys_cond_destroy>(ppu, handle->queue_not_empty);
+	ret = ret ? ret : lv2_syscall<sys_cond_destroy>(ppu, handle->run_thread_cond);
+	ret = ret ? ret : lv2_syscall<sys_cond_destroy>(ppu, handle->output_consumed);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->queue_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->run_thread_mutex);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, handle->output_mutex);
 
 	return ret != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : CELL_OK;
 }
@@ -939,7 +939,7 @@ error_code _CellAdecCoreOpReleasePcm_atracx(ppu_thread& ppu, vm::ptr<AtracXdecCo
 		return {};
 	}
 
-	ensure(sys_mutex_unlock(ppu, handle->output_mutex) == CELL_OK);
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, handle->output_mutex) == CELL_OK);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
index ac3dfa7e06..9332fc5f1e 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
@@ -999,6 +999,10 @@ void dmux_pamf_spu_context::operator()() // cellSpursMain()
 			ensure(stream_info_queue->pop(stream_info));
 
 			set_stream({ stream_info.stream_addr.get_ptr(), stream_info.stream_size }, stream_info.continuity);
+
+			// Delay demuxing a bit
+			// Prevents White Knight Chronicles II FMVs from freezing, since events are otherwise fired before the game has finished initializing FMV playback
+			thread_ctrl::wait_for(1'500);
 		}
 
 		process_next_pack();
@@ -1229,7 +1233,7 @@ error_code DmuxPamfContext::wait_au_released_or_stream_reset(ppu_thread& ppu, u6
 
 			if (lv2_syscall<sys_cond_wait>(ppu, cond, 0) != CELL_OK)
 			{
-				sys_mutex_unlock(ppu, mutex);
+				lv2_syscall<sys_mutex_unlock>(ppu, mutex);
 				return CELL_DMUX_PAMF_ERROR_FATAL;
 			}
 
@@ -1247,7 +1251,7 @@ error_code DmuxPamfContext::wait_au_released_or_stream_reset(ppu_thread& ppu, u6
 
 	au_released_bitset = 0;
 
-	return sys_mutex_unlock(ppu, mutex) != CELL_OK ? static_cast<error_code>(CELL_DMUX_PAMF_ERROR_FATAL) : CELL_OK;
+	return lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK ? static_cast<error_code>(CELL_DMUX_PAMF_ERROR_FATAL) : CELL_OK;
 }
 
 template <bool reset>
@@ -1265,7 +1269,7 @@ error_code DmuxPamfContext::set_au_reset(ppu_thread& ppu)
 
 	std::ranges::for_each(elementary_streams | std::views::filter([](auto es){ return !!es; }), [](auto& reset_next_au) { reset_next_au = reset; }, &DmuxPamfElementaryStream::reset_next_au);
 
-	return sys_mutex_unlock(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+	return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 }
 
 template <typename F>
@@ -1383,7 +1387,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 
 			sequence_state = DmuxPamfSequenceState::resetting;
 
-			if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+			if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::starting_demux_done_mutex_unlock_error;
 				label6_starting_demux_done_mutex_unlock_error_state:
@@ -1451,7 +1455,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 			// If the elementary stream of the found access unit is not enabled, don't do anything
 			if (!es || es->_this.get_ptr() != es || es->es_id != event.au_found.user_data)
 			{
-				if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+				if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 				{
 					savestate = dmux_pamf_state::sending_fatal_err;
 					continue;
@@ -1479,7 +1483,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 					es->reset_next_au = false;
 				}
 
-				if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+				if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 				{
 					savestate = dmux_pamf_state::sending_fatal_err;
 					continue;
@@ -1505,7 +1509,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 				es->au_specific_info[2] = read_from_ptr<bf_t<u8, 6, 2>>(event.au_found.stream_header_buf, 1);
 			}
 
-			if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+			if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1567,7 +1571,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 
 				if (lv2_syscall<sys_cond_signal_all>(ppu, cond) != CELL_OK)
 				{
-					sys_mutex_unlock(ppu, mutex);
+					lv2_syscall<sys_mutex_unlock>(ppu, mutex);
 
 					savestate = dmux_pamf_state::sending_fatal_err;
 					continue;
@@ -1576,7 +1580,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 				RETURN_ON_CPU_FLAG_AGAIN();
 			}
 
-			if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+			if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1602,7 +1606,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 			DmuxPamfElementaryStream* const es = find_es(event.flush_done.stream_id, event.flush_done.private_stream_id);
 			const bool valid = es && es->_this.get_ptr() == es && es->es_id == event.flush_done.user_data;
 
-			if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+			if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1672,7 +1676,7 @@ void DmuxPamfContext::exec(ppu_thread& ppu)
 				ensure(cmd_result_queue.pop());
 			}
 
-			if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+			if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 			{
 				savestate = dmux_pamf_state::sending_fatal_err;
 				continue;
@@ -1978,8 +1982,8 @@ error_code DmuxPamfContext::open(ppu_thread& ppu, const CellDmuxPamfResource& re
 	const vm::var<sys_mutex_attribute_t> mutex_attr = {{ SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, { "_dxpmtx"_u64 } }};
 	const vm::var<sys_cond_attribute_t> cond_attr = {{ SYS_SYNC_NOT_PROCESS_SHARED, 0, 0, { "_dxpcnd"_u64 } }};
 
-	if (sys_mutex_create(ppu, _this.ptr(&DmuxPamfContext::mutex), mutex_attr) != CELL_OK
-		|| sys_cond_create(ppu, _this.ptr(&DmuxPamfContext::cond), _this->mutex, cond_attr) != CELL_OK)
+	if (lv2_syscall<sys_mutex_create>(ppu, _this.ptr(&DmuxPamfContext::mutex), mutex_attr) != CELL_OK
+		|| lv2_syscall<sys_cond_create>(ppu, _this.ptr(&DmuxPamfContext::cond), _this->mutex, cond_attr) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -2092,8 +2096,8 @@ error_code DmuxPamfContext::close(ppu_thread& ppu)
 		g_fxo->get<lv2_memory_container>().free(0x40000);
 	}
 
-	if (sys_cond_destroy(ppu, cond) != CELL_OK
-		|| sys_mutex_destroy(ppu, mutex) != CELL_OK)
+	if (lv2_syscall<sys_cond_destroy>(ppu, cond) != CELL_OK
+		|| lv2_syscall<sys_mutex_destroy>(ppu, mutex) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -2144,7 +2148,7 @@ error_code DmuxPamfContext::reset_stream(ppu_thread& ppu)
 
 		if (sequence_state != DmuxPamfSequenceState::running)
 		{
-			return sys_mutex_unlock(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+			return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
 		[[fallthrough]];
@@ -2164,7 +2168,7 @@ error_code DmuxPamfContext::reset_stream(ppu_thread& ppu)
 	case 2:
 		if (const error_code ret = lv2_syscall<sys_cond_signal_to>(ppu, cond, static_cast<u32>(thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
 		{
-			sys_mutex_unlock(ppu, mutex);
+			lv2_syscall<sys_mutex_unlock>(ppu, mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
@@ -2174,7 +2178,7 @@ error_code DmuxPamfContext::reset_stream(ppu_thread& ppu)
 			return {};
 		}
 
-		return sys_mutex_unlock(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+		return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 
 	default:
 		fmt::throw_exception("Unexpected savestate value: 0x%x", savestate);
@@ -2240,7 +2244,7 @@ error_code DmuxPamfContext::join_thread(ppu_thread& ppu)
 
 	send_spu_command_and_wait<DmuxPamfCommandType::close>(ppu, false);
 
-	if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+	if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -2293,7 +2297,7 @@ error_code DmuxPamfContext::set_stream(ppu_thread& ppu, vm::cptr<u8> stream_addr
 
 		if (!stream_info_queue.emplace(stream_address, stream_size, user_data, !discontinuity, raw_es))
 		{
-			return sys_mutex_unlock(ppu, mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_BUSY : CELL_DMUX_PAMF_ERROR_FATAL;
+			return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_BUSY : CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 	}
 
@@ -2307,7 +2311,7 @@ error_code DmuxPamfContext::set_stream(ppu_thread& ppu, vm::cptr<u8> stream_addr
 
 	sequence_state = DmuxPamfSequenceState::running;
 
-	return sys_mutex_unlock(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+	return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 }
 
 template <bool raw_es>
@@ -2362,7 +2366,7 @@ error_code DmuxPamfElementaryStream::release_au(ppu_thread& ppu, vm::ptr<u8> au_
 	case 2:
 		if (const error_code ret = lv2_syscall<sys_cond_signal_to>(ppu, demuxer->cond, static_cast<u32>(demuxer->thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
 		{
-			sys_mutex_unlock(ppu, demuxer->mutex);
+			lv2_syscall<sys_mutex_unlock>(ppu, demuxer->mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
@@ -2372,7 +2376,7 @@ error_code DmuxPamfElementaryStream::release_au(ppu_thread& ppu, vm::ptr<u8> au_
 			return {};
 		}
 
-		return sys_mutex_unlock(ppu, demuxer->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+		return lv2_syscall<sys_mutex_unlock>(ppu, demuxer->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 
 	default:
 		fmt::throw_exception("Unexpected savestate value: 0x%x", savestate);
@@ -2490,13 +2494,13 @@ error_code DmuxPamfContext::enable_es(ppu_thread& ppu, u16 stream_id, u16 privat
 
 		if (enabled_es_num == max_enabled_es_num)
 		{
-			return sys_mutex_unlock(ppu, mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_NO_MEMORY : CELL_DMUX_PAMF_ERROR_FATAL;
+			return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_NO_MEMORY : CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
 		if (find_es(stream_id, private_stream_id))
 		{
 			// Elementary stream is already enabled
-			return sys_mutex_unlock(ppu, mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_ARG : CELL_DMUX_PAMF_ERROR_FATAL;
+			return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_ARG : CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 	}
 
@@ -2574,7 +2578,7 @@ error_code DmuxPamfContext::enable_es(ppu_thread& ppu, u16 stream_id, u16 privat
 
 	enabled_es_num++;
 
-	if (sys_mutex_unlock(ppu, mutex) != CELL_OK)
+	if (lv2_syscall<sys_mutex_unlock>(ppu, mutex) != CELL_OK)
 	{
 		return CELL_DMUX_PAMF_ERROR_FATAL;
 	}
@@ -2642,7 +2646,7 @@ error_code DmuxPamfElementaryStream::disable_es(ppu_thread& ppu)
 		if (!dmux->find_es(stream_id, private_stream_id))
 		{
 			// Elementary stream is already disabled
-			return sys_mutex_unlock(ppu, dmux->mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_ARG : CELL_DMUX_PAMF_ERROR_FATAL;
+			return lv2_syscall<sys_mutex_unlock>(ppu, dmux->mutex) == CELL_OK ? CELL_DMUX_PAMF_ERROR_ARG : CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
 		[[fallthrough]];
@@ -2675,7 +2679,7 @@ error_code DmuxPamfElementaryStream::disable_es(ppu_thread& ppu)
 	case 2:
 		if (const error_code ret = lv2_syscall<sys_cond_signal_to>(ppu, dmux->cond, static_cast<u32>(dmux->thread_id)); ret != CELL_OK && ret != static_cast<s32>(CELL_EPERM))
 		{
-			sys_mutex_unlock(ppu, dmux->mutex);
+			lv2_syscall<sys_mutex_unlock>(ppu, dmux->mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
@@ -2685,7 +2689,7 @@ error_code DmuxPamfElementaryStream::disable_es(ppu_thread& ppu)
 			return {};
 		}
 
-		return sys_mutex_unlock(ppu, dmux->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+		return lv2_syscall<sys_mutex_unlock>(ppu, dmux->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 
 	default:
 		fmt::throw_exception("Unexpected savestate value: 0x%x", savestate);
@@ -2732,7 +2736,7 @@ error_code DmuxPamfElementaryStream::flush_es(ppu_thread& ppu) const
 		return {};
 	}
 
-	return sys_mutex_unlock(ppu, demuxer->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+	return lv2_syscall<sys_mutex_unlock>(ppu, demuxer->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 }
 
 error_code _CellDmuxCoreOpFlushEs(ppu_thread& ppu, vm::ptr<CellDmuxPamfEsHandle> esHandle)
@@ -2775,7 +2779,7 @@ error_code DmuxPamfElementaryStream::reset_es(ppu_thread& ppu) const
 		return {};
 	}
 
-	return sys_mutex_unlock(ppu, demuxer->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+	return lv2_syscall<sys_mutex_unlock>(ppu, demuxer->mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 }
 
 error_code _CellDmuxCoreOpResetEs(ppu_thread& ppu, vm::ptr<CellDmuxPamfEsHandle> esHandle)
@@ -2825,7 +2829,7 @@ error_code DmuxPamfContext::reset_stream_and_wait_done(ppu_thread& ppu)
 	{
 		if (lv2_syscall<sys_cond_wait>(ppu, cond, 0) != CELL_OK)
 		{
-			sys_mutex_unlock(ppu, mutex);
+			lv2_syscall<sys_mutex_unlock>(ppu, mutex);
 			return CELL_DMUX_PAMF_ERROR_FATAL;
 		}
 
@@ -2835,7 +2839,7 @@ error_code DmuxPamfContext::reset_stream_and_wait_done(ppu_thread& ppu)
 		}
 	}
 
-	return sys_mutex_unlock(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
+	return lv2_syscall<sys_mutex_unlock>(ppu, mutex) == CELL_OK ? static_cast<error_code>(CELL_OK) : CELL_DMUX_PAMF_ERROR_FATAL;
 }
 
 error_code _CellDmuxCoreOpResetStreamAndWaitDone(ppu_thread& ppu, vm::ptr<CellDmuxPamfHandle> handle)
diff --git a/rpcs3/Emu/Cell/lv2/sys_prx.cpp b/rpcs3/Emu/Cell/lv2/sys_prx.cpp
index f20b6be6cb..f46f3bdafa 100644
--- a/rpcs3/Emu/Cell/lv2/sys_prx.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_prx.cpp
@@ -64,7 +64,7 @@ extern const std::map<std::string_view, int> g_prx_list
 	{ "libddpdec.sprx", 0 },
 	{ "libdivxdec.sprx", 0 },
 	{ "libdmux.sprx", 0 },
-	{ "libdmuxpamf.sprx", 0 },
+	{ "libdmuxpamf.sprx", 1 },
 	{ "libdtslbrdec.sprx", 0 },
 	{ "libfiber.sprx", 0 },
 	{ "libfont.sprx", 0 },

From 27024171926ea4ff62877bbd14ee9cb0f2e9c117 Mon Sep 17 00:00:00 2001
From: BehroozRezvani <Brezvani@outlook.com>
Date: Fri, 27 Mar 2026 15:08:46 +0000
Subject: [PATCH 44/98] Make performance overlays use window space (#18419)

Adds a new performance overlay option to use the whole window as rather
than just framebuffer space.
---
 rpcs3/Emu/RSX/GL/GLOverlays.cpp               |  4 ++
 rpcs3/Emu/RSX/GL/GLPresent.cpp                |  4 +-
 .../HomeMenu/overlay_home_menu_settings.cpp   |  5 +-
 .../Emu/RSX/Overlays/overlay_perf_metrics.cpp | 69 ++++++++++++++++---
 rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.h | 11 ++-
 rpcs3/Emu/RSX/Overlays/overlays.h             |  4 ++
 rpcs3/Emu/RSX/VK/VKOverlays.cpp               |  6 +-
 rpcs3/Emu/RSX/VK/VKPresent.cpp                |  4 +-
 rpcs3/Emu/localized_string_id.h               |  1 +
 rpcs3/Emu/system_config.h                     |  5 +-
 rpcs3/rpcs3qt/emu_settings_type.h             |  6 +-
 rpcs3/rpcs3qt/localized_emu.h                 |  1 +
 rpcs3/rpcs3qt/settings_dialog.cpp             |  8 ++-
 rpcs3/rpcs3qt/settings_dialog.ui              | 25 ++++++-
 rpcs3/rpcs3qt/tooltips.h                      |  5 +-
 15 files changed, 132 insertions(+), 26 deletions(-)

diff --git a/rpcs3/Emu/RSX/GL/GLOverlays.cpp b/rpcs3/Emu/RSX/GL/GLOverlays.cpp
index 38f66c1edf..a758804e4f 100644
--- a/rpcs3/Emu/RSX/GL/GLOverlays.cpp
+++ b/rpcs3/Emu/RSX/GL/GLOverlays.cpp
@@ -399,6 +399,10 @@ namespace gl
 
 	void ui_overlay_renderer::run(gl::command_context& cmd_, const areau& viewport, GLuint target, rsx::overlays::overlay& ui, bool flip_vertically)
 	{
+		ui.set_render_viewport(
+		    static_cast<u16>(std::min<u32>(viewport.width(), std::numeric_limits<u16>::max())),
+		    static_cast<u16>(std::min<u32>(viewport.height(), std::numeric_limits<u16>::max()))
+		);
 		const auto ui_scale = color4f(static_cast<f32>(ui.virtual_width), static_cast<f32>(ui.virtual_height), 1.f, 1.f);
 		const auto ui_viewport = color4f(static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()), static_cast<f32>(viewport.x1), static_cast<f32>(viewport.y1));
 
diff --git a/rpcs3/Emu/RSX/GL/GLPresent.cpp b/rpcs3/Emu/RSX/GL/GLPresent.cpp
index e101d77e03..2e23ca33b6 100644
--- a/rpcs3/Emu/RSX/GL/GLPresent.cpp
+++ b/rpcs3/Emu/RSX/GL/GLPresent.cpp
@@ -317,9 +317,11 @@ void GLGSRender::flip(const rsx::display_flip_info_t& info)
 			// Lock to avoid modification during run-update chain
 			std::lock_guard lock(*m_overlay_manager);
 
+			const areau display_area = {0, 0, static_cast<u32>(m_frame->client_width()), static_cast<u32>(m_frame->client_height())};
 			for (const auto& view : m_overlay_manager->get_views())
 			{
-				m_ui_renderer.run(cmd, aspect_ratio, target, *view.get(), flip_vertically);
+				const areau render_area = view->use_window_space ? display_area : aspect_ratio;
+				m_ui_renderer.run(cmd, render_area, target, *view.get(), flip_vertically);
 			}
 		}
 	};
diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
index 3d32aaf844..1a2f99dca3 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
@@ -252,10 +252,11 @@ namespace rsx
 			add_dropdown(&g_cfg.video.perf_overlay.position, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_POSITION);
 			add_checkbox(&g_cfg.video.perf_overlay.center_x, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_CENTER_X);
 			add_checkbox(&g_cfg.video.perf_overlay.center_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_CENTER_Y);
-			add_unsigned_slider(&g_cfg.video.perf_overlay.margin_x, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_X, " px", 1);
-			add_unsigned_slider(&g_cfg.video.perf_overlay.margin_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y, " px", 1);
+			add_float_slider(&g_cfg.video.perf_overlay.margin_x, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_X, " %", 0.25f);
+			add_float_slider(&g_cfg.video.perf_overlay.margin_y, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y, " %", 0.25f);
 			add_unsigned_slider(&g_cfg.video.perf_overlay.font_size, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE, " px", 1);
 			add_unsigned_slider(&g_cfg.video.perf_overlay.opacity, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY, " %", 1);
+			add_checkbox(&g_cfg.video.perf_overlay.perf_overlay_use_window_space, localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE);
 
 			apply_layout();
 		}
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp b/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
index 8b68357208..e62097c71c 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
@@ -6,6 +6,7 @@
 #include "Emu/Cell/PPUThread.h"
 
 #include <algorithm>
+#include <cmath>
 #include <utility>
 
 #include "util/cpu_stats.hpp"
@@ -93,7 +94,6 @@ namespace rsx
 		{
 			// left, top, right, bottom
 			const areau padding { m_padding, m_padding - std::min<u32>(4, m_padding), m_padding, m_padding };
-			const positionu margin { m_margin_x, m_margin_y };
 			positionu pos;
 
 			u16 graph_width = 0;
@@ -116,6 +116,26 @@ namespace rsx
 				graph_height += m_padding;
 			}
 
+			const u16 overlay_width = std::max(m_body.w, graph_width);
+			const u16 overlay_height = static_cast<u16>(m_body.h + graph_height);
+			const auto percent_to_margin_px = [](f32 margin_percent, u16 virtual_size, u16 overlay_size) -> u32
+			{
+				if (overlay_size >= virtual_size)
+				{
+					return 0;
+				}
+
+				const u32 max_margin = virtual_size - overlay_size;
+				const u32 margin_px = static_cast<u32>(std::lround((std::clamp(margin_percent, 0.0f, 100.0f) / 100.0f) * max_margin));
+				return std::min(margin_px, max_margin);
+			};
+
+			const positionu margin
+			{
+				percent_to_margin_px(m_margin_x, m_virtual_width, overlay_width),
+				percent_to_margin_px(m_margin_y, m_virtual_height, overlay_height)
+			};
+
 			switch (m_quadrant)
 			{
 			case screen_quadrant::top_left:
@@ -123,27 +143,27 @@ namespace rsx
 				pos.y = margin.y;
 				break;
 			case screen_quadrant::top_right:
-				pos.x = virtual_width - std::max(m_body.w, graph_width) - margin.x;
+				pos.x = m_virtual_width - overlay_width - margin.x;
 				pos.y = margin.y;
 				break;
 			case screen_quadrant::bottom_left:
 				pos.x = margin.x;
-				pos.y = virtual_height - m_body.h - graph_height - margin.y;
+				pos.y = m_virtual_height - overlay_height - margin.y;
 				break;
 			case screen_quadrant::bottom_right:
-				pos.x = virtual_width - std::max(m_body.w, graph_width) - margin.x;
-				pos.y = virtual_height - m_body.h - graph_height - margin.y;
+				pos.x = m_virtual_width - overlay_width - margin.x;
+				pos.y = m_virtual_height - overlay_height - margin.y;
 				break;
 			}
 
 			if (m_center_x)
 			{
-				pos.x = (virtual_width - std::max(m_body.w, graph_width)) / 2;
+				pos.x = overlay_width >= m_virtual_width ? 0 : (m_virtual_width - overlay_width) / 2;
 			}
 
 			if (m_center_y)
 			{
-				pos.y = (virtual_height - m_body.h - graph_height) / 2;
+				pos.y = overlay_height >= m_virtual_height ? 0 : (m_virtual_height - overlay_height) / 2;
 			}
 
 			elm.set_pos(pos.x, pos.y);
@@ -381,7 +401,7 @@ namespace rsx
 			m_force_repaint = true;
 		}
 
-		void perf_metrics_overlay::set_margins(u32 margin_x, u32 margin_y, bool center_x, bool center_y)
+		void perf_metrics_overlay::set_margins(f32 margin_x, f32 margin_y, bool center_x, bool center_y)
 		{
 			if (m_margin_x == margin_x && m_margin_y == margin_y && m_center_x == center_x && m_center_y == center_y)
 				return;
@@ -431,6 +451,38 @@ namespace rsx
 			m_force_update = true;
 		}
 
+		void perf_metrics_overlay::set_render_viewport(u16 width, u16 height)
+		{
+			u16 new_virtual_width = virtual_width;
+			u16 new_virtual_height = virtual_height;
+
+			if (use_window_space && width > 0 && height > 0)
+			{
+				const double scale_x = static_cast<double>(width) / virtual_width;
+				const double scale_y = static_cast<double>(height) / virtual_height;
+				const double scale = std::min(scale_x, scale_y);
+
+				new_virtual_width = static_cast<u16>(std::min<u32>(
+					static_cast<u32>(std::lround(width / scale)),
+					std::numeric_limits<u16>::max()));
+
+				new_virtual_height = static_cast<u16>(std::min<u32>(
+					static_cast<u32>(std::lround(height / scale)),
+					std::numeric_limits<u16>::max()));
+			}
+
+			if (m_virtual_width == new_virtual_width && m_virtual_height == new_virtual_height)
+				return;
+
+			m_virtual_width = new_virtual_width;
+			m_virtual_height = new_virtual_height;
+
+			if (m_is_initialised)
+			{
+				reset_transforms();
+			}
+		}
+
 		void perf_metrics_overlay::update(u64 /*timestamp_us*/)
 		{
 			const auto elapsed_update = m_update_timer.GetElapsedTimeInMilliSec();
@@ -897,6 +949,7 @@ namespace rsx
 					perf_overlay->set_font(perf_settings.font);
 					perf_overlay->set_font_size(perf_settings.font_size);
 					perf_overlay->set_margins(perf_settings.margin_x, perf_settings.margin_y, perf_settings.center_x.get(), perf_settings.center_y.get());
+					perf_overlay->use_window_space = perf_settings.perf_overlay_use_window_space.get();
 					perf_overlay->set_opacity(perf_settings.opacity / 100.f);
 					perf_overlay->set_body_colors(perf_settings.color_body, perf_settings.background_body);
 					perf_overlay->set_title_colors(perf_settings.color_title, perf_settings.background_title);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.h b/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.h
index 4a121b5231..2b676e591b 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.h
@@ -37,10 +37,12 @@ namespace rsx
 			u32 m_frames{};
 			std::string m_font{};
 			u16 m_font_size{};
-			u32 m_margin_x{}; // horizontal distance to the screen border relative to the screen_quadrant in px
-			u32 m_margin_y{}; // vertical distance to the screen border relative to the screen_quadrant in px
+			f32 m_margin_x{}; // horizontal distance to the screen border relative to the screen_quadrant in percent of the window width
+			f32 m_margin_y{}; // vertical distance to the screen border relative to the screen_quadrant in percent of the window height
 			u32 m_padding{};  // space between overlay elements
 			f32 m_opacity{};  // 0..1
+			u16 m_virtual_width{virtual_width};
+			u16 m_virtual_height{virtual_height};
 
 			bool m_center_x{}; // center the overlay horizontally
 			bool m_center_y{}; // center the overlay vertically
@@ -96,11 +98,14 @@ namespace rsx
 			void set_update_interval(u32 update_interval);
 			void set_font(std::string font);
 			void set_font_size(u16 font_size);
-			void set_margins(u32 margin_x, u32 margin_y, bool center_x, bool center_y);
+			void set_margins(f32 margin_x, f32 margin_y, bool center_x, bool center_y);
 			void set_opacity(f32 opacity);
 			void set_body_colors(std::string color, std::string background);
 			void set_title_colors(std::string color, std::string background);
 			void force_next_update();
+			void set_render_viewport(u16 width, u16 height) override;
+			u16 get_virtual_width() const override { return m_virtual_width; }
+			u16 get_virtual_height() const override { return m_virtual_height; }
 
 			void update(u64 timestamp_us) override;
 
diff --git a/rpcs3/Emu/RSX/Overlays/overlays.h b/rpcs3/Emu/RSX/Overlays/overlays.h
index 2aac6798d2..d9f3986aee 100644
--- a/rpcs3/Emu/RSX/Overlays/overlays.h
+++ b/rpcs3/Emu/RSX/Overlays/overlays.h
@@ -46,6 +46,7 @@ namespace rsx
 
 			static constexpr u16 virtual_width = 1280;
 			static constexpr u16 virtual_height = 720;
+			bool use_window_space = false;
 
 			u32 min_refresh_duration_us = 16600;
 			atomic_t<bool> visible = false;
@@ -57,6 +58,9 @@ namespace rsx
 			virtual compiled_resource get_compiled() = 0;
 
 			void refresh() const;
+			virtual u16 get_virtual_width() const { return virtual_width; }
+			virtual u16 get_virtual_height() const { return virtual_height; }
+			virtual void set_render_viewport(u16 /*width*/, u16 /*height*/) {}
 		};
 
 		// Interactable UI element
diff --git a/rpcs3/Emu/RSX/VK/VKOverlays.cpp b/rpcs3/Emu/RSX/VK/VKOverlays.cpp
index 0436ab527d..684cf8fedb 100644
--- a/rpcs3/Emu/RSX/VK/VKOverlays.cpp
+++ b/rpcs3/Emu/RSX/VK/VKOverlays.cpp
@@ -628,7 +628,11 @@ namespace vk
 	void ui_overlay_renderer::run(vk::command_buffer& cmd, const areau& viewport, vk::framebuffer* target, VkRenderPass render_pass,
 			vk::data_heap& upload_heap, rsx::overlays::overlay& ui)
 	{
-		m_scale_offset = color4f(ui.virtual_width, ui.virtual_height, 1.f, 1.f);
+		ui.set_render_viewport(
+		    static_cast<u16>(std::min<u32>(viewport.width(), std::numeric_limits<u16>::max())),
+		    static_cast<u16>(std::min<u32>(viewport.height(), std::numeric_limits<u16>::max()))
+		);
+		m_scale_offset = color4f(ui.get_virtual_width(), ui.get_virtual_height(), 1.f, 1.f);
 		m_viewport = { { static_cast<f32>(viewport.x1), static_cast<f32>(viewport.y1) }, { static_cast<f32>(viewport.width()), static_cast<f32>(viewport.height()) } };
 
 		std::vector<vk::image_view*> image_views
diff --git a/rpcs3/Emu/RSX/VK/VKPresent.cpp b/rpcs3/Emu/RSX/VK/VKPresent.cpp
index 3b47e28162..16adbadc41 100644
--- a/rpcs3/Emu/RSX/VK/VKPresent.cpp
+++ b/rpcs3/Emu/RSX/VK/VKPresent.cpp
@@ -663,9 +663,11 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
 		auto ui_renderer = vk::get_overlay_pass<vk::ui_overlay_renderer>();
 		std::lock_guard lock(*m_overlay_manager);
 
+		const areau display_area = {0, 0, static_cast<u32>(m_swapchain_dims.width), static_cast<u32>(m_swapchain_dims.height)};
 		for (const auto& view : m_overlay_manager->get_views())
 		{
-			ui_renderer->run(*m_current_command_buffer, area, fbo, single_target_pass, m_texture_upload_buffer_ring_info, *view.get());
+			const areau render_area = view->use_window_space ? display_area : area;
+			ui_renderer->run(*m_current_command_buffer, render_area, fbo, single_target_pass, m_texture_upload_buffer_ring_info, *view.get());
 		}
 	};
 
diff --git a/rpcs3/Emu/localized_string_id.h b/rpcs3/Emu/localized_string_id.h
index 9b91abab99..9387b7f6e7 100644
--- a/rpcs3/Emu/localized_string_id.h
+++ b/rpcs3/Emu/localized_string_id.h
@@ -270,6 +270,7 @@ enum class localized_string_id
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY,
+	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE,
 	HOME_MENU_SETTINGS_DEBUG,
 	HOME_MENU_SETTINGS_DEBUG_OVERLAY,
 	HOME_MENU_SETTINGS_DEBUG_INPUT_OVERLAY,
diff --git a/rpcs3/Emu/system_config.h b/rpcs3/Emu/system_config.h
index 058eda2f12..75d824938f 100644
--- a/rpcs3/Emu/system_config.h
+++ b/rpcs3/Emu/system_config.h
@@ -209,8 +209,8 @@ struct cfg_root : cfg::node
 			cfg::uint<4, 36> font_size{ this, "Font size (px)", 10, true };
 			cfg::_enum<screen_quadrant> position{ this, "Position", screen_quadrant::top_left, true };
 			cfg::string font{ this, "Font", "n023055ms.ttf", true };
-			cfg::uint<0, 1280> margin_x{ this, "Horizontal Margin (px)", 50, true }; // horizontal distance to the screen border relative to the screen_quadrant in px
-			cfg::uint<0, 720> margin_y{ this, "Vertical Margin (px)", 50, true }; // vertical distance to the screen border relative to the screen_quadrant in px
+			cfg::_float<0, 100> margin_x{ this, "Horizontal Margin (%)", 4, true }; // horizontal distance to the window border relative to the screen_quadrant in percent of the window width
+			cfg::_float<0, 100> margin_y{ this, "Vertical Margin (%)", 7, true }; // vertical distance to the window border relative to the screen_quadrant in percent of the window height
 			cfg::_bool center_x{ this, "Center Horizontally", false, true };
 			cfg::_bool center_y{ this, "Center Vertically", false, true };
 			cfg::uint<0, 100> opacity{ this, "Opacity (%)", 70, true };
@@ -218,6 +218,7 @@ struct cfg_root : cfg::node
 			cfg::string background_body{ this, "Body Background (hex)", "#002339FF", true };
 			cfg::string color_title{ this, "Title Color (hex)", "#F26C24FF", true };
 			cfg::string background_title{ this, "Title Background (hex)", "#00000000", true };
+			cfg::_bool perf_overlay_use_window_space{this, "Use Window Space", false, true};
 
 		} perf_overlay{ this };
 
diff --git a/rpcs3/rpcs3qt/emu_settings_type.h b/rpcs3/rpcs3qt/emu_settings_type.h
index fccc13a0dd..9b9f8a9279 100644
--- a/rpcs3/rpcs3qt/emu_settings_type.h
+++ b/rpcs3/rpcs3qt/emu_settings_type.h
@@ -127,6 +127,7 @@ enum class emu_settings_type
 	PerfOverlayMarginY,
 	PerfOverlayCenterX,
 	PerfOverlayCenterY,
+	PerfOverlayUseWindowSpace,
 
 	// Shader Loading Dialog
 	ShaderLoadBgEnabled,
@@ -338,10 +339,11 @@ inline static const std::map<emu_settings_type, cfg_location> settings_location
 	{ emu_settings_type::PerfOverlayUpdateInterval,        { "Video", "Performance Overlay", "Metrics update interval (ms)" } },
 	{ emu_settings_type::PerfOverlayFontSize,              { "Video", "Performance Overlay", "Font size (px)" } },
 	{ emu_settings_type::PerfOverlayOpacity,               { "Video", "Performance Overlay", "Opacity (%)" } },
-	{ emu_settings_type::PerfOverlayMarginX,               { "Video", "Performance Overlay", "Horizontal Margin (px)" } },
-	{ emu_settings_type::PerfOverlayMarginY,               { "Video", "Performance Overlay", "Vertical Margin (px)" } },
+	{ emu_settings_type::PerfOverlayMarginX,               { "Video", "Performance Overlay", "Horizontal Margin (%)" } },
+	{ emu_settings_type::PerfOverlayMarginY,               { "Video", "Performance Overlay", "Vertical Margin (%)" } },
 	{ emu_settings_type::PerfOverlayCenterX,               { "Video", "Performance Overlay", "Center Horizontally" } },
 	{ emu_settings_type::PerfOverlayCenterY,               { "Video", "Performance Overlay", "Center Vertically" } },
+	{ emu_settings_type::PerfOverlayUseWindowSpace, 	   { "Video", "Performance Overlay", "Use Window Space"}},
 
 	// Shader Loading Dialog
 	{ emu_settings_type::ShaderLoadBgEnabled,      { "Video", "Shader Loading Dialog", "Allow custom background" } },
diff --git a/rpcs3/rpcs3qt/localized_emu.h b/rpcs3/rpcs3qt/localized_emu.h
index 8ee62d1603..6f2acb31c7 100644
--- a/rpcs3/rpcs3qt/localized_emu.h
+++ b/rpcs3/rpcs3qt/localized_emu.h
@@ -290,6 +290,7 @@ private:
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_MARGIN_Y: return tr("Vertical Margin", "Performance Overlay");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_FONT_SIZE: return tr("Font Size", "Performance Overlay");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_OPACITY: return tr("Opacity", "Performance Overlay");
+		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_USE_WINDOW_SPACE: return tr("Use Window Space", "Performance Overlay");
 		case localized_string_id::HOME_MENU_SETTINGS_DEBUG: return tr("Debug");
 		case localized_string_id::HOME_MENU_SETTINGS_DEBUG_OVERLAY: return tr("Debug Overlay", "Debug");
 		case localized_string_id::HOME_MENU_SETTINGS_DEBUG_INPUT_OVERLAY: return tr("Input Debug Overlay", "Debug");
diff --git a/rpcs3/rpcs3qt/settings_dialog.cpp b/rpcs3/rpcs3qt/settings_dialog.cpp
index b78eaf973a..c95247748a 100644
--- a/rpcs3/rpcs3qt/settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/settings_dialog.cpp
@@ -1875,6 +1875,9 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	});
 	ui->perfOverlayMarginY->setEnabled(!ui->perfOverlayCenterY->isChecked());
 
+	m_emu_settings->EnhanceCheckBox(ui->perfOverlayUseWindowSpace, emu_settings_type::PerfOverlayUseWindowSpace);
+	SubscribeTooltip(ui->perfOverlayUseWindowSpace, tooltips.settings.perf_overlay_use_window_space);
+
 	m_emu_settings->EnhanceCheckBox(ui->perfOverlayFramerateGraphEnabled, emu_settings_type::PerfOverlayFramerateGraphEnabled);
 	SubscribeTooltip(ui->perfOverlayFramerateGraphEnabled, tooltips.settings.perf_overlay_framerate_graph_enabled);
 
@@ -1901,6 +1904,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 		ui->perfOverlayMarginY->setEnabled(enabled && !ui->perfOverlayCenterY->isChecked());
 		ui->perfOverlayCenterX->setEnabled(enabled);
 		ui->perfOverlayCenterY->setEnabled(enabled);
+		ui->perfOverlayUseWindowSpace->setEnabled(enabled);
 		ui->perfOverlayFramerateGraphEnabled->setEnabled(enabled);
 		ui->perfOverlayFrametimeGraphEnabled->setEnabled(enabled);
 		ui->perf_overlay_framerate_datapoints->setEnabled(enabled);
@@ -1946,10 +1950,10 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	// SpinBoxes
 
-	m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginX, emu_settings_type::PerfOverlayMarginX, "", tr("px", "Performance overlay margin x"));
+	m_emu_settings->EnhanceDoubleSpinBox(ui->perfOverlayMarginX, emu_settings_type::PerfOverlayMarginX, "", tr("%", "Performance overlay margin x"));
 	SubscribeTooltip(ui->perfOverlayMarginX, tooltips.settings.perf_overlay_margin_x);
 
-	m_emu_settings->EnhanceSpinBox(ui->perfOverlayMarginY, emu_settings_type::PerfOverlayMarginY, "", tr("px", "Performance overlay margin y"));
+	m_emu_settings->EnhanceDoubleSpinBox(ui->perfOverlayMarginY, emu_settings_type::PerfOverlayMarginY, "", tr("%", "Performance overlay margin y"));
 	SubscribeTooltip(ui->perfOverlayMarginY, tooltips.settings.perf_overlay_margin_y);
 
 	// Global settings (gui_settings)
diff --git a/rpcs3/rpcs3qt/settings_dialog.ui b/rpcs3/rpcs3qt/settings_dialog.ui
index 0d28134da8..282826fcd6 100644
--- a/rpcs3/rpcs3qt/settings_dialog.ui
+++ b/rpcs3/rpcs3qt/settings_dialog.ui
@@ -3524,7 +3524,14 @@
                   </widget>
                  </item>
                  <item>
-                  <widget class="QSpinBox" name="perfOverlayMarginX"/>
+                  <widget class="QDoubleSpinBox" name="perfOverlayMarginX">
+                   <property name="decimals">
+                    <number>1</number>
+                   </property>
+                   <property name="singleStep">
+                    <double>0.5</double>
+                   </property>
+                  </widget>
                  </item>
                 </layout>
                </item>
@@ -3545,10 +3552,24 @@
                   </widget>
                  </item>
                  <item>
-                  <widget class="QSpinBox" name="perfOverlayMarginY"/>
+                  <widget class="QDoubleSpinBox" name="perfOverlayMarginY">
+                   <property name="decimals">
+                    <number>1</number>
+                   </property>
+                   <property name="singleStep">
+                    <double>0.5</double>
+                   </property>
+                  </widget>
                  </item>
                 </layout>
                </item>
+               <item>
+                <widget class="QCheckBox" name="perfOverlayUseWindowSpace">
+                 <property name="text">
+                  <string>Use Window Space</string>
+                 </property>
+                </widget>
+               </item>
                <item>
                 <widget class="QWidget" name="perf_overlay_update_interval" native="true">
                  <layout class="QVBoxLayout" name="layout_perf_overlay_update_interval">
diff --git a/rpcs3/rpcs3qt/tooltips.h b/rpcs3/rpcs3qt/tooltips.h
index c5a5e5be31..0276ac0f82 100644
--- a/rpcs3/rpcs3qt/tooltips.h
+++ b/rpcs3/rpcs3qt/tooltips.h
@@ -169,10 +169,11 @@ public:
 		const QString perf_overlay_update_interval         = tr("Sets the time interval in which the performance overlay is being updated (measured in milliseconds).\nSetting this to 16 milliseconds will refresh the performance overlay at roughly 60Hz.\nThe performance overlay refresh rate does not affect the frame graph statistics and can only be as fast as the current game allows.");
 		const QString perf_overlay_font_size               = tr("Sets the font size of the performance overlay (measured in pixels).");
 		const QString perf_overlay_opacity                 = tr("Sets the opacity of the performance overlay (measured in %).");
-		const QString perf_overlay_margin_x                = tr("Sets the horizontal distance to the screen border relative to the screen quadrant (measured in pixels).");
-		const QString perf_overlay_margin_y                = tr("Sets the vertical distance to the screen border relative to the screen quadrant (measured in pixels).");
+		const QString perf_overlay_margin_x                = tr("Sets the horizontal distance to the screen border relative to the screen quadrant (measured in %).");
+		const QString perf_overlay_margin_y                = tr("Sets the vertical distance to the screen border relative to the screen quadrant (measured in %).");
 		const QString perf_overlay_center_x                = tr("Centers the performance overlay horizontally and overrides the horizontal margin.");
 		const QString perf_overlay_center_y                = tr("Centers the performance overlay vertically and overrides the vertical margin.");
+		const QString perf_overlay_use_window_space		   = tr("Position overlay relative to the full window surface, enabling placement outside game's render area.");
 
 		const QString shader_load_bg_enabled   = tr("Shows a background image during the native shader loading dialog/loading screen.\nBy default the used image will be <gamedir>/PS3_GAME/PIC1.PNG.");
 		const QString shader_load_bg_darkening = tr("Changes the background image darkening effect strength of the native shader loading dialog.\nThis may be used to improve readability and/or aesthetics.");

From a4523651c7aa188c1b72ea6ec9f1d807a68c2178 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Sat, 24 Jan 2026 22:39:51 +0200
Subject: [PATCH 45/98] RPCS3: Notify RAM shortage, Log current and peak RAM
 usage

---
 Utilities/Thread.cpp                   | 10 ++++++
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp |  2 +-
 rpcs3/Emu/Cell/lv2/sys_fs.cpp          | 46 +++++++-------------------
 rpcs3/Emu/perf_monitor.cpp             | 35 +++++++++++++++-----
 rpcs3/rpcs3.cpp                        |  4 +++
 rpcs3/util/sysinfo.cpp                 | 16 ++++++++-
 rpcs3/util/sysinfo.hpp                 |  2 ++
 7 files changed, 70 insertions(+), 45 deletions(-)

diff --git a/Utilities/Thread.cpp b/Utilities/Thread.cpp
index 9514ed9cdf..b22c1aeb52 100644
--- a/Utilities/Thread.cpp
+++ b/Utilities/Thread.cpp
@@ -2879,6 +2879,16 @@ void thread_base::exec()
 		}
 	}
 
+	if (auto [total, current] = utils::get_memory_usage(); total - current <= 256 * 1024 * 1024)
+	{
+		if (reason_buf.empty())
+		{
+			reason_buf = std::string{reason};
+		}
+
+		fmt::append(reason_buf, " (Possible RAM deficiency: free RAM: %dMB)", (total - current) / (1024 * 1024));
+	}
+
 	if (!reason_buf.empty())
 	{
 		reason = reason_buf;
diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 96d4afa95e..b10845889b 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -8615,7 +8615,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		// Blocks starting from 0x0 or invalid instruction won't be compiled, may need special interpreter fallback
 	}
 
-	if (!m_patterns.empty())
+	if (!m_patterns.empty() && g_cfg.core.spu_debug)
 	{
 		std::string out_dump;
 		dump(result, out_dump);
diff --git a/rpcs3/Emu/Cell/lv2/sys_fs.cpp b/rpcs3/Emu/Cell/lv2/sys_fs.cpp
index ffd31227a8..beec0fc4e4 100644
--- a/rpcs3/Emu/Cell/lv2/sys_fs.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_fs.cpp
@@ -900,10 +900,8 @@ lv2_file::open_raw_result_t lv2_file::open_raw(const std::string& local_path, s3
 		switch (auto error = fs::g_tls_error)
 		{
 		case fs::error::noent: return {CELL_ENOENT};
-		default: sys_fs.error("lv2_file::open(): unknown error %s", error); break;
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO};
 	}
 
 	if (flags & CELL_FS_O_MSELF && !verify_mself(file))
@@ -1374,8 +1372,7 @@ error_code sys_fs_opendir(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<u32> fd)
 		}
 		default:
 		{
-			sys_fs.error("sys_fs_opendir(): unknown error %s", error);
-			return {CELL_EIO, path};
+			fmt::throw_exception("unknown error %s", error);
 		}
 		}
 	}
@@ -1597,8 +1594,7 @@ error_code sys_fs_stat(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<CellFsStat>
 		}
 		default:
 		{
-			sys_fs.error("sys_fs_stat(): unknown error %s", error);
-			return {CELL_EIO, path};
+			fmt::throw_exception("unknown error %s", error);
 		}
 		}
 	}
@@ -1732,10 +1728,8 @@ error_code sys_fs_mkdir(ppu_thread& ppu, vm::cptr<char> path, s32 mode)
 		{
 			return {sys_fs.warning, CELL_EEXIST, path};
 		}
-		default: sys_fs.error("sys_fs_mkdir(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, path}; // ???
 	}
 
 	sys_fs.notice("sys_fs_mkdir(): directory %s created", path);
@@ -1797,10 +1791,8 @@ error_code sys_fs_rename(ppu_thread& ppu, vm::cptr<char> from, vm::cptr<char> to
 		{
 		case fs::error::noent: return {CELL_ENOENT, from};
 		case fs::error::exist: return {CELL_EEXIST, to};
-		default: sys_fs.error("sys_fs_rename(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, from}; // ???
 	}
 
 	sys_fs.notice("sys_fs_rename(): %s renamed to %s", from, to);
@@ -1852,10 +1844,8 @@ error_code sys_fs_rmdir(ppu_thread& ppu, vm::cptr<char> path)
 		{
 		case fs::error::noent: return {CELL_ENOENT, path};
 		case fs::error::notempty: return {CELL_ENOTEMPTY, path};
-		default: sys_fs.error("sys_fs_rmdir(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, path}; // ???
 	}
 
 	sys_fs.notice("sys_fs_rmdir(): directory %s removed", path);
@@ -1910,10 +1900,8 @@ error_code sys_fs_unlink(ppu_thread& ppu, vm::cptr<char> path)
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
 		}
-		default: sys_fs.error("sys_fs_unlink(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, path}; // ???
 	}
 
 	sys_fs.notice("sys_fs_unlink(): file %s deleted", path);
@@ -2632,10 +2620,8 @@ error_code sys_fs_lseek(ppu_thread& ppu, u32 fd, s64 offset, s32 whence, vm::ptr
 		switch (auto error = fs::g_tls_error)
 		{
 		case fs::error::inval: return {CELL_EINVAL, "fd=%u, offset=0x%x, whence=%d", fd, offset, whence};
-		default: sys_fs.error("sys_fs_lseek(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return CELL_EIO; // ???
 	}
 
 	lock.unlock();
@@ -2751,10 +2737,8 @@ error_code sys_fs_get_block_size(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<u
 		{
 		case fs::error::exist: return {CELL_EISDIR, path};
 		case fs::error::noent: return {CELL_ENOENT, path};
-		default: sys_fs.error("sys_fs_get_block_size(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, path}; // ???
 	}
 
 	static_cast<void>(ppu.test_stopped());
@@ -2809,10 +2793,8 @@ error_code sys_fs_truncate(ppu_thread& ppu, vm::cptr<char> path, u64 size)
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
 		}
-		default: sys_fs.error("sys_fs_truncate(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, path}; // ???
 	}
 
 	return CELL_OK;
@@ -2858,10 +2840,8 @@ error_code sys_fs_ftruncate(ppu_thread& ppu, u32 fd, u64 size)
 		switch (auto error = fs::g_tls_error)
 		{
 		case fs::error::ok:
-		default: sys_fs.error("sys_fs_ftruncate(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return CELL_EIO; // ???
 	}
 
 	return CELL_OK;
@@ -3057,10 +3037,8 @@ error_code sys_fs_utime(ppu_thread& ppu, vm::cptr<char> path, vm::cptr<CellFsUti
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
 		}
-		default: sys_fs.error("sys_fs_utime(): unknown error %s", error);
+		default: fmt::throw_exception("unknown error %s", error);
 		}
-
-		return {CELL_EIO, path}; // ???
 	}
 
 	return CELL_OK;
diff --git a/rpcs3/Emu/perf_monitor.cpp b/rpcs3/Emu/perf_monitor.cpp
index 15cdcf498f..ac9560a24f 100644
--- a/rpcs3/Emu/perf_monitor.cpp
+++ b/rpcs3/Emu/perf_monitor.cpp
@@ -4,14 +4,18 @@
 #include "Emu/System.h"
 #include "Emu/Cell/timers.hpp"
 #include "util/cpu_stats.hpp"
+#include "util/sysinfo.hpp"
 #include "Utilities/Thread.h"
 
 LOG_CHANNEL(perf_log, "PERF");
 
 void perf_monitor::operator()()
 {
-	constexpr u64 update_interval_us = 1000000; // Update every second
-	constexpr u64 log_interval_us = 10000000;   // Log every 10 seconds
+	constexpr u64 update_interval_us = 500000; // Update every half second
+	constexpr u64 log_interval_us_max = 10000000; // Log at minimum every 10 seconds
+	constexpr u64 log_interval_us_min = 500000;  // Log at maximum every half a second (catching possible memory leak)
+	constexpr u64 log_mem_increase = 50 * (1024 * 1024);  // Log when memory usage increased by this amount
+
 	u64 elapsed_us = 0;
 
 	utils::cpu_stats stats;
@@ -19,26 +23,28 @@ void perf_monitor::operator()()
 
 	u32 logged_pause = 0;
 	u64 last_pause_time = umax;
+	u64 max_memory_usage = 0;
 
 	std::vector<double> per_core_usage;
 	std::string msg;
 
-	for (u64 sleep_until = get_system_time(); thread_ctrl::state() != thread_state::aborting;)
+	for (u64 sleep_until = get_system_time();;)
 	{
 		thread_ctrl::wait_until(&sleep_until, update_interval_us);
 		elapsed_us += update_interval_us;
 
-		if (thread_ctrl::state() == thread_state::aborting)
-		{
-			break;
-		}
-
 		double total_usage = 0.0;
 
 		stats.get_per_core_usage(per_core_usage, total_usage);
 
-		if (elapsed_us >= log_interval_us)
+		const u64 current_mem_use = utils::get_memory_usage().second;
+		const u64 mem_use_increase = current_mem_use >= max_memory_usage ? current_mem_use - max_memory_usage : 0;
+
+		const u64 log_interval = (mem_use_increase >= log_mem_increase ? log_interval_us_min : log_interval_us_max);
+
+		if (elapsed_us >= log_interval || thread_ctrl::state() == thread_state::aborting)
 		{
+			max_memory_usage = std::max<u64>(current_mem_use, max_memory_usage);
 			elapsed_us = 0;
 
 			const bool is_paused = Emu.IsPaused();
@@ -76,7 +82,18 @@ void perf_monitor::operator()()
 				fmt::append(msg, "%s %.1f%%", i > 0 ? "," : "", per_core_usage[i]);
 			}
 
+			if (max_memory_usage)
+			{
+				fmt::append(msg, ", RAM Usage: %dMB (Peak: %dMB)", current_mem_use / (1024 * 1024), max_memory_usage / (1024 * 1024));
+			}
+
 			perf_log.notice("%s", msg);
+
+			if (thread_ctrl::state() == thread_state::aborting)
+			{
+				// Log once before terminating
+				break;
+			}
 		}
 	}
 }
diff --git a/rpcs3/rpcs3.cpp b/rpcs3/rpcs3.cpp
index cb2058874e..86e3c47171 100644
--- a/rpcs3/rpcs3.cpp
+++ b/rpcs3/rpcs3.cpp
@@ -197,6 +197,10 @@ std::set<std::string> get_one_drive_paths()
 
 		fmt::append(buf, "\nBuild: \"%s\"", rpcs3::get_verbose_version());
 		fmt::append(buf, "\nDate: \"%s\"", std::chrono::system_clock::now());
+
+		const auto [total, current] = utils::get_memory_usage();
+
+		fmt::append(buf, "\nRAM Usage: %dMB/%dMB (%dMB free)", current / (1024 * 1024), total / (1024 * 1024), (total - current) / (1024 * 1024));
 	}
 
 	std::string_view text = s_is_error_launch ? _text : buf;
diff --git a/rpcs3/util/sysinfo.cpp b/rpcs3/util/sysinfo.cpp
index 8abe584a94..81c0b3d31a 100755
--- a/rpcs3/util/sysinfo.cpp
+++ b/rpcs3/util/sysinfo.cpp
@@ -736,6 +736,20 @@ std::string utils::get_firmware_version()
 	return {};
 }
 
+std::pair<u64, u64> utils::get_memory_usage()
+{
+#ifdef _WIN32
+	::MEMORYSTATUSEX status{};
+	status.dwLength = sizeof(status);
+	::GlobalMemoryStatusEx(&status);
+	return { status.ullTotalPhys, status.ullTotalPhys - status.ullAvailPhys };
+
+#else
+	// TODO
+	return { get_total_memory(), 0 };
+#endif
+}
+
 utils::OS_version utils::get_OS_version()
 {
 	OS_version res {};
@@ -1087,7 +1101,7 @@ static const bool s_tsc_freq_evaluated = []() -> bool
 u64 utils::get_total_memory()
 {
 #ifdef _WIN32
-	::MEMORYSTATUSEX memInfo;
+	::MEMORYSTATUSEX memInfo{};
 	memInfo.dwLength = sizeof(memInfo);
 	::GlobalMemoryStatusEx(&memInfo);
 	return memInfo.ullTotalPhys;
diff --git a/rpcs3/util/sysinfo.hpp b/rpcs3/util/sysinfo.hpp
index d9bd0c6660..491c54b088 100755
--- a/rpcs3/util/sysinfo.hpp
+++ b/rpcs3/util/sysinfo.hpp
@@ -71,6 +71,8 @@ namespace utils
 
 	std::string get_firmware_version();
 
+	std::pair<u64, u64> get_memory_usage();
+
 	struct OS_version
 	{
 		std::string type;

From 976cd1ce6640daf6d19a9618c40b100f89fe9434 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Fri, 27 Mar 2026 21:39:33 +0300
Subject: [PATCH 46/98] SaveStates: Fix restart after saving

---
 .../RSX/Overlays/HomeMenu/overlay_home_menu_savestate.cpp   | 2 +-
 rpcs3/Emu/System.cpp                                        | 6 +++---
 rpcs3/Emu/System.h                                          | 2 +-
 rpcs3/rpcs3qt/gs_frame.cpp                                  | 2 +-
 rpcs3/rpcs3qt/main_window.cpp                               | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_savestate.cpp b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_savestate.cpp
index b359fb562c..4d0681193f 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_savestate.cpp
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_savestate.cpp
@@ -26,7 +26,7 @@ namespace rsx
 				{
 					if (!suspend_mode)
 					{
-						Emu.after_kill_callback = []() { Emu.Restart(); };
+						Emu.after_kill_callback = []() { Emu.Restart(true, false); };
 
 						// Make sure we keep the game window opened
 						Emu.SetContinuousMode(true);
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index 7818bd20d5..4fdb5e47f3 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -3996,7 +3996,7 @@ void Emulator::Kill(bool allow_autoexit, bool savestate, savestate_stage* save_s
 	}));
 }
 
-game_boot_result Emulator::Restart(bool graceful)
+game_boot_result Emulator::Restart(bool graceful, bool reset_path)
 {
 	if (m_state == system_state::stopping)
 	{
@@ -4004,7 +4004,7 @@ game_boot_result Emulator::Restart(bool graceful)
 		return game_boot_result::still_running;
 	}
 
-	Emu.after_kill_callback = [this]
+	Emu.after_kill_callback = [this, reset_path]
 	{
 		// Reset boot path in case of ISO
 		if (m_path.starts_with(iso_device::virtual_device_name))
@@ -4016,7 +4016,7 @@ game_boot_result Emulator::Restart(bool graceful)
 		}
 
 		// If continuous mode changed the path, restart from the original executable
-		if (!m_path_original.empty() && m_path_original != m_path)
+		if (reset_path && !m_path_original.empty() && m_path_original != m_path)
 		{
 			sys_log.notice("Restart: Resetting boot path from '%s' to original '%s'", m_path, m_path_original);
 			m_path = m_path_original;
diff --git a/rpcs3/Emu/System.h b/rpcs3/Emu/System.h
index 3bf33bcd52..ac2243389c 100644
--- a/rpcs3/Emu/System.h
+++ b/rpcs3/Emu/System.h
@@ -442,7 +442,7 @@ public:
 	void Resume();
 	void GracefulShutdown(bool allow_autoexit = true, bool async_op = false, bool savestate = false, bool continuous_mode = false);
 	void Kill(bool allow_autoexit = true, bool savestate = false, savestate_stage* stage = nullptr);
-	game_boot_result Restart(bool graceful = true);
+	game_boot_result Restart(bool graceful = true, bool reset_path = true);
 	bool Quit(bool force_quit);
 	static void CleanUp();
 
diff --git a/rpcs3/rpcs3qt/gs_frame.cpp b/rpcs3/rpcs3qt/gs_frame.cpp
index c73db8a687..2dab09d87f 100644
--- a/rpcs3/rpcs3qt/gs_frame.cpp
+++ b/rpcs3/rpcs3qt/gs_frame.cpp
@@ -362,7 +362,7 @@ void gs_frame::handle_shortcut(gui::shortcuts::shortcut shortcut_key, const QKey
 		{
 			Emu.after_kill_callback = []()
 			{
-				Emu.Restart();
+				Emu.Restart(true, false);
 			};
 
 			// Make sure we keep the game window opened
diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index 94157571e8..a82fe5b091 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -2538,7 +2538,7 @@ void main_window::CreateConnects()
 		{
 			Emu.after_kill_callback = []()
 			{
-				Emu.Restart();
+				Emu.Restart(true, false);
 			};
 
 			// Make sure we keep the game window opened

From e2dff6bbf8fce033f1c92ff7afb4d3ae91b3cb47 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 03:05:46 +0300
Subject: [PATCH 47/98] rsx: Implement resolution scale change handling in
 surface cache

---
 rpcs3/Emu/RSX/Common/surface_store.h | 95 +++++++++++++++++++++++++++-
 rpcs3/Emu/RSX/Common/surface_utils.h | 14 ++--
 rpcs3/Emu/RSX/GL/GLPresent.cpp       | 13 ++++
 rpcs3/Emu/RSX/GL/GLRenderTargets.h   | 17 +++--
 rpcs3/Emu/RSX/VK/VKPresent.cpp       | 13 ++++
 rpcs3/Emu/RSX/VK/VKRenderTargets.h   | 17 +++--
 rpcs3/Emu/RSX/rsx_utils.h            |  6 ++
 7 files changed, 155 insertions(+), 20 deletions(-)

diff --git a/rpcs3/Emu/RSX/Common/surface_store.h b/rpcs3/Emu/RSX/Common/surface_store.h
index 51152ea32a..0cfbbe849c 100644
--- a/rpcs3/Emu/RSX/Common/surface_store.h
+++ b/rpcs3/Emu/RSX/Common/surface_store.h
@@ -132,7 +132,7 @@ namespace rsx
 					free_rsx_memory(Traits::get(sink));
 				}
 
-				Traits::clone_surface(cmd, sink, region.source, new_address, region);
+				Traits::clone_surface(cmd, sink, region.source, new_address, region, region.source->resolution_scaling_config);
 				allocate_rsx_memory(Traits::get(sink));
 
 				if (invalidated) [[unlikely]]
@@ -449,7 +449,7 @@ namespace rsx
 					}
 				}
 
-				if (Traits::surface_matches_properties(surface, format, width, height, antialias))
+				if (Traits::surface_matches_properties(surface, format, width, height, antialias, scaling_config))
 				{
 					if (!pitch_compatible)
 					{
@@ -496,7 +496,7 @@ namespace rsx
 				for (auto It = invalidated_resources.begin(); It != invalidated_resources.end(); It++)
 				{
 					auto &surface = *It;
-					if (Traits::surface_matches_properties(surface, format, width, height, antialias, true))
+					if (Traits::surface_matches_properties(surface, format, width, height, antialias, scaling_config, true))
 					{
 						new_surface_storage = std::move(surface);
 						Traits::notify_surface_reused(new_surface_storage);
@@ -1469,5 +1469,94 @@ namespace rsx
 				}
 			}
 		}
+
+		void sync_scaling_config(command_list_type cmd, const rsx::surface_scaling_config_t& active_config)
+		{
+			auto process_list_function = [&](surface_ranged_map& data, const utils::address_range32& range)
+			{
+				std::vector<Traits::surface_type> surfaces_to_clone;
+
+				for (auto It = data.begin_range(range); It != data.end();)
+				{
+					auto surface = Traits::get(It->second);
+					if (surface->get_resolution_scaling_config() == active_config)
+					{
+						++It;
+						continue;
+					}
+
+					surfaces_to_clone.push_back(surface);
+
+					// Invalidate the previous surface
+					invalidate(It->second);
+					It = data.erase(It);
+				}
+
+				for (auto& surface : surfaces_to_clone)
+				{
+					// Enqueue the memory transfer
+					surface_storage_type sink{};
+					deferred_clipped_region<surface_type> copy{};
+					copy.width = surface->template get_surface_width<>();
+					copy.height = surface->template get_surface_height<>();
+					copy.transfer_scale_x = 1.f;
+					copy.transfer_scale_y = 1.f;
+					copy.target = nullptr;
+					copy.source = surface;
+
+					Traits::clone_surface(cmd, sink, surface, surface->base_addr, copy, active_config);
+					allocate_rsx_memory(Traits::get(sink));
+
+					// Replace with the new one
+					ensure(copy.target == Traits::get(sink));
+					data.emplace(surface->get_memory_range(), std::move(sink));
+				}
+			};
+
+			const auto rtt_bind_backup = m_bound_render_targets;
+			const auto dsv_bind_backup = m_bound_depth_stencil;
+
+			// Unbind everything. We'll restore it later
+			for (auto& rtt_bind : m_bound_render_targets)
+			{
+				rtt_bind = {};
+			}
+
+			m_bound_depth_stencil = {};
+
+			process_list_function(m_render_targets_storage, m_render_targets_memory_range);
+			process_list_function(m_depth_stencil_storage, m_depth_stencil_memory_range);
+
+			// Restore bindings.
+			for (int i = 0; i < 4; ++i)
+			{
+				const auto address = rtt_bind_backup[i].first;
+				if (!address)
+				{
+					continue;
+				}
+
+				auto rtt = m_render_targets_storage.find(address);
+				ensure(rtt != m_render_targets_storage.end());
+
+				m_bound_render_targets[i] =
+				{
+					address,
+					Traits::get(rtt->second)
+				};
+			}
+
+			if (const auto ds_address = dsv_bind_backup.first)
+			{
+				auto ds = m_depth_stencil_storage.find(ds_address);
+				ensure(ds != m_depth_stencil_storage.end());
+
+				m_bound_depth_stencil =
+				{
+					ds_address,
+					Traits::get(ds->second)
+				};
+			}
+		}
 	};
 }
diff --git a/rpcs3/Emu/RSX/Common/surface_utils.h b/rpcs3/Emu/RSX/Common/surface_utils.h
index ffd71e6003..e740bf34a7 100644
--- a/rpcs3/Emu/RSX/Common/surface_utils.h
+++ b/rpcs3/Emu/RSX/Common/surface_utils.h
@@ -554,10 +554,14 @@ namespace rsx
 			}
 
 			// Apply resolution scale if needed
-			if (resolution_scaling_config.scale_percent != 100)
+			if (resolution_scaling_config.scale_percent != 100 ||
+				region.source->resolution_scaling_config.scale_percent != 100)
 			{
-				auto [src_width, src_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, slice.width, slice.height, slice.source->width(), slice.source->height());
-				auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(resolution_scaling_config, slice.width, slice.height, slice.target->width(), slice.target->height());
+				const auto& src_res_scale = region.source->resolution_scaling_config;
+				const auto& dst_res_scale = resolution_scaling_config;
+
+				auto [src_width, src_height] = rsx::apply_resolution_scale<true>(src_res_scale, slice.width, slice.height, slice.source->width(), slice.source->height());
+				auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(dst_res_scale, slice.width, slice.height, slice.target->width(), slice.target->height());
 
 				slice.transfer_scale_x *= f32(dst_width) / src_width;
 				slice.transfer_scale_y *= f32(dst_height) / src_height;
@@ -565,8 +569,8 @@ namespace rsx
 				slice.width = src_width;
 				slice.height = src_height;
 
-				std::tie(slice.src_x, slice.src_y) = rsx::apply_resolution_scale<false>(resolution_scaling_config, slice.src_x, slice.src_y, slice.source->width(), slice.source->height());
-				std::tie(slice.dst_x, slice.dst_y) = rsx::apply_resolution_scale<false>(resolution_scaling_config, slice.dst_x, slice.dst_y, slice.target->width(), slice.target->height());
+				std::tie(slice.src_x, slice.src_y) = rsx::apply_resolution_scale<false>(src_res_scale, slice.src_x, slice.src_y, slice.source->width(), slice.source->height());
+				std::tie(slice.dst_x, slice.dst_y) = rsx::apply_resolution_scale<false>(dst_res_scale, slice.dst_x, slice.dst_y, slice.target->width(), slice.target->height());
 			}
 		}
 
diff --git a/rpcs3/Emu/RSX/GL/GLPresent.cpp b/rpcs3/Emu/RSX/GL/GLPresent.cpp
index 2e23ca33b6..2aa11868ee 100644
--- a/rpcs3/Emu/RSX/GL/GLPresent.cpp
+++ b/rpcs3/Emu/RSX/GL/GLPresent.cpp
@@ -517,6 +517,19 @@ void GLGSRender::flip(const rsx::display_flip_info_t& info)
 	m_frame->flip(m_context);
 	rsx::thread::flip(info);
 
+	// Data sync
+	const rsx::surface_scaling_config_t active_res_scaling_config =
+	{
+		.scale_percent = static_cast<u16>(g_cfg.video.resolution_scale_percent),
+		.min_scalable_dimension = static_cast<u16>(g_cfg.video.min_scalable_dimension),
+	};
+
+	if (active_res_scaling_config != this->resolution_scaling_config)
+	{
+		m_rtts.sync_scaling_config(cmd, active_res_scaling_config);
+		this->resolution_scaling_config = active_res_scaling_config;
+	}
+
 	// Cleanup
 	m_gl_texture_cache.on_frame_end();
 	m_vertex_cache->purge();
diff --git a/rpcs3/Emu/RSX/GL/GLRenderTargets.h b/rpcs3/Emu/RSX/GL/GLRenderTargets.h
index ecf7e161da..f5e2252b92 100644
--- a/rpcs3/Emu/RSX/GL/GLRenderTargets.h
+++ b/rpcs3/Emu/RSX/GL/GLRenderTargets.h
@@ -229,13 +229,14 @@ struct gl_render_target_traits
 	void clone_surface(
 		gl::command_context& cmd,
 		std::unique_ptr<gl::render_target>& sink, gl::render_target* ref,
-		u32 address, barrier_descriptor_t& prev)
+		u32 address, barrier_descriptor_t& prev,
+		const rsx::surface_scaling_config_t& scaling_config)
 	{
 		if (!sink)
 		{
 			auto internal_format = static_cast<GLenum>(ref->get_internal_format());
 			const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(
-				ref->resolution_scaling_config,
+				scaling_config,
 				prev.width, prev.height,
 				ref->get_surface_width<rsx::surface_metrics::pixels>(),
 				ref->get_surface_height<rsx::surface_metrics::pixels>());
@@ -248,7 +249,7 @@ struct gl_render_target_traits
 			sink->format_info = ref->format_info;
 
 			sink->sample_layout = ref->sample_layout;
-			sink->resolution_scaling_config = ref->resolution_scaling_config;
+			sink->resolution_scaling_config = scaling_config;
 
 			sink->set_name(fmt::format("SINK_%u@0x%x", sink->id(), address));
 			sink->set_spp(ref->get_spp());
@@ -385,6 +386,7 @@ struct gl_render_target_traits
 		gl::texture::internal_format format,
 		usz width, usz height,
 		rsx::surface_antialiasing antialias,
+		const rsx::surface_scaling_config_t& scaling_config,
 		bool check_refs = false)
 	{
 		if (check_refs && surface->has_refs())
@@ -392,7 +394,8 @@ struct gl_render_target_traits
 
 		return surface->get_internal_format() == format &&
 			surface->get_spp() == get_format_sample_count(antialias) &&
-			surface->matches_dimensions(static_cast<u16>(width), static_cast<u16>(height));
+			surface->matches_dimensions(static_cast<u16>(width), static_cast<u16>(height)) &&
+			surface->resolution_scaling_config == scaling_config;
 	}
 
 	static
@@ -401,10 +404,11 @@ struct gl_render_target_traits
 		rsx::surface_color_format format,
 		usz width, usz height,
 		rsx::surface_antialiasing antialias,
+		const rsx::surface_scaling_config_t& scaling_config,
 		bool check_refs=false)
 	{
 		const auto internal_fmt = rsx::internals::surface_color_format_to_gl(format).internal_format;
-		return int_surface_matches_properties(surface, internal_fmt, width, height, antialias, check_refs);
+		return int_surface_matches_properties(surface, internal_fmt, width, height, antialias, scaling_config, check_refs);
 	}
 
 	static
@@ -413,10 +417,11 @@ struct gl_render_target_traits
 		rsx::surface_depth_format2 format,
 		usz width, usz height,
 		rsx::surface_antialiasing antialias,
+		const rsx::surface_scaling_config_t& scaling_config,
 		bool check_refs = false)
 	{
 		const auto internal_fmt = rsx::internals::surface_depth_format_to_gl(format).internal_format;
-		return int_surface_matches_properties(surface, internal_fmt, width, height, antialias, check_refs);
+		return int_surface_matches_properties(surface, internal_fmt, width, height, antialias, scaling_config, check_refs);
 	}
 
 	static
diff --git a/rpcs3/Emu/RSX/VK/VKPresent.cpp b/rpcs3/Emu/RSX/VK/VKPresent.cpp
index 16adbadc41..47f59381bb 100644
--- a/rpcs3/Emu/RSX/VK/VKPresent.cpp
+++ b/rpcs3/Emu/RSX/VK/VKPresent.cpp
@@ -963,4 +963,17 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
 
 	m_frame->flip(m_context);
 	rsx::thread::flip(info);
+
+	// Data sync
+	const rsx::surface_scaling_config_t active_res_scaling_config =
+	{
+		.scale_percent = static_cast<u16>(g_cfg.video.resolution_scale_percent),
+		.min_scalable_dimension = static_cast<u16>(g_cfg.video.min_scalable_dimension),
+	};
+
+	if (active_res_scaling_config != this->resolution_scaling_config)
+	{
+		m_rtts.sync_scaling_config(*m_current_command_buffer, active_res_scaling_config);
+		this->resolution_scaling_config = active_res_scaling_config;
+	}
 }
diff --git a/rpcs3/Emu/RSX/VK/VKRenderTargets.h b/rpcs3/Emu/RSX/VK/VKRenderTargets.h
index 7d4f515b4e..c040e9bca0 100644
--- a/rpcs3/Emu/RSX/VK/VKRenderTargets.h
+++ b/rpcs3/Emu/RSX/VK/VKRenderTargets.h
@@ -337,12 +337,13 @@ namespace vk
 		static void clone_surface(
 			vk::command_buffer& cmd,
 			std::unique_ptr<vk::render_target>& sink, vk::render_target* ref,
-			u32 address, barrier_descriptor_t& prev)
+			u32 address, barrier_descriptor_t& prev,
+			const rsx::surface_scaling_config_t& scaling_config)
 		{
 			if (!sink)
 			{
 				const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(
-					ref->resolution_scaling_config,
+					scaling_config,
 					prev.width, prev.height,
 					ref->get_surface_width<rsx::surface_metrics::pixels>(), ref->get_surface_height<rsx::surface_metrics::pixels>());
 
@@ -363,7 +364,7 @@ namespace vk
 				sink->add_ref();
 
 				sink->sample_layout = ref->sample_layout;
-				sink->resolution_scaling_config = ref->resolution_scaling_config;
+				sink->resolution_scaling_config = scaling_config;
 
 				sink->set_spp(ref->get_spp());
 				sink->format_info = ref->format_info;
@@ -521,6 +522,7 @@ namespace vk
 			VkFormat format,
 			usz width, usz height,
 			rsx::surface_antialiasing antialias,
+			const rsx::surface_scaling_config_t& scaling_config,
 			bool check_refs)
 		{
 			if (check_refs && surface->has_refs())
@@ -531,7 +533,8 @@ namespace vk
 
 			return (surface->info.format == format &&
 				surface->get_spp() == get_format_sample_count(antialias) &&
-				surface->matches_dimensions(static_cast<u16>(width), static_cast<u16>(height)));
+				surface->matches_dimensions(static_cast<u16>(width), static_cast<u16>(height))) &&
+				surface->resolution_scaling_config == scaling_config;
 		}
 
 		static bool surface_matches_properties(
@@ -539,10 +542,11 @@ namespace vk
 			rsx::surface_color_format format,
 			usz width, usz height,
 			rsx::surface_antialiasing antialias,
+			const rsx::surface_scaling_config_t& scaling_config,
 			bool check_refs = false)
 		{
 			VkFormat vk_format = vk::get_compatible_surface_format(format).first;
-			return int_surface_matches_properties(surface, vk_format, width, height, antialias, check_refs);
+			return int_surface_matches_properties(surface, vk_format, width, height, antialias, scaling_config, check_refs);
 		}
 
 		static bool surface_matches_properties(
@@ -550,11 +554,12 @@ namespace vk
 			rsx::surface_depth_format2 format,
 			usz width, usz height,
 			rsx::surface_antialiasing antialias,
+			const rsx::surface_scaling_config_t& scaling_config,
 			bool check_refs = false)
 		{
 			auto device = vk::get_current_renderer();
 			VkFormat vk_format = vk::get_compatible_depth_surface_format(device->get_formats_support(), format);
-			return int_surface_matches_properties(surface, vk_format, width, height, antialias, check_refs);
+			return int_surface_matches_properties(surface, vk_format, width, height, antialias, scaling_config, check_refs);
 		}
 
 		static void spill_buffer(std::unique_ptr<vk::buffer>& /*bo*/)
diff --git a/rpcs3/Emu/RSX/rsx_utils.h b/rpcs3/Emu/RSX/rsx_utils.h
index 310af56dab..79aef602c6 100644
--- a/rpcs3/Emu/RSX/rsx_utils.h
+++ b/rpcs3/Emu/RSX/rsx_utils.h
@@ -220,6 +220,12 @@ namespace rsx
 		u16 min_scalable_dimension = 0;
 
 		f32 scale_factor() const { return scale_percent * 0.01f; }
+
+		bool operator == (const surface_scaling_config_t& that) const
+		{
+			return this->scale_percent == that.scale_percent &&
+				this->min_scalable_dimension == that.min_scalable_dimension;
+		}
 	};
 
 	template <typename T>

From fe3cbde1d3a0b18edca4c978fdb36779a1e8cd24 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 03:10:31 +0300
Subject: [PATCH 48/98] rsx: Add optimization to skip cloning surfaces whose
 dimensions did not change

- If only the threshold changed or the surface is below threshold anyway, nothing will change
- In those cases, just update the internal data and continue
---
 rpcs3/Emu/RSX/Common/surface_store.h | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/rpcs3/Emu/RSX/Common/surface_store.h b/rpcs3/Emu/RSX/Common/surface_store.h
index 0cfbbe849c..70007178fa 100644
--- a/rpcs3/Emu/RSX/Common/surface_store.h
+++ b/rpcs3/Emu/RSX/Common/surface_store.h
@@ -1485,6 +1485,21 @@ namespace rsx
 						continue;
 					}
 
+					// Perform a test scaling and check if anything is different after scaling
+					// There are many cases where this will avoid creating new surfaces
+					const auto [new_w, new_h] = rsx::apply_inverse_resolution_scale<true>(
+						active_config,
+						surface->template get_surface_width<>(),
+						surface->template get_surface_height<>());
+
+					if (new_w == surface->width() && new_h == surface->height())
+					{
+						// Not affected by resolution scale. Just update the details and move on.
+						surface->resolution_scaling_config = active_config;
+						++It;
+						continue;
+					}
+
 					surfaces_to_clone.push_back(surface);
 
 					// Invalidate the previous surface

From c00fa2cc8c6fd49fcff1a208cd1507bd73dc5fdc Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 03:39:30 +0300
Subject: [PATCH 49/98] config: Make resolution scaling a dynamic option

---
 rpcs3/Emu/system_config.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/system_config.h b/rpcs3/Emu/system_config.h
index 75d824938f..6403754dd8 100644
--- a/rpcs3/Emu/system_config.h
+++ b/rpcs3/Emu/system_config.h
@@ -161,7 +161,7 @@ struct cfg_root : cfg::node
 		cfg::_bool precise_zpass_count{ this, "Accurate ZCULL stats", true };
 		cfg::_int<1, 8> consecutive_frames_to_draw{ this, "Consecutive Frames To Draw", 1, true};
 		cfg::_int<1, 8> consecutive_frames_to_skip{ this, "Consecutive Frames To Skip", 1, true};
-		cfg::_int<25, 800> resolution_scale_percent{ this, "Resolution Scale", 100 };
+		cfg::_int<25, 800> resolution_scale_percent{ this, "Resolution Scale", 100, true };
 		cfg::uint<0, 16> anisotropic_level_override{ this, "Anisotropic Filter Override", 0, true };
 		cfg::_float<-32, 32> texture_lod_bias{ this, "Texture LOD Bias Addend", 0, true };
 		cfg::_int<1, 1024> min_scalable_dimension{ this, "Minimum Scalable Dimension", 16 };

From 91c136b6d0db5de188bfcac5f8ae1962aa4c73de Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 03:54:23 +0300
Subject: [PATCH 50/98] rsx/overlay: Add resolution scale slider to home menu

---
 .../RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp   | 7 +++----
 rpcs3/Emu/localized_string_id.h                            | 1 +
 rpcs3/Emu/system_config.h                                  | 2 +-
 rpcs3/rpcs3qt/localized_emu.h                              | 1 +
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
index 1a2f99dca3..3d9439c112 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
@@ -152,16 +152,15 @@ namespace rsx
 		home_menu_settings_video::home_menu_settings_video(s16 x, s16 y, u16 width, u16 height, bool use_separators, home_menu_page* parent)
 			: home_menu_settings_page(x, y, width, height, use_separators, parent, get_localized_string(localized_string_id::HOME_MENU_SETTINGS_VIDEO))
 		{
+			add_unsigned_slider(&g_cfg.video.resolution_scale_percent, localized_string_id::HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_PERCENT, "%", 25);
+
 			add_dropdown(&g_cfg.video.vsync, localized_string_id::HOME_MENU_SETTINGS_VIDEO_VSYNC);
 
 			add_dropdown(&g_cfg.video.frame_limit, localized_string_id::HOME_MENU_SETTINGS_VIDEO_FRAME_LIMIT);
 			add_unsigned_slider(&g_cfg.video.anisotropic_level_override, localized_string_id::HOME_MENU_SETTINGS_VIDEO_ANISOTROPIC_OVERRIDE, "x", 2, {{0, "Auto"}}, {14});
 
 			add_dropdown(&g_cfg.video.output_scaling, localized_string_id::HOME_MENU_SETTINGS_VIDEO_OUTPUT_SCALING);
-			if (g_cfg.video.renderer == video_renderer::vulkan && g_cfg.video.output_scaling == output_scaling_mode::fsr)
-			{
-				add_unsigned_slider(&g_cfg.video.rcas_sharpening_intensity, localized_string_id::HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING, " %", 1);
-			}
+			add_unsigned_slider(&g_cfg.video.rcas_sharpening_intensity, localized_string_id::HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING, " %", 1);
 
 			add_checkbox(&g_cfg.video.stretch_to_display_area, localized_string_id::HOME_MENU_SETTINGS_VIDEO_STRETCH_TO_DISPLAY);
 
diff --git a/rpcs3/Emu/localized_string_id.h b/rpcs3/Emu/localized_string_id.h
index 9387b7f6e7..08fb639bcf 100644
--- a/rpcs3/Emu/localized_string_id.h
+++ b/rpcs3/Emu/localized_string_id.h
@@ -222,6 +222,7 @@ enum class localized_string_id
 	HOME_MENU_SETTINGS_VIDEO_ANISOTROPIC_OVERRIDE,
 	HOME_MENU_SETTINGS_VIDEO_OUTPUT_SCALING,
 	HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING,
+	HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_PERCENT,
 	HOME_MENU_SETTINGS_VIDEO_STRETCH_TO_DISPLAY,
 	HOME_MENU_SETTINGS_VIDEO_STEREO_MODE,
 	HOME_MENU_SETTINGS_INPUT,
diff --git a/rpcs3/Emu/system_config.h b/rpcs3/Emu/system_config.h
index 6403754dd8..38dbea98f8 100644
--- a/rpcs3/Emu/system_config.h
+++ b/rpcs3/Emu/system_config.h
@@ -161,7 +161,7 @@ struct cfg_root : cfg::node
 		cfg::_bool precise_zpass_count{ this, "Accurate ZCULL stats", true };
 		cfg::_int<1, 8> consecutive_frames_to_draw{ this, "Consecutive Frames To Draw", 1, true};
 		cfg::_int<1, 8> consecutive_frames_to_skip{ this, "Consecutive Frames To Skip", 1, true};
-		cfg::_int<25, 800> resolution_scale_percent{ this, "Resolution Scale", 100, true };
+		cfg::uint<25, 800> resolution_scale_percent{ this, "Resolution Scale", 100, true };
 		cfg::uint<0, 16> anisotropic_level_override{ this, "Anisotropic Filter Override", 0, true };
 		cfg::_float<-32, 32> texture_lod_bias{ this, "Texture LOD Bias Addend", 0, true };
 		cfg::_int<1, 1024> min_scalable_dimension{ this, "Minimum Scalable Dimension", 16 };
diff --git a/rpcs3/rpcs3qt/localized_emu.h b/rpcs3/rpcs3qt/localized_emu.h
index 6f2acb31c7..c0a0780860 100644
--- a/rpcs3/rpcs3qt/localized_emu.h
+++ b/rpcs3/rpcs3qt/localized_emu.h
@@ -242,6 +242,7 @@ private:
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_ANISOTROPIC_OVERRIDE: return tr("Anisotropic Filter Override", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_OUTPUT_SCALING: return tr("Output Scaling", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING: return tr("FidelityFX CAS Sharpening Intensity", "Video");
+		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_PERCENT: return tr("Resolution Scale", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_STRETCH_TO_DISPLAY: return tr("Stretch To Display Area", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_STEREO_MODE: return tr("Stereo Mode", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_INPUT: return tr("Input");

From b57390d3cd8d6d232f52755216970deaffcf2c45 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 04:03:54 +0300
Subject: [PATCH 51/98] rsx/overlays: Add resolution scale threshold to home
 menu

---
 rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp | 1 +
 rpcs3/Emu/localized_string_id.h                                | 1 +
 rpcs3/Emu/system_config.h                                      | 2 +-
 rpcs3/rpcs3qt/localized_emu.h                                  | 1 +
 4 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
index 3d9439c112..65a3b4263d 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
@@ -153,6 +153,7 @@ namespace rsx
 			: home_menu_settings_page(x, y, width, height, use_separators, parent, get_localized_string(localized_string_id::HOME_MENU_SETTINGS_VIDEO))
 		{
 			add_unsigned_slider(&g_cfg.video.resolution_scale_percent, localized_string_id::HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_PERCENT, "%", 25);
+			add_unsigned_slider(&g_cfg.video.min_scalable_dimension, localized_string_id::HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_THRESHOLD, "px", 1);
 
 			add_dropdown(&g_cfg.video.vsync, localized_string_id::HOME_MENU_SETTINGS_VIDEO_VSYNC);
 
diff --git a/rpcs3/Emu/localized_string_id.h b/rpcs3/Emu/localized_string_id.h
index 08fb639bcf..0bcf1caf8b 100644
--- a/rpcs3/Emu/localized_string_id.h
+++ b/rpcs3/Emu/localized_string_id.h
@@ -223,6 +223,7 @@ enum class localized_string_id
 	HOME_MENU_SETTINGS_VIDEO_OUTPUT_SCALING,
 	HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING,
 	HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_PERCENT,
+	HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_THRESHOLD,
 	HOME_MENU_SETTINGS_VIDEO_STRETCH_TO_DISPLAY,
 	HOME_MENU_SETTINGS_VIDEO_STEREO_MODE,
 	HOME_MENU_SETTINGS_INPUT,
diff --git a/rpcs3/Emu/system_config.h b/rpcs3/Emu/system_config.h
index 38dbea98f8..099e0243a1 100644
--- a/rpcs3/Emu/system_config.h
+++ b/rpcs3/Emu/system_config.h
@@ -164,7 +164,7 @@ struct cfg_root : cfg::node
 		cfg::uint<25, 800> resolution_scale_percent{ this, "Resolution Scale", 100, true };
 		cfg::uint<0, 16> anisotropic_level_override{ this, "Anisotropic Filter Override", 0, true };
 		cfg::_float<-32, 32> texture_lod_bias{ this, "Texture LOD Bias Addend", 0, true };
-		cfg::_int<1, 1024> min_scalable_dimension{ this, "Minimum Scalable Dimension", 16 };
+		cfg::uint<1, 1024> min_scalable_dimension{ this, "Minimum Scalable Dimension", 16, true };
 		cfg::_int<0, 16> shader_compiler_threads_count{ this, "Shader Compiler Threads", 0 };
 		cfg::_int<0, 30000000> driver_recovery_timeout{ this, "Driver Recovery Timeout", 1000000, true };
 		cfg::uint<0, 16667> driver_wakeup_delay{ this, "Driver Wake-Up Delay", 0, true };
diff --git a/rpcs3/rpcs3qt/localized_emu.h b/rpcs3/rpcs3qt/localized_emu.h
index c0a0780860..fe0451b44c 100644
--- a/rpcs3/rpcs3qt/localized_emu.h
+++ b/rpcs3/rpcs3qt/localized_emu.h
@@ -243,6 +243,7 @@ private:
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_OUTPUT_SCALING: return tr("Output Scaling", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_RCAS_SHARPENING: return tr("FidelityFX CAS Sharpening Intensity", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_PERCENT: return tr("Resolution Scale", "Video");
+		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_RESOLUTION_SCALE_THRESHOLD: return tr("Resolution Scale Threshold", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_STRETCH_TO_DISPLAY: return tr("Stretch To Display Area", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_VIDEO_STEREO_MODE: return tr("Stereo Mode", "Video");
 		case localized_string_id::HOME_MENU_SETTINGS_INPUT: return tr("Input");

From 64c24959cb519f623990d1b54f9337fffe53fee9 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 04:13:33 +0300
Subject: [PATCH 52/98] rsx: Fix clang build

---
 rpcs3/Emu/RSX/Common/surface_store.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Common/surface_store.h b/rpcs3/Emu/RSX/Common/surface_store.h
index 70007178fa..d3e9db45b2 100644
--- a/rpcs3/Emu/RSX/Common/surface_store.h
+++ b/rpcs3/Emu/RSX/Common/surface_store.h
@@ -1474,7 +1474,7 @@ namespace rsx
 		{
 			auto process_list_function = [&](surface_ranged_map& data, const utils::address_range32& range)
 			{
-				std::vector<Traits::surface_type> surfaces_to_clone;
+				std::vector<surface_type> surfaces_to_clone;
 
 				for (auto It = data.begin_range(range); It != data.end();)
 				{

From 0052108e876a384b637259468d8e7627d99d66ef Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 13:12:23 +0300
Subject: [PATCH 53/98] rsx/rtt: Fix transfer region calculation when source
 and destination scaling does not match

---
 rpcs3/Emu/RSX/Common/surface_utils.h | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/rpcs3/Emu/RSX/Common/surface_utils.h b/rpcs3/Emu/RSX/Common/surface_utils.h
index e740bf34a7..8ec97600bc 100644
--- a/rpcs3/Emu/RSX/Common/surface_utils.h
+++ b/rpcs3/Emu/RSX/Common/surface_utils.h
@@ -559,9 +559,11 @@ namespace rsx
 			{
 				const auto& src_res_scale = region.source->resolution_scaling_config;
 				const auto& dst_res_scale = resolution_scaling_config;
+				const auto src_surface = ensure(dynamic_cast<const render_target_descriptor*>(slice.source));
+				const auto dst_surface = ensure(dynamic_cast<const render_target_descriptor*>(slice.target));
 
-				auto [src_width, src_height] = rsx::apply_resolution_scale<true>(src_res_scale, slice.width, slice.height, slice.source->width(), slice.source->height());
-				auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(dst_res_scale, slice.width, slice.height, slice.target->width(), slice.target->height());
+				auto [src_width, src_height] = rsx::apply_resolution_scale<true>(src_res_scale, slice.width, slice.height, src_surface->get_surface_width(), src_surface->get_surface_height());
+				auto [dst_width, dst_height] = rsx::apply_resolution_scale<true>(dst_res_scale, slice.width, slice.height, dst_surface->get_surface_width(), dst_surface->get_surface_height());
 
 				slice.transfer_scale_x *= f32(dst_width) / src_width;
 				slice.transfer_scale_y *= f32(dst_height) / src_height;
@@ -569,8 +571,8 @@ namespace rsx
 				slice.width = src_width;
 				slice.height = src_height;
 
-				std::tie(slice.src_x, slice.src_y) = rsx::apply_resolution_scale<false>(src_res_scale, slice.src_x, slice.src_y, slice.source->width(), slice.source->height());
-				std::tie(slice.dst_x, slice.dst_y) = rsx::apply_resolution_scale<false>(dst_res_scale, slice.dst_x, slice.dst_y, slice.target->width(), slice.target->height());
+				std::tie(slice.src_x, slice.src_y) = rsx::apply_resolution_scale<false>(src_res_scale, slice.src_x, slice.src_y, src_surface->get_surface_width(), src_surface->get_surface_height());
+				std::tie(slice.dst_x, slice.dst_y) = rsx::apply_resolution_scale<false>(dst_res_scale, slice.dst_x, slice.dst_y, dst_surface->get_surface_width(), dst_surface->get_surface_height());
 			}
 		}
 

From 069821a2e79a14dd5035c19b7f34990cc7887e28 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 13:13:36 +0300
Subject: [PATCH 54/98] rsx/rtts: Fix broken optimization check

- Typo. Applying inverse res scale is really not what we want
---
 rpcs3/Emu/RSX/Common/surface_store.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Common/surface_store.h b/rpcs3/Emu/RSX/Common/surface_store.h
index d3e9db45b2..88268de22c 100644
--- a/rpcs3/Emu/RSX/Common/surface_store.h
+++ b/rpcs3/Emu/RSX/Common/surface_store.h
@@ -1487,7 +1487,7 @@ namespace rsx
 
 					// Perform a test scaling and check if anything is different after scaling
 					// There are many cases where this will avoid creating new surfaces
-					const auto [new_w, new_h] = rsx::apply_inverse_resolution_scale<true>(
+					const auto [new_w, new_h] = rsx::apply_resolution_scale<true>(
 						active_config,
 						surface->template get_surface_width<>(),
 						surface->template get_surface_height<>());

From 51ea735cb5fab5f3ab0dda756f19a753aaa07451 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sat, 28 Mar 2026 19:33:35 +0300
Subject: [PATCH 55/98] rsx/vk: Try to reclaim memory aggressively when
 changing resolution scale

---
 rpcs3/Emu/RSX/Common/surface_store.h |  6 +++++-
 rpcs3/Emu/RSX/VK/VKPresent.cpp       | 16 ++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Common/surface_store.h b/rpcs3/Emu/RSX/Common/surface_store.h
index 88268de22c..4b3aaa0605 100644
--- a/rpcs3/Emu/RSX/Common/surface_store.h
+++ b/rpcs3/Emu/RSX/Common/surface_store.h
@@ -1523,8 +1523,12 @@ namespace rsx
 					allocate_rsx_memory(Traits::get(sink));
 
 					// Replace with the new one
-					ensure(copy.target == Traits::get(sink));
+					auto new_surface = Traits::get(sink);
+					ensure(copy.target == new_surface);
 					data.emplace(surface->get_memory_range(), std::move(sink));
+
+					// Force barrier to reduce VRAM pressure
+					new_surface->memory_barrier(cmd, rsx::surface_access::memory_read);
 				}
 			};
 
diff --git a/rpcs3/Emu/RSX/VK/VKPresent.cpp b/rpcs3/Emu/RSX/VK/VKPresent.cpp
index 47f59381bb..432e8c7e87 100644
--- a/rpcs3/Emu/RSX/VK/VKPresent.cpp
+++ b/rpcs3/Emu/RSX/VK/VKPresent.cpp
@@ -1,6 +1,7 @@
 #include "stdafx.h"
 #include "VKGSRender.h"
 #include "vkutils/buffer_object.h"
+#include "vkutils/memory.h"
 #include "Emu/RSX/Overlays/overlay_manager.h"
 #include "Emu/RSX/Overlays/overlay_debug_overlay.h"
 #include "Emu/Cell/Modules/cellVideoOut.h"
@@ -973,7 +974,22 @@ void VKGSRender::flip(const rsx::display_flip_info_t& info)
 
 	if (active_res_scaling_config != this->resolution_scaling_config)
 	{
+		// First, try to reclaim any memory since the res scale upgrade is so memory intensive
+		if (const auto severity = vk::vmm_determine_memory_load_severity();
+			severity > rsx::problem_severity::low && m_rtts.handle_memory_pressure(*m_current_command_buffer, severity))
+		{
+			flush_command_queue(true);
+		}
+
+		// Then apply the change
 		m_rtts.sync_scaling_config(*m_current_command_buffer, active_res_scaling_config);
 		this->resolution_scaling_config = active_res_scaling_config;
+
+		// Finally reclaim any unused resources
+		if (const auto severity = vk::vmm_determine_memory_load_severity();
+			severity > rsx::problem_severity::low && m_rtts.handle_memory_pressure(*m_current_command_buffer, severity))
+		{
+			flush_command_queue(true);
+		}
 	}
 }

From f0f9ef6f3057dfb201dbdbab519207afc9f2bfe4 Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Fri, 13 Mar 2026 13:55:51 +0100
Subject: [PATCH 56/98] cmake: fix build with latest Curl

---
 buildfiles/cmake/FindWolfSSL.cmake | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/buildfiles/cmake/FindWolfSSL.cmake b/buildfiles/cmake/FindWolfSSL.cmake
index d2e30be60b..35f316837c 100644
--- a/buildfiles/cmake/FindWolfSSL.cmake
+++ b/buildfiles/cmake/FindWolfSSL.cmake
@@ -1,4 +1,3 @@
-set(WOLFSSL_LIBRARY ON)
-set(WOLFSSL_INCLUDE_DIR ON)
-set(WOLFSSL_LIBRARIES wolfssl)
+set(WOLFSSL_LIBRARY wolfssl)
+set(WOLFSSL_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/3rdparty/wolfssl)
 set(WOLFSSL_FOUND TRUE)

From e6204d3c1d1ef048a220025bf75851f53f6751c3 Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Fri, 27 Mar 2026 17:20:42 +0100
Subject: [PATCH 57/98] CMake: fix the case USE_SYSTEM_ZLIB=OFF and
 USE_SYSTEM_CURL=OFF

---
 buildfiles/cmake/FindZLIB.cmake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/buildfiles/cmake/FindZLIB.cmake b/buildfiles/cmake/FindZLIB.cmake
index 0a29abafa9..ff5869a5f7 100644
--- a/buildfiles/cmake/FindZLIB.cmake
+++ b/buildfiles/cmake/FindZLIB.cmake
@@ -3,9 +3,9 @@ if(USE_SYSTEM_ZLIB)
     find_package(ZLIB)
     list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
 else()
-    add_library(ZLIB::ZLIB INTERFACE IMPORTED)
+    add_library(ZLIB::ZLIB STATIC IMPORTED)
     set_target_properties(ZLIB::ZLIB PROPERTIES
-        INTERFACE_LINK_LIBRARIES zlibstatic
+        IMPORTED_LOCATION "${CMAKE_BINARY_DIR}/3rdparty/zlib/zlib/libzlibstatic.a"
         INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/3rdparty/zlib/zlib;${CMAKE_BINARY_DIR}/3rdparty/zlib/zlib")
     set(ZLIB_FOUND TRUE)
 endif()

From 1791876eda617a9b3b0af44977996debed0e40ff Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Fri, 27 Mar 2026 17:21:41 +0100
Subject: [PATCH 58/98] remove unused lambda captures

---
 rpcs3/headless_application.cpp                |  2 +-
 rpcs3/rpcs3qt/auto_pause_settings_dialog.cpp  |  2 +-
 rpcs3/rpcs3qt/clans_settings_dialog.cpp       |  2 +-
 rpcs3/rpcs3qt/emu_settings.cpp                |  2 +-
 rpcs3/rpcs3qt/game_list_actions.cpp           |  2 +-
 rpcs3/rpcs3qt/game_list_grid.cpp              |  2 +-
 rpcs3/rpcs3qt/game_list_table.cpp             |  2 +-
 rpcs3/rpcs3qt/gs_frame.cpp                    |  2 +-
 rpcs3/rpcs3qt/gui_application.cpp             |  8 ++++----
 rpcs3/rpcs3qt/kernel_explorer.cpp             |  4 ++--
 rpcs3/rpcs3qt/main_window.cpp                 |  8 ++++----
 rpcs3/rpcs3qt/savestate_manager_dialog.cpp    |  2 +-
 rpcs3/rpcs3qt/settings_dialog.cpp             |  4 ++--
 rpcs3/rpcs3qt/sound_effect_manager_dialog.cpp |  2 +-
 rpcs3/rpcs3qt/trophy_manager_dialog.cpp       | 12 ++++++------
 rpcs3/rpcs3qt/vfs_dialog_path_widget.cpp      |  2 +-
 16 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/rpcs3/headless_application.cpp b/rpcs3/headless_application.cpp
index 135a61c491..5d9240254d 100644
--- a/rpcs3/headless_application.cpp
+++ b/rpcs3/headless_application.cpp
@@ -49,7 +49,7 @@ void headless_application::InitializeCallbacks()
 {
 	EmuCallbacks callbacks = CreateCallbacks();
 
-	callbacks.try_to_quit = [this](bool force_quit, std::function<void()> on_exit) -> bool
+	callbacks.try_to_quit = [](bool force_quit, std::function<void()> on_exit) -> bool
 	{
 		if (force_quit)
 		{
diff --git a/rpcs3/rpcs3qt/auto_pause_settings_dialog.cpp b/rpcs3/rpcs3qt/auto_pause_settings_dialog.cpp
index 26cbfc96b7..4eaadb9e7e 100644
--- a/rpcs3/rpcs3qt/auto_pause_settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/auto_pause_settings_dialog.cpp
@@ -181,7 +181,7 @@ void auto_pause_settings_dialog::ShowContextMenu(const QPoint &pos)
 		OnEntryConfig(idx, true);
 	});
 	connect(remove, &QAction::triggered, this, &auto_pause_settings_dialog::OnRemove);
-	connect(config, &QAction::triggered, this, [=, this]() {OnEntryConfig(row, false); });
+	connect(config, &QAction::triggered, this, [=]() {OnEntryConfig(row, false); });
 
 	myMenu.exec(m_pause_list->viewport()->mapToGlobal(pos));
 }
diff --git a/rpcs3/rpcs3qt/clans_settings_dialog.cpp b/rpcs3/rpcs3qt/clans_settings_dialog.cpp
index 9745d11294..0b26b791ee 100644
--- a/rpcs3/rpcs3qt/clans_settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/clans_settings_dialog.cpp
@@ -66,7 +66,7 @@ clans_settings_dialog::clans_settings_dialog(QWidget* parent)
 			g_cfg_clans.save();
 		});
 
-	connect(m_cbx_protocol, &QComboBox::currentIndexChanged, this, [this](int index)
+	connect(m_cbx_protocol, &QComboBox::currentIndexChanged, this, [](int index)
 		{
 			if (index < 0)
 				return;
diff --git a/rpcs3/rpcs3qt/emu_settings.cpp b/rpcs3/rpcs3qt/emu_settings.cpp
index 30860e10f5..0ec017a02c 100644
--- a/rpcs3/rpcs3qt/emu_settings.cpp
+++ b/rpcs3/rpcs3qt/emu_settings.cpp
@@ -207,7 +207,7 @@ bool emu_settings::ValidateSettings(bool cleanup)
 	bool is_clean = true;
 
 	std::function<void(int, YAML::Node&, std::vector<std::string>&, cfg::_base*)> search_level;
-	search_level = [&search_level, &is_clean, &cleanup, this](int level, YAML::Node& yml_node, std::vector<std::string>& keys, cfg::_base* cfg_base)
+	search_level = [&search_level, &is_clean, &cleanup](int level, YAML::Node& yml_node, std::vector<std::string>& keys, cfg::_base* cfg_base)
 	{
 		if (!yml_node || !yml_node.IsMap())
 		{
diff --git a/rpcs3/rpcs3qt/game_list_actions.cpp b/rpcs3/rpcs3qt/game_list_actions.cpp
index 5ff938e990..25b9f06b96 100644
--- a/rpcs3/rpcs3qt/game_list_actions.cpp
+++ b/rpcs3/rpcs3qt/game_list_actions.cpp
@@ -908,7 +908,7 @@ void game_list_actions::BatchActionBySerials(progress_dialog* pdlg, const std::s
 
 	const int serials_size = ::narrow<int>(serials.size());
 
-	*iterate_over_serial = [=, this, index_ptr = index](int index)
+	*iterate_over_serial = [=, index_ptr = index](int index)
 	{
 		if (index == serials_size)
 		{
diff --git a/rpcs3/rpcs3qt/game_list_grid.cpp b/rpcs3/rpcs3qt/game_list_grid.cpp
index 94fa571f7e..903fdf016a 100644
--- a/rpcs3/rpcs3qt/game_list_grid.cpp
+++ b/rpcs3/rpcs3qt/game_list_grid.cpp
@@ -21,7 +21,7 @@ game_list_grid::game_list_grid()
 		Q_EMIT IconReady(game, item);
 	};
 
-	connect(this, &game_list_grid::IconReady, this, [this](const game_info& game, const movie_item_base* item)
+	connect(this, &game_list_grid::IconReady, this, [](const game_info& game, const movie_item_base* item)
 	{
 		if (game && item && game->item == item) item->image_change_callback();
 	}, Qt::QueuedConnection); // The default 'AutoConnection' doesn't seem to work in this specific case...
diff --git a/rpcs3/rpcs3qt/game_list_table.cpp b/rpcs3/rpcs3qt/game_list_table.cpp
index 53d0754bce..3d40467bb1 100644
--- a/rpcs3/rpcs3qt/game_list_table.cpp
+++ b/rpcs3/rpcs3qt/game_list_table.cpp
@@ -54,7 +54,7 @@ game_list_table::game_list_table(game_list_frame* frame, std::shared_ptr<persist
 		}
 	});
 
-	connect(this, &game_list::IconReady, this, [this](const game_info& game, const movie_item_base* item)
+	connect(this, &game_list::IconReady, this, [](const game_info& game, const movie_item_base* item)
 	{
 		if (game && item && game->item == item) item->image_change_callback();
 	});
diff --git a/rpcs3/rpcs3qt/gs_frame.cpp b/rpcs3/rpcs3qt/gs_frame.cpp
index 2dab09d87f..bcc148d9a6 100644
--- a/rpcs3/rpcs3qt/gs_frame.cpp
+++ b/rpcs3/rpcs3qt/gs_frame.cpp
@@ -793,7 +793,7 @@ f64 gs_frame::client_display_rate()
 {
 	f64 rate = 20.; // Minimum is 20
 
-	Emu.BlockingCallFromMainThread([this, &rate]()
+	Emu.BlockingCallFromMainThread([&rate]()
 	{
 		const QList<QScreen*> screens = QGuiApplication::screens();
 
diff --git a/rpcs3/rpcs3qt/gui_application.cpp b/rpcs3/rpcs3qt/gui_application.cpp
index 606a081fff..8379e2f5e0 100644
--- a/rpcs3/rpcs3qt/gui_application.cpp
+++ b/rpcs3/rpcs3qt/gui_application.cpp
@@ -737,8 +737,8 @@ void gui_application::InitializeCallbacks()
 	callbacks.get_msg_dialog  = [this]() -> std::shared_ptr<MsgDialogBase> { return m_show_gui ? std::make_shared<msg_dialog_frame>() : nullptr; };
 	callbacks.get_osk_dialog  = [this]() -> std::shared_ptr<OskDialogBase> { return m_show_gui ? std::make_shared<osk_dialog_frame>() : nullptr; };
 	callbacks.get_save_dialog = []() -> std::unique_ptr<SaveDialogBase> { return std::make_unique<save_data_dialog>(); };
-	callbacks.get_sendmessage_dialog = [this]() -> std::shared_ptr<SendMessageDialogBase> { return std::make_shared<sendmessage_dialog_frame>(); };
-	callbacks.get_recvmessage_dialog = [this]() -> std::shared_ptr<RecvMessageDialogBase> { return std::make_shared<recvmessage_dialog_frame>(); };
+	callbacks.get_sendmessage_dialog = []() -> std::shared_ptr<SendMessageDialogBase> { return std::make_shared<sendmessage_dialog_frame>(); };
+	callbacks.get_recvmessage_dialog = []() -> std::shared_ptr<RecvMessageDialogBase> { return std::make_shared<recvmessage_dialog_frame>(); };
 	callbacks.get_trophy_notification_dialog = [this]() -> std::unique_ptr<TrophyNotificationBase> { return std::make_unique<trophy_notification_helper>(m_game_window); };
 
 	callbacks.on_run    = [this](bool start_playtime) { OnEmulatorRun(start_playtime); };
@@ -839,7 +839,7 @@ void gui_application::InitializeCallbacks()
 		};
 	}
 
-	callbacks.on_emulation_stop_no_response = [this](std::shared_ptr<atomic_t<bool>> closed_successfully, int seconds_waiting_already)
+	callbacks.on_emulation_stop_no_response = [](std::shared_ptr<atomic_t<bool>> closed_successfully, int seconds_waiting_already)
 	{
 		const std::string terminate_message = tr("Stopping emulator took too long."
 			"\nSome thread has probably deadlocked. Aborting.").toStdString();
@@ -849,7 +849,7 @@ void gui_application::InitializeCallbacks()
 			report_fatal_error(terminate_message);
 		}
 
-		Emu.CallFromMainThread([this, closed_successfully, seconds_waiting_already, terminate_message]
+		Emu.CallFromMainThread([closed_successfully, seconds_waiting_already, terminate_message]
 		{
 			const auto seconds = std::make_shared<int>(seconds_waiting_already);
 
diff --git a/rpcs3/rpcs3qt/kernel_explorer.cpp b/rpcs3/rpcs3qt/kernel_explorer.cpp
index 68c6f45e2b..926949fb58 100644
--- a/rpcs3/rpcs3qt/kernel_explorer.cpp
+++ b/rpcs3/rpcs3qt/kernel_explorer.cpp
@@ -316,7 +316,7 @@ void kernel_explorer::update()
 
 	add_solid_node(find_node(root, additional_nodes::process_info), QString::fromStdString(fmt::format("Process Info, Sdk Version: 0x%08x, PPC SEG: %#x, SFO Category: %s (Fake: %s)", g_ps3_process_info.sdk_ver, g_ps3_process_info.ppc_seg, Emu.GetCat(), Emu.GetFakeCat())));
 
-	auto display_program_segments = [this](QTreeWidgetItem* tree, const ppu_module<lv2_obj>& m)
+	auto display_program_segments = [](QTreeWidgetItem* tree, const ppu_module<lv2_obj>& m)
 	{
 		for (usz i = 0; i < m.segs.size(); i++)
 		{
@@ -661,7 +661,7 @@ void kernel_explorer::update()
 		const s32 prio = ppu.prio.load().prio;
 		std::string prio_text = fmt::format("%4d", prio);
 		prio_text = fmt::replace_all(prio_text, " ", " ");
-	
+
 		ppu_threads.emplace_back(prio, fmt::format(u8"PPU 0x%07x: PRIO: %s, “%s”Joiner: %s, Status: %s, State: %s, %s func: “%s”%s", id, prio_text, *ppu.ppu_tname.load(), ppu.joiner.load(), status, ppu.state.load()
 			, ppu.ack_suspend ? "After" : (ppu.current_function ? "In" : "Last"), func ? func : "", get_wait_time_str(ppu.start_time)));
 	}, idm::unlocked);
diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index a82fe5b091..0d62ef5b72 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -1734,7 +1734,7 @@ void main_window::DecryptSPRXLibraries()
 			dlg->set_button_enabled(QDialogButtonBox::StandardButton::Ok, text.size() - (text.indexOf('x') + 1) == 32);
 		});
 
-		connect(dlg, &QDialog::accepted, this, [this, iterate, dlg, mod_index, decrypter, repeat_count]()
+		connect(dlg, &QDialog::accepted, this, [iterate, dlg, mod_index, decrypter, repeat_count]()
 		{
 			std::string text = dlg->get_input_text().toStdString();
 
@@ -3118,13 +3118,13 @@ void main_window::CreateConnects()
 		m_game_list_frame->Refresh(true); // New user may have different games unlocked.
 	});
 
-	connect(ui->actionManage_Screenshots, &QAction::triggered, this, [this]
+	connect(ui->actionManage_Screenshots, &QAction::triggered, this, []
 	{
 		screenshot_manager_dialog* screenshot_manager = new screenshot_manager_dialog();
 		screenshot_manager->show();
 	});
 
-	connect(ui->actionManage_SoundEffects, &QAction::triggered, this, [this]
+	connect(ui->actionManage_SoundEffects, &QAction::triggered, this, []
 	{
 		sound_effect_manager_dialog* dlg = new sound_effect_manager_dialog();
 		dlg->show();
@@ -3376,7 +3376,7 @@ void main_window::CreateConnects()
 		welcome->open();
 	});
 
-	connect(ui->supportAct, &QAction::triggered, this, [this]
+	connect(ui->supportAct, &QAction::triggered, this, []
 	{
 		QDesktopServices::openUrl(QUrl("https://rpcs3.net/patreon"));
 	});
diff --git a/rpcs3/rpcs3qt/savestate_manager_dialog.cpp b/rpcs3/rpcs3qt/savestate_manager_dialog.cpp
index 2898c9b170..dbeca1698f 100644
--- a/rpcs3/rpcs3qt/savestate_manager_dialog.cpp
+++ b/rpcs3/rpcs3qt/savestate_manager_dialog.cpp
@@ -575,7 +575,7 @@ void savestate_manager_dialog::ShowGameTableContextMenu(const QPoint& pos)
 	if (!name.isEmpty())
 	{
 		QAction* copy_name = new QAction(tr("&Copy Name"), menu);
-		connect(copy_name, &QAction::triggered, this, [this, name]()
+		connect(copy_name, &QAction::triggered, this, [name]()
 		{
 			QApplication::clipboard()->setText(name);
 		});
diff --git a/rpcs3/rpcs3qt/settings_dialog.cpp b/rpcs3/rpcs3qt/settings_dialog.cpp
index c95247748a..f4fcee4985 100644
--- a/rpcs3/rpcs3qt/settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/settings_dialog.cpp
@@ -858,7 +858,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 		ui->vulkansched->setEnabled(is_vulkan);
 	};
 
-	const auto apply_fsr_specific_options = [r_creator, this]()
+	const auto apply_fsr_specific_options = [this]()
 	{
 		const auto [text, value] = get_data(ui->outputScalingMode, ui->outputScalingMode->currentIndex());
 		const bool fsr_selected = static_cast<output_scaling_mode>(value) == output_scaling_mode::fsr;
@@ -2095,7 +2095,7 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 
 	connect(ui->edit_button_game_window_title_format, &QAbstractButton::clicked, [get_game_window_title, set_game_window_title, this]()
 	{
-		auto get_game_window_title_label = [get_game_window_title, set_game_window_title, this](const QString& format)
+		auto get_game_window_title_label = [get_game_window_title](const QString& format)
 		{
 			const QString game_window_title = get_game_window_title(format);
 
diff --git a/rpcs3/rpcs3qt/sound_effect_manager_dialog.cpp b/rpcs3/rpcs3qt/sound_effect_manager_dialog.cpp
index cfd93246eb..3f7aeccce0 100644
--- a/rpcs3/rpcs3qt/sound_effect_manager_dialog.cpp
+++ b/rpcs3/rpcs3qt/sound_effect_manager_dialog.cpp
@@ -41,7 +41,7 @@ sound_effect_manager_dialog::sound_effect_manager_dialog(QWidget* parent)
 		}
 
 		QPushButton* button = new QPushButton("", this);
-		connect(button, &QAbstractButton::clicked, this, [this, button, sound, name]()
+		connect(button, &QAbstractButton::clicked, this, [this, sound, name]()
 		{
 			const std::string path = rsx::overlays::get_sound_filepath(sound);
 			if (fs::is_file(path))
diff --git a/rpcs3/rpcs3qt/trophy_manager_dialog.cpp b/rpcs3/rpcs3qt/trophy_manager_dialog.cpp
index 51ef2d2e9f..11046f2a70 100644
--- a/rpcs3/rpcs3qt/trophy_manager_dialog.cpp
+++ b/rpcs3/rpcs3qt/trophy_manager_dialog.cpp
@@ -392,7 +392,7 @@ trophy_manager_dialog::trophy_manager_dialog(std::shared_ptr<gui_settings> gui_s
 	m_trophy_table->create_header_actions(m_trophy_column_acts,
 		[this](int col) { return m_gui_settings->GetTrophylistColVisibility(static_cast<gui::trophy_list_columns>(col)); },
 		[this](int col, bool visible) { m_gui_settings->SetTrophylistColVisibility(static_cast<gui::trophy_list_columns>(col), visible); });
-	
+
 	m_game_table->create_header_actions(m_game_column_acts,
 		[this](int col) { return m_gui_settings->GetTrophyGamelistColVisibility(static_cast<gui::trophy_game_list_columns>(col)); },
 		[this](int col, bool visible) { m_gui_settings->SetTrophyGamelistColVisibility(static_cast<gui::trophy_game_list_columns>(col), visible); });
@@ -651,7 +651,7 @@ void trophy_manager_dialog::ResizeGameIcons()
 			const int trophy_index = item->data(GameUserRole::GameIndex).toInt();
 			QString trophy_icon_path = QString::fromStdString(m_trophies_db[trophy_index]->path);
 
-			item->set_icon_load_func([this, icon_path = std::move(trophy_icon_path), localized_icon, trophy_index, cancel = item->icon_loading_aborted(), dpr](int index)
+			item->set_icon_load_func([this, icon_path = std::move(trophy_icon_path), localized_icon, cancel = item->icon_loading_aborted(), dpr](int index)
 			{
 				if (cancel && cancel->load())
 				{
@@ -897,7 +897,7 @@ void trophy_manager_dialog::ShowTrophyTableContextMenu(const QPoint& pos)
 		if (!name.isEmpty() && !desc.isEmpty())
 		{
 			QAction* copy_both = new QAction(tr("&Copy Name + Description"), copy_menu);
-			connect(copy_both, &QAction::triggered, this, [this, name, desc]()
+			connect(copy_both, &QAction::triggered, this, [name, desc]()
 			{
 				QApplication::clipboard()->setText(name % QStringLiteral("\n\n") % desc);
 			});
@@ -907,7 +907,7 @@ void trophy_manager_dialog::ShowTrophyTableContextMenu(const QPoint& pos)
 		if (!name.isEmpty())
 		{
 			QAction* copy_name = new QAction(tr("&Copy Name"), copy_menu);
-			connect(copy_name, &QAction::triggered, this, [this, name]()
+			connect(copy_name, &QAction::triggered, this, [name]()
 			{
 				QApplication::clipboard()->setText(name);
 			});
@@ -917,7 +917,7 @@ void trophy_manager_dialog::ShowTrophyTableContextMenu(const QPoint& pos)
 		if (!desc.isEmpty())
 		{
 			QAction* copy_desc = new QAction(tr("&Copy Description"), copy_menu);
-			connect(copy_desc, &QAction::triggered, this, [this, desc]()
+			connect(copy_desc, &QAction::triggered, this, [desc]()
 			{
 				QApplication::clipboard()->setText(desc);
 			});
@@ -1038,7 +1038,7 @@ void trophy_manager_dialog::ShowGameTableContextMenu(const QPoint& pos)
 	if (!name.isEmpty())
 	{
 		QAction* copy_name = new QAction(tr("&Copy Name"), menu);
-		connect(copy_name, &QAction::triggered, this, [this, name]()
+		connect(copy_name, &QAction::triggered, this, [name]()
 		{
 			QApplication::clipboard()->setText(name);
 		});
diff --git a/rpcs3/rpcs3qt/vfs_dialog_path_widget.cpp b/rpcs3/rpcs3qt/vfs_dialog_path_widget.cpp
index f5ceac8aee..44aceff70a 100644
--- a/rpcs3/rpcs3qt/vfs_dialog_path_widget.cpp
+++ b/rpcs3/rpcs3qt/vfs_dialog_path_widget.cpp
@@ -81,7 +81,7 @@ vfs_dialog_path_widget::vfs_dialog_path_widget(const QString& name, const QStrin
 		item->setCheckState(Qt::CheckState::Checked);
 	});
 
-	connect(m_dir_list, &QListWidget::currentRowChanged, this, [this, button_remove_dir](int row)
+	connect(m_dir_list, &QListWidget::currentRowChanged, this, [button_remove_dir](int row)
 	{
 		button_remove_dir->setEnabled(row > 0);
 	});

From f8fe64ff7766df55bc9af080257732456173cf93 Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Tue, 24 Mar 2026 11:56:10 +0100
Subject: [PATCH 59/98] find_dialog: fix compiler warning

---
 rpcs3/rpcs3qt/find_dialog.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/rpcs3qt/find_dialog.cpp b/rpcs3/rpcs3qt/find_dialog.cpp
index 25d9442f2b..756e355e4f 100644
--- a/rpcs3/rpcs3qt/find_dialog.cpp
+++ b/rpcs3/rpcs3qt/find_dialog.cpp
@@ -15,7 +15,7 @@ find_dialog::find_dialog(QPlainTextEdit* edit, QWidget *parent, Qt::WindowFlags
 
 	QCheckBox* cb_case_sensitive = new QCheckBox(tr("Case sensitive"));
 	cb_case_sensitive->setChecked(m_case_sensitive);
-	connect(cb_case_sensitive, &QCheckBox::toggled, this, [=](bool checked)
+	connect(cb_case_sensitive, &QCheckBox::toggled, this, [this](bool checked)
 	{
 		m_case_sensitive = checked;
 	});

From aa7cf5ea153ececef87d0dc0982522ea690b281e Mon Sep 17 00:00:00 2001
From: Ani <ani-leo@outlook.com>
Date: Sun, 29 Mar 2026 18:48:59 +0200
Subject: [PATCH 60/98] sysinfo: Implement RAM Usage stats for Linux (#18473)

Reads memory statistics from "/proc/meminfo"
---
 rpcs3/util/sysinfo.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/rpcs3/util/sysinfo.cpp b/rpcs3/util/sysinfo.cpp
index 81c0b3d31a..16b40d7e52 100755
--- a/rpcs3/util/sysinfo.cpp
+++ b/rpcs3/util/sysinfo.cpp
@@ -743,7 +743,26 @@ std::pair<u64, u64> utils::get_memory_usage()
 	status.dwLength = sizeof(status);
 	::GlobalMemoryStatusEx(&status);
 	return { status.ullTotalPhys, status.ullTotalPhys - status.ullAvailPhys };
+#elif __linux__
+	std::ifstream proc("/proc/meminfo");
+	std::string line;
+	uint64_t mem_total = get_total_memory();
+	uint64_t mem_available = 0;
 
+	while (std::getline(proc, line))
+	{
+		if (line.rfind("MemTotal:", 0) == 0 && line.find("kB") != std::string::npos)
+		{
+			mem_total = std::stoull(line.substr(line.find_first_of("0123456789"))) * 1024;
+		}
+		else if (line.rfind("MemAvailable:", 0) == 0 && line.find("kB") != std::string::npos)
+		{
+			mem_available = std::stoull(line.substr(line.find_first_of("0123456789"))) * 1024;
+			break;
+		}
+	}
+
+	return { mem_total, mem_total - mem_available };
 #else
 	// TODO
 	return { get_total_memory(), 0 };

From bd2b2c2747b14d862d9bd68392dafac68c991d72 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 29 Mar 2026 09:31:35 +0200
Subject: [PATCH 61/98] Qt: add recording settings dialog

---
 Utilities/Config.h                          |   6 +-
 rpcs3/Emu/Io/recording_config.h             |  12 +-
 rpcs3/rpcs3.vcxproj                         |  28 ++
 rpcs3/rpcs3.vcxproj.filters                 |  18 +
 rpcs3/rpcs3qt/CMakeLists.txt                |   2 +
 rpcs3/rpcs3qt/main_window.cpp               |   7 +
 rpcs3/rpcs3qt/main_window.ui                |   6 +
 rpcs3/rpcs3qt/recording_settings_dialog.cpp | 455 ++++++++++++++++++++
 rpcs3/rpcs3qt/recording_settings_dialog.h   |  47 ++
 rpcs3/rpcs3qt/recording_settings_dialog.ui  | 273 ++++++++++++
 10 files changed, 845 insertions(+), 9 deletions(-)
 create mode 100644 rpcs3/rpcs3qt/recording_settings_dialog.cpp
 create mode 100644 rpcs3/rpcs3qt/recording_settings_dialog.h
 create mode 100644 rpcs3/rpcs3qt/recording_settings_dialog.ui

diff --git a/Utilities/Config.h b/Utilities/Config.h
index ca9af028a5..4c79cbf31c 100644
--- a/Utilities/Config.h
+++ b/Utilities/Config.h
@@ -393,7 +393,7 @@ namespace cfg
 
 		void set(const s64& value)
 		{
-			ensure(value >= Min && value <= Max);
+			if (value < Min || value > Max) fmt::throw_exception("'%s': value %d out of bounds (min=%d, max=%d)", m_name, value, Min, Max);
 			m_value = static_cast<int_type>(value);
 		}
 
@@ -484,7 +484,7 @@ namespace cfg
 
 		void set(const f64& value)
 		{
-			ensure(value >= Min && value <= Max);
+			if (value < Min || value > Max) fmt::throw_exception("'%s': value %d out of bounds (min=%d, max=%d)", m_name, value, Min, Max);
 			m_value = static_cast<float_type>(value);
 		}
 
@@ -571,7 +571,7 @@ namespace cfg
 
 		void set(const u64& value)
 		{
-			ensure(value >= Min && value <= Max);
+			if (value < Min || value > Max) fmt::throw_exception("'%s': value %d out of bounds (min=%d, max=%d)", m_name, value, Min, Max);
 			m_value = static_cast<int_type>(value);
 		}
 
diff --git a/rpcs3/Emu/Io/recording_config.h b/rpcs3/Emu/Io/recording_config.h
index 127d24015f..ef73149f5e 100644
--- a/rpcs3/Emu/Io/recording_config.h
+++ b/rpcs3/Emu/Io/recording_config.h
@@ -13,13 +13,13 @@ struct cfg_recording final : cfg::node
 		node_video(cfg::node* _this) : cfg::node(_this, "Video") {}
 
 		cfg::uint<0, 60> framerate{this, "Framerate", 30};
-		cfg::uint<0, 7680> width{this, "Width", 1280};
-		cfg::uint<0, 4320> height{this, "Height", 720};
+		cfg::uint<640, 7680> width{this, "Width", 1280};
+		cfg::uint<360, 4320> height{this, "Height", 720};
 		cfg::uint<0, 192> pixel_format{this, "AVPixelFormat", 0}; // AVPixelFormat::AV_PIX_FMT_YUV420P
 		cfg::uint<0, 0xFFFF> video_codec{this, "AVCodecID", 12}; // AVCodecID::AV_CODEC_ID_MPEG4
-		cfg::uint<0, 25000000> video_bps{this, "Video Bitrate", 4000000};
-		cfg::uint<0, 5> max_b_frames{this, "Max B-Frames", 2};
-		cfg::uint<0, 20> gop_size{this, "Group of Pictures Size", 12};
+		cfg::uint<1'000'000, 60'000'000> video_bps{this, "Video Bitrate", 4'000'000};
+		cfg::uint<0, 3> max_b_frames{this, "Max B-Frames", 2};
+		cfg::uint<1, 120> gop_size{this, "Group of Pictures Size", 30};
 
 	} video{ this };
 
@@ -28,7 +28,7 @@ struct cfg_recording final : cfg::node
 		node_audio(cfg::node* _this) : cfg::node(_this, "Audio") {}
 		
 		cfg::uint<0x10000, 0x17000> audio_codec{this, "AVCodecID", 86018}; // AVCodecID::AV_CODEC_ID_AAC
-		cfg::uint<0, 25000000> audio_bps{this, "Audio Bitrate", 320000};
+		cfg::uint<64'000, 320'000> audio_bps{this, "Audio Bitrate", 192'000};
 
 	} audio{ this };
 
diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj
index 5401efb323..d25ca3905c 100644
--- a/rpcs3/rpcs3.vcxproj
+++ b/rpcs3/rpcs3.vcxproj
@@ -386,6 +386,9 @@
     <ClCompile Include="QTGeneratedFiles\Debug\moc_pad_settings_dialog.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Debug\moc_recording_settings_dialog.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Debug\moc_patch_creator_dialog.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
@@ -689,6 +692,9 @@
     <ClCompile Include="QTGeneratedFiles\Release\moc_pad_settings_dialog.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Release\moc_recording_settings_dialog.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Release\moc_patch_creator_dialog.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
     </ClCompile>
@@ -868,6 +874,7 @@
     <ClCompile Include="rpcs3qt\osk_dialog_frame.cpp" />
     <ClCompile Include="rpcs3qt\pad_led_settings_dialog.cpp" />
     <ClCompile Include="rpcs3qt\pad_motion_settings_dialog.cpp" />
+    <ClCompile Include="rpcs3qt\recording_settings_dialog.cpp" />
     <ClCompile Include="rpcs3qt\patch_creator_dialog.cpp" />
     <ClCompile Include="rpcs3qt\patch_manager_dialog.cpp" />
     <ClCompile Include="rpcs3qt\pkg_install_dialog.cpp" />
@@ -1157,6 +1164,7 @@
     <ClInclude Include="QTGeneratedFiles\ui_pad_led_settings_dialog.h" />
     <ClInclude Include="QTGeneratedFiles\ui_pad_motion_settings_dialog.h" />
     <ClInclude Include="QTGeneratedFiles\ui_pad_settings_dialog.h" />
+    <ClInclude Include="QTGeneratedFiles\ui_recording_settings_dialog.h" />
     <ClInclude Include="QTGeneratedFiles\ui_patch_creator_dialog.h" />
     <ClInclude Include="QTGeneratedFiles\ui_patch_manager_dialog.h" />
     <ClInclude Include="QTGeneratedFiles\ui_settings_dialog.h" />
@@ -1624,6 +1632,16 @@
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DWIN32_LEAN_AND_MEAN -DHAVE_VULKAN -DWITH_DISCORD_RPC -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DNDEBUG -DQT_CONCURRENT_LIB -DQT_MULTIMEDIA_LIB -DQT_MULTIMEDIAWIDGETS_LIB -DQT_SVG_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\SoundTouch\soundtouch\include" "-I.\..\3rdparty\cubeb\extra" "-I.\..\3rdparty\cubeb\cubeb\include" "-I.\..\3rdparty\protobuf\protobuf\src" "-I.\..\3rdparty\wolfssl\wolfssl" "-I.\..\3rdparty\curl\curl\include" "-I.\..\3rdparty\libusb\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtCore" "-I.\release" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtConcurrent" "-I$(QTDIR)\include\QtMultimedia" "-I$(QTDIR)\include\QtMultimediaWidgets" "-I$(QTDIR)\include\QtSvg"</Command>
     </CustomBuild>
+    <CustomBuild Include="rpcs3qt\recording_settings_dialog.h">
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Moc%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DWIN32_LEAN_AND_MEAN -DHAVE_VULKAN -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_CONCURRENT_LIB -DQT_MULTIMEDIA_LIB -DQT_MULTIMEDIAWIDGETS_LIB -DQT_SVG_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\SoundTouch\soundtouch\include" "-I.\..\3rdparty\cubeb\extra" "-I.\..\3rdparty\cubeb\cubeb\include" "-I.\..\3rdparty\protobuf\protobuf\src" "-I.\..\3rdparty\wolfssl\wolfssl" "-I.\..\3rdparty\curl\curl\include" "-I.\..\3rdparty\libusb\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtCore" "-I.\debug" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtConcurrent" "-I$(QTDIR)\include\QtMultimedia" "-I$(QTDIR)\include\QtMultimediaWidgets" "-I$(QTDIR)\include\QtSvg"</Command>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Moc%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"$(QTDIR)\bin\moc.exe"  "%(FullPath)" -o ".\QTGeneratedFiles\$(ConfigurationName)\moc_%(Filename).cpp"  -D_WINDOWS -DUNICODE -DWIN32 -DWIN64 -DWIN32_LEAN_AND_MEAN -DHAVE_VULKAN -DWITH_DISCORD_RPC -DQT_NO_DEBUG -DQT_WIDGETS_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DNDEBUG -DQT_CONCURRENT_LIB -DQT_MULTIMEDIA_LIB -DQT_MULTIMEDIAWIDGETS_LIB -DQT_SVG_LIB -D%(PreprocessorDefinitions) "-I.\..\3rdparty\SoundTouch\soundtouch\include" "-I.\..\3rdparty\cubeb\extra" "-I.\..\3rdparty\cubeb\cubeb\include" "-I.\..\3rdparty\protobuf\protobuf\src" "-I.\..\3rdparty\wolfssl\wolfssl" "-I.\..\3rdparty\curl\curl\include" "-I.\..\3rdparty\libusb\libusb\libusb" "-I$(VULKAN_SDK)\Include" "-I$(QTDIR)\include" "-I$(QTDIR)\include\QtWidgets" "-I$(QTDIR)\include\QtGui" "-I$(QTDIR)\include\QtCore" "-I.\release" "-I.\QTGeneratedFiles\$(ConfigurationName)" "-I.\QTGeneratedFiles" "-I$(QTDIR)\include\QtConcurrent" "-I$(QTDIR)\include\QtMultimedia" "-I$(QTDIR)\include\QtMultimediaWidgets" "-I$(QTDIR)\include\QtSvg"</Command>
+    </CustomBuild>
     <ClInclude Include="rpcs3qt\pad_device_info.h" />
     <ClInclude Include="rpcs3qt\permissions.h" />
     <ClInclude Include="rpcs3qt\progress_indicator.h" />
@@ -2196,6 +2214,16 @@
       <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\QTGeneratedFiles\ui_%(Filename).h;%(Outputs)</Outputs>
       <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"$(QTDIR)\bin\uic.exe" -o ".\QTGeneratedFiles\ui_%(Filename).h" "%(FullPath)"</Command>
     </CustomBuild>
+    <CustomBuild Include="rpcs3qt\recording_settings_dialog.ui">
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(QTDIR)\bin\uic.exe;%(AdditionalInputs)</AdditionalInputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Uic%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">.\QTGeneratedFiles\ui_%(Filename).h;%(Outputs)</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">"$(QTDIR)\bin\uic.exe" -o ".\QTGeneratedFiles\ui_%(Filename).h" "%(FullPath)"</Command>
+      <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(QTDIR)\bin\uic.exe;%(AdditionalInputs)</AdditionalInputs>
+      <Message Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Uic%27ing %(Identity)...</Message>
+      <Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">.\QTGeneratedFiles\ui_%(Filename).h;%(Outputs)</Outputs>
+      <Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">"$(QTDIR)\bin\uic.exe" -o ".\QTGeneratedFiles\ui_%(Filename).h" "%(FullPath)"</Command>
+    </CustomBuild>
     <CustomBuild Include="rpcs3qt\shortcut_dialog.ui">
       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(QTDIR)\bin\uic.exe;%(AdditionalInputs)</AdditionalInputs>
       <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Uic%27ing %(Identity)...</Message>
diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters
index d9ebc34ef6..28af783415 100644
--- a/rpcs3/rpcs3.vcxproj.filters
+++ b/rpcs3/rpcs3.vcxproj.filters
@@ -291,6 +291,12 @@
     <ClCompile Include="QTGeneratedFiles\Release\moc_pad_settings_dialog.cpp">
       <Filter>Generated Files\Release</Filter>
     </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Debug\moc_recording_settings_dialog.cpp">
+      <Filter>Generated Files\Debug</Filter>
+    </ClCompile>
+    <ClCompile Include="QTGeneratedFiles\Release\moc_recording_settings_dialog.cpp">
+      <Filter>Generated Files\Release</Filter>
+    </ClCompile>
     <ClCompile Include="QTGeneratedFiles\Debug\moc_rsx_debugger.cpp">
       <Filter>Generated Files\Debug</Filter>
     </ClCompile>
@@ -441,6 +447,9 @@
     <ClCompile Include="rpcs3qt\pad_settings_dialog.cpp">
       <Filter>Gui\settings</Filter>
     </ClCompile>
+    <ClCompile Include="rpcs3qt\recording_settings_dialog.cpp">
+      <Filter>Gui\settings</Filter>
+    </ClCompile>
     <ClCompile Include="rpcs3qt\log_frame.cpp">
       <Filter>Gui\log</Filter>
     </ClCompile>
@@ -1304,6 +1313,9 @@
     <ClInclude Include="QTGeneratedFiles\ui_pad_led_settings_dialog.h">
       <Filter>Generated Files</Filter>
     </ClInclude>
+    <ClInclude Include="QTGeneratedFiles\ui_recording_settings_dialog.h">
+      <Filter>Generated Files</Filter>
+    </ClInclude>
     <ClInclude Include="QTGeneratedFiles\ui_settings_dialog.h">
       <Filter>Generated Files</Filter>
     </ClInclude>
@@ -1555,6 +1567,9 @@
     <CustomBuild Include="rpcs3qt\settings_dialog.ui">
       <Filter>Form Files</Filter>
     </CustomBuild>
+    <CustomBuild Include="rpcs3qt\recording_settings_dialog.ui">
+      <Filter>Form Files</Filter>
+    </CustomBuild>
     <CustomBuild Include="rpcs3qt\welcome_dialog.ui">
       <Filter>Form Files</Filter>
     </CustomBuild>
@@ -1597,6 +1612,9 @@
     <CustomBuild Include="rpcs3qt\pad_led_settings_dialog.h">
       <Filter>Gui\settings</Filter>
     </CustomBuild>
+    <CustomBuild Include="rpcs3qt\recording_settings_dialog.h">
+      <Filter>Gui\settings</Filter>
+    </CustomBuild>
     <CustomBuild Include="rpcs3qt\log_frame.h">
       <Filter>Gui\log</Filter>
     </CustomBuild>
diff --git a/rpcs3/rpcs3qt/CMakeLists.txt b/rpcs3/rpcs3qt/CMakeLists.txt
index 5c330c7ae4..b0a75d9bfa 100644
--- a/rpcs3/rpcs3qt/CMakeLists.txt
+++ b/rpcs3/rpcs3qt/CMakeLists.txt
@@ -83,6 +83,7 @@ add_library(rpcs3_ui STATIC
     qt_video_source.cpp
     raw_mouse_settings_dialog.cpp
     register_editor_dialog.cpp
+    recording_settings_dialog.cpp
     recvmessage_dialog_frame.cpp
     render_creator.cpp
     rpcn_settings_dialog.cpp
@@ -135,6 +136,7 @@ add_library(rpcs3_ui STATIC
     patch_creator_dialog.ui
     patch_manager_dialog.ui
     ps_move_tracker_dialog.ui
+    recording_settings_dialog.ui
     settings_dialog.ui
     shortcut_dialog.ui
     welcome_dialog.ui
diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index 0d62ef5b72..b4776d2fc1 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -46,6 +46,7 @@
 #include "welcome_dialog.h"
 #include "music_player_dialog.h"
 #include "sound_effect_manager_dialog.h"
+#include "recording_settings_dialog.h"
 
 #include <thread>
 #include <unordered_set>
@@ -3130,6 +3131,12 @@ void main_window::CreateConnects()
 		dlg->show();
 	});
 
+	connect(ui->actionRecording, &QAction::triggered, this, [this]
+	{
+		recording_settings_dialog* dlg = new recording_settings_dialog(this);
+		dlg->open();
+	});
+
 	connect(ui->toolsCgDisasmAct, &QAction::triggered, this, [this]
 	{
 		cg_disasm_window* cgdw = new cg_disasm_window(m_gui_settings);
diff --git a/rpcs3/rpcs3qt/main_window.ui b/rpcs3/rpcs3qt/main_window.ui
index 8fcf4ac610..7a7c965ce8 100644
--- a/rpcs3/rpcs3qt/main_window.ui
+++ b/rpcs3/rpcs3qt/main_window.ui
@@ -290,6 +290,7 @@
     <addaction name="separator"/>
     <addaction name="confShortcutsAct"/>
     <addaction name="actionManage_SoundEffects"/>
+    <addaction name="actionRecording"/>
     <addaction name="separator"/>
     <addaction name="confAutopauseManagerAct"/>
    </widget>
@@ -1536,6 +1537,11 @@
     <string>Play Hover Music</string>
    </property>
   </action>
+  <action name="actionRecording">
+   <property name="text">
+    <string>Recording</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources>
diff --git a/rpcs3/rpcs3qt/recording_settings_dialog.cpp b/rpcs3/rpcs3qt/recording_settings_dialog.cpp
new file mode 100644
index 0000000000..befd14713a
--- /dev/null
+++ b/rpcs3/rpcs3qt/recording_settings_dialog.cpp
@@ -0,0 +1,455 @@
+#include "stdafx.h"
+#include "recording_settings_dialog.h"
+#include "ui_recording_settings_dialog.h"
+
+#include <QPushButton>
+
+#ifdef _MSC_VER
+#pragma warning(push, 0)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wextra"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#endif
+extern "C" {
+#include "libavcodec/avcodec.h"
+#include "libavformat/avformat.h"
+}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic pop
+#endif
+
+LOG_CHANNEL(cfg_log, "CFG");
+
+static std::vector<const AVCodec*> get_video_codecs(const AVOutputFormat* fmt)
+{
+	std::vector<const AVCodec*> codecs;
+
+	void* opaque = nullptr;
+	while (const AVCodec* codec = av_codec_iterate(&opaque))
+	{
+		if (!codec->pix_fmts)
+			continue;
+
+		if (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
+			continue;
+
+		if (codec->type != AVMediaType::AVMEDIA_TYPE_VIDEO)
+			continue;
+
+		switch (codec->id)
+		{
+		case AV_CODEC_ID_H264:
+		case AV_CODEC_ID_HEVC:
+		case AV_CODEC_ID_MPEG4:
+		case AV_CODEC_ID_AV1:
+			break;
+		default:
+			continue;
+		}
+
+		if (!av_codec_is_encoder(codec))
+			continue;
+
+		if (avformat_query_codec(fmt, codec->id, FF_COMPLIANCE_NORMAL) != 1)
+			continue;
+
+		codecs.push_back(codec);
+	}
+
+	return codecs;
+}
+
+static std::vector<const AVCodec*> get_audio_codecs(const AVOutputFormat* fmt)
+{
+	std::vector<const AVCodec*> codecs;
+
+	void* opaque = nullptr;
+	while (const AVCodec* codec = av_codec_iterate(&opaque))
+	{
+		if (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
+			continue;
+
+		if (codec->type != AVMediaType::AVMEDIA_TYPE_AUDIO)
+			continue;
+
+		if (!av_codec_is_encoder(codec))
+			continue;
+
+		if (avformat_query_codec(fmt, codec->id, FF_COMPLIANCE_NORMAL) != 1)
+			continue;
+
+		codecs.push_back(codec);
+	}
+
+	return codecs;
+}
+
+recording_settings_dialog::recording_settings_dialog(QWidget* parent)
+	: QDialog(parent), ui(new Ui::recording_settings_dialog)
+{
+	ui->setupUi(this);
+	setAttribute(Qt::WA_DeleteOnClose);
+
+	if (!g_cfg_recording.load())
+	{
+		cfg_log.notice("Could not load recording config. Using defaults.");
+	}
+
+	ui->combo_presets->addItem(tr("720p 30fps"),  static_cast<int>(quality_preset::_720p_30));
+	ui->combo_presets->addItem(tr("720p 60fps"),  static_cast<int>(quality_preset::_720p_60));
+	ui->combo_presets->addItem(tr("1080p 30fps"), static_cast<int>(quality_preset::_1080p_30));
+	ui->combo_presets->addItem(tr("1080p 60fps"), static_cast<int>(quality_preset::_1080p_60));
+	ui->combo_presets->addItem(tr("1440p 30fps"), static_cast<int>(quality_preset::_1440p_30));
+	ui->combo_presets->addItem(tr("1440p 60fps"), static_cast<int>(quality_preset::_1440p_60));
+	ui->combo_presets->addItem(tr("2160p 30fps"), static_cast<int>(quality_preset::_2160p_30));
+	ui->combo_presets->addItem(tr("2160p 60fps"), static_cast<int>(quality_preset::_2160p_60));
+	ui->combo_presets->addItem(tr("Custom"),      static_cast<int>(quality_preset::custom));
+	connect(ui->combo_presets, &QComboBox::currentIndexChanged, this, [this](int index)
+	{
+		const QVariant var = ui->combo_presets->itemData(index);
+		if (var.canConvert<int>())
+		{
+			const quality_preset preset = static_cast<quality_preset>(var.toInt());
+			select_preset(preset, g_cfg_recording);
+			update_ui();
+		}
+	});
+
+	ui->combo_resolution->addItem("360p",  QVariant::fromValue(QPair<int, int>(640, 360)));
+	ui->combo_resolution->addItem("480p",  QVariant::fromValue(QPair<int, int>(854, 480)));
+	ui->combo_resolution->addItem("720p",  QVariant::fromValue(QPair<int, int>(1280, 720)));
+	ui->combo_resolution->addItem("1080p", QVariant::fromValue(QPair<int, int>(1920, 1080)));
+	ui->combo_resolution->addItem("1440p", QVariant::fromValue(QPair<int, int>(2560, 1440)));
+	ui->combo_resolution->addItem("2160p", QVariant::fromValue(QPair<int, int>(3840, 2160)));
+	connect(ui->combo_resolution, &QComboBox::currentIndexChanged, this, [this](int index)
+	{
+		const QVariant var = ui->combo_resolution->itemData(index);
+		if (var.canConvert<QPair<int, int>>())
+		{
+			const QPair<int, int> size = var.value<QPair<int, int>>();
+			g_cfg_recording.video.width.set(size.first);
+			g_cfg_recording.video.height.set(size.second);
+			update_preset();
+		}
+	});
+
+	const AVOutputFormat* fmt = av_guess_format("mp4", nullptr, nullptr);
+	m_video_codecs = get_video_codecs(fmt);
+	m_audio_codecs = get_audio_codecs(fmt);
+
+	for (const AVCodec* codec : m_video_codecs)
+	{
+		if (!codec) continue;
+
+		const std::string name = codec->long_name ? codec->long_name : avcodec_get_name(codec->id);
+		ui->combo_video_codec->addItem(QString::fromStdString(name), static_cast<int>(codec->id));
+	}
+
+	for (const AVCodec* codec : m_audio_codecs)
+	{
+		if (!codec) continue;
+
+		const std::string name = codec->long_name ? codec->long_name : avcodec_get_name(codec->id);
+		ui->combo_audio_codec->addItem(QString::fromStdString(name), static_cast<int>(codec->id));
+	}
+
+	connect(ui->combo_video_codec, &QComboBox::currentIndexChanged, this, [this](int index)
+	{
+		const QVariant var = ui->combo_video_codec->itemData(index);
+		if (var.canConvert<int>())
+		{
+			const int codec_id = var.toInt();
+			g_cfg_recording.video.video_codec.set(codec_id);
+			update_preset();
+		}
+	});
+
+	connect(ui->combo_audio_codec, &QComboBox::currentIndexChanged, this, [this](int index)
+	{
+		const QVariant var = ui->combo_audio_codec->itemData(index);
+		if (var.canConvert<int>())
+		{
+			const int codec_id = var.toInt();
+			g_cfg_recording.audio.audio_codec.set(codec_id);
+			update_preset();
+		}
+	});
+
+	ui->combo_framerate->addItem("30", 30);
+	ui->combo_framerate->addItem("60", 60);
+	connect(ui->combo_framerate, &QComboBox::currentIndexChanged, this, [this](int index)
+	{
+		const QVariant var = ui->combo_framerate->itemData(index);
+		if (var.canConvert<int>())
+		{
+			const int fps = var.toInt();
+			g_cfg_recording.video.framerate.set(fps);
+			update_preset();
+		}
+	});
+
+	ui->spinbox_video_bitrate->setSingleStep(1);
+	ui->spinbox_video_bitrate->setMinimum(g_cfg_recording.video.video_bps.min);
+	ui->spinbox_video_bitrate->setMaximum(g_cfg_recording.video.video_bps.max);
+	connect(ui->spinbox_video_bitrate, &QSpinBox::valueChanged, this, [this](int value)
+	{
+		g_cfg_recording.video.video_bps.set(value);
+		update_preset();
+	});
+
+	ui->spinbox_audio_bitrate->setSingleStep(1);
+	ui->spinbox_audio_bitrate->setMinimum(g_cfg_recording.audio.audio_bps.min);
+	ui->spinbox_audio_bitrate->setMaximum(g_cfg_recording.audio.audio_bps.max);
+	connect(ui->spinbox_audio_bitrate, &QSpinBox::valueChanged, this, [this](int value)
+	{
+		g_cfg_recording.audio.audio_bps.set(value);
+		update_preset();
+	});
+
+	ui->spinbox_gop_size->setSingleStep(1);
+	ui->spinbox_gop_size->setMinimum(g_cfg_recording.video.gop_size.min);
+	ui->spinbox_gop_size->setMaximum(g_cfg_recording.video.gop_size.max);
+	connect(ui->spinbox_gop_size, &QSpinBox::valueChanged, this, [this](int value)
+	{
+		g_cfg_recording.video.gop_size.set(value);
+		update_preset();
+	});
+
+	ui->spinbox_max_b_frames->setSingleStep(1);
+	ui->spinbox_max_b_frames->setMinimum(g_cfg_recording.video.max_b_frames.min);
+	ui->spinbox_max_b_frames->setMaximum(g_cfg_recording.video.max_b_frames.max);
+	connect(ui->spinbox_max_b_frames, &QSpinBox::valueChanged, this, [this](int value)
+	{
+		g_cfg_recording.video.max_b_frames.set(value);
+		update_preset();
+	});
+
+	connect(ui->buttonBox, &QDialogButtonBox::clicked, [this](QAbstractButton* button)
+	{
+		if (button == ui->buttonBox->button(QDialogButtonBox::Save))
+		{
+			g_cfg_recording.save();
+			accept();
+		}
+		else if (button == ui->buttonBox->button(QDialogButtonBox::Cancel))
+		{
+			reject();
+		}
+		else if (button == ui->buttonBox->button(QDialogButtonBox::RestoreDefaults))
+		{
+			g_cfg_recording.from_default();
+			update_ui();
+			update_preset();
+		}
+	});
+
+	connect(this, &QDialog::rejected, this, []()
+	{
+		if (!g_cfg_recording.load())
+		{
+			cfg_log.notice("Could not load recording config. Using defaults.");
+		}
+	});
+
+	update_ui();
+	update_preset();
+}
+
+recording_settings_dialog::~recording_settings_dialog()
+{
+}
+
+void recording_settings_dialog::update_preset()
+{
+	const quality_preset preset = current_preset();
+	ui->combo_presets->setCurrentIndex(ui->combo_presets->findData(static_cast<int>(preset)));
+}
+
+void recording_settings_dialog::update_ui()
+{
+	ui->combo_resolution->blockSignals(true);
+	ui->combo_framerate->blockSignals(true);
+	ui->combo_video_codec->blockSignals(true);
+	ui->combo_audio_codec->blockSignals(true);
+	ui->spinbox_video_bitrate->blockSignals(true);
+	ui->spinbox_audio_bitrate->blockSignals(true);
+	ui->spinbox_gop_size->blockSignals(true);
+	ui->spinbox_max_b_frames->blockSignals(true);
+
+	ui->combo_resolution->setCurrentIndex(ui->combo_resolution->findData(QVariant::fromValue(QPair<int, int>(g_cfg_recording.video.width.get(), g_cfg_recording.video.height.get()))));
+	ui->combo_framerate->setCurrentIndex(ui->combo_framerate->findData(static_cast<int>(g_cfg_recording.video.framerate.get())));
+	ui->combo_video_codec->setCurrentIndex(ui->combo_video_codec->findData(static_cast<int>(g_cfg_recording.video.video_codec.get())));
+	ui->combo_audio_codec->setCurrentIndex(ui->combo_audio_codec->findData(static_cast<int>(g_cfg_recording.audio.audio_codec.get())));
+	ui->spinbox_video_bitrate->setValue(g_cfg_recording.video.video_bps);
+	ui->spinbox_audio_bitrate->setValue(g_cfg_recording.audio.audio_bps);
+	ui->spinbox_gop_size->setValue(g_cfg_recording.video.gop_size);
+	ui->spinbox_max_b_frames->setValue(g_cfg_recording.video.max_b_frames);
+
+	ui->combo_resolution->blockSignals(false);
+	ui->combo_framerate->blockSignals(false);
+	ui->combo_video_codec->blockSignals(false);
+	ui->combo_audio_codec->blockSignals(false);
+	ui->spinbox_video_bitrate->blockSignals(false);
+	ui->spinbox_audio_bitrate->blockSignals(false);
+	ui->spinbox_gop_size->blockSignals(false);
+	ui->spinbox_max_b_frames->blockSignals(false);
+
+	const auto get_codec_name = [](const std::vector<const AVCodec*>& codecs, u32 id)
+	{
+		for (const AVCodec* codec : codecs)
+		{
+			if (codec && codec->id == static_cast<AVCodecID>(id))
+			{
+				const std::string name = codec->long_name ? codec->long_name : avcodec_get_name(codec->id);
+				return name;
+			}
+		}
+		return std::string();
+	};
+
+	ui->label_info_keys->setText(
+		tr("Resolution:") + "\n" +
+		tr("Framerate:") + "\n" +
+		tr("Video Codec:") + "\n" +
+		tr("Video Bitrate:") + "\n" +
+		tr("Audio Codec:") + "\n" +
+		tr("Audio Bitrate:") + "\n" +
+		tr("Gop-Size:") + "\n" +
+		tr("Max B-Frames:")
+	);
+
+	ui->label_info_values->setText(QString::fromStdString(
+		fmt::format("%d x %d\n%d fps\n%s\n%d\n%s\n%d\n%d\n%d",
+			g_cfg_recording.video.width.get(), g_cfg_recording.video.height.get(),
+			g_cfg_recording.video.framerate.get(),
+			get_codec_name(m_video_codecs, g_cfg_recording.video.video_codec.get()),
+			g_cfg_recording.video.video_bps.get(),
+			get_codec_name(m_audio_codecs, g_cfg_recording.audio.audio_codec.get()),
+			g_cfg_recording.audio.audio_bps.get(),
+			g_cfg_recording.video.gop_size.get(),
+			g_cfg_recording.video.max_b_frames.get()
+		)
+	));
+}
+
+void recording_settings_dialog::select_preset(quality_preset preset, cfg_recording& cfg)
+{
+	if (preset == quality_preset::custom)
+	{
+		return;
+	}
+
+	cfg.audio.audio_codec.set(static_cast<u32>(AVCodecID::AV_CODEC_ID_AAC));
+	cfg.audio.audio_bps.set(192'000); // 192 kbps
+
+	cfg.video.video_codec.set(static_cast<u32>(AVCodecID::AV_CODEC_ID_MPEG4));
+	cfg.video.pixel_format.set(static_cast<u32>(::AV_PIX_FMT_YUV420P));
+
+	switch (preset)
+	{
+	case quality_preset::_720p_30:
+	case quality_preset::_720p_60:
+		cfg.video.width.set(1280);
+		cfg.video.height.set(720);
+		break;
+	case quality_preset::_1080p_30:
+	case quality_preset::_1080p_60:
+		cfg.video.width.set(1920);
+		cfg.video.height.set(1080);
+		break;
+	case quality_preset::_1440p_30:
+	case quality_preset::_1440p_60:
+		cfg.video.width.set(2560);
+		cfg.video.height.set(1440);
+		break;
+	case quality_preset::_2160p_30:
+	case quality_preset::_2160p_60:
+		cfg.video.width.set(3840);
+		cfg.video.height.set(2160);
+		break;
+	case quality_preset::custom:
+		break;
+	}
+
+	switch (preset)
+	{
+	case quality_preset::_720p_30:
+	case quality_preset::_1080p_30:
+	case quality_preset::_1440p_30:
+	case quality_preset::_2160p_30:
+		cfg.video.framerate.set(30);
+		break;
+	case quality_preset::_720p_60:
+	case quality_preset::_1080p_60:
+	case quality_preset::_1440p_60:
+	case quality_preset::_2160p_60:
+		cfg.video.framerate.set(60);
+		break;
+	case quality_preset::custom:
+		break;
+	}
+
+	switch (preset)
+	{
+	case quality_preset::_720p_30:
+		cfg.video.video_bps.set(4'000'000);
+		break;
+	case quality_preset::_720p_60:
+		cfg.video.video_bps.set(6'000'000);
+		break;
+	case quality_preset::_1080p_30:
+		cfg.video.video_bps.set(8'000'000);
+		break;
+	case quality_preset::_1080p_60:
+		cfg.video.video_bps.set(12'000'000);
+		break;
+	case quality_preset::_1440p_30:
+		cfg.video.video_bps.set(16'000'000);
+		break;
+	case quality_preset::_1440p_60:
+		cfg.video.video_bps.set(24'000'000);
+		break;
+	case quality_preset::_2160p_30:
+		cfg.video.video_bps.set(40'000'000);
+		break;
+	case quality_preset::_2160p_60:
+		cfg.video.video_bps.set(60'000'000);
+		break;
+	case quality_preset::custom:
+		break;
+	}
+
+	cfg.video.gop_size.set(cfg.video.framerate.get());
+	cfg.video.max_b_frames.set(2);
+}
+
+recording_settings_dialog::quality_preset recording_settings_dialog::current_preset()
+{
+	for (u32 i = 0; i < static_cast<u32>(quality_preset::custom); i++)
+	{
+		const quality_preset preset = static_cast<quality_preset>(i);
+
+		cfg_recording cfg;
+		select_preset(preset, cfg);
+
+		if (g_cfg_recording.video.framerate.get() == cfg.video.framerate.get() &&
+			g_cfg_recording.video.width.get() == cfg.video.width.get() &&
+			g_cfg_recording.video.height.get() == cfg.video.height.get() &&
+			g_cfg_recording.video.pixel_format.get() == cfg.video.pixel_format.get() &&
+			g_cfg_recording.video.video_codec.get() == cfg.video.video_codec.get() &&
+			g_cfg_recording.video.video_bps.get() == cfg.video.video_bps.get() &&
+			g_cfg_recording.video.max_b_frames.get() == cfg.video.max_b_frames.get() &&
+			g_cfg_recording.video.gop_size.get() == cfg.video.gop_size.get() &&
+			g_cfg_recording.audio.audio_codec.get() == cfg.audio.audio_codec.get() &&
+			g_cfg_recording.audio.audio_bps.get() == cfg.audio.audio_bps.get())
+		{
+			return preset;
+		}
+	}
+
+	return quality_preset::custom;
+}
diff --git a/rpcs3/rpcs3qt/recording_settings_dialog.h b/rpcs3/rpcs3qt/recording_settings_dialog.h
new file mode 100644
index 0000000000..3a17d7d8a8
--- /dev/null
+++ b/rpcs3/rpcs3qt/recording_settings_dialog.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "util/types.hpp"
+#include "Emu/Io/recording_config.h"
+
+#include <QDialog>
+
+namespace Ui
+{
+	class recording_settings_dialog;
+}
+
+struct AVCodec;
+
+class recording_settings_dialog : public QDialog
+{
+	Q_OBJECT
+
+public:
+	recording_settings_dialog(QWidget* parent = nullptr);
+	virtual ~recording_settings_dialog();
+
+private:
+	enum class quality_preset
+	{
+		_720p_30,
+		_720p_60,
+		_1080p_30,
+		_1080p_60,
+		_1440p_30,
+		_1440p_60,
+		_2160p_30,
+		_2160p_60,
+		custom
+	};
+
+	void update_preset();
+	void update_ui();
+
+	static void select_preset(quality_preset preset, cfg_recording& cfg);
+	static quality_preset current_preset();
+
+	Ui::recording_settings_dialog* ui;
+
+	std::vector<const AVCodec*> m_video_codecs;
+	std::vector<const AVCodec*> m_audio_codecs;
+};
diff --git a/rpcs3/rpcs3qt/recording_settings_dialog.ui b/rpcs3/rpcs3qt/recording_settings_dialog.ui
new file mode 100644
index 0000000000..9d11e1299a
--- /dev/null
+++ b/rpcs3/rpcs3qt/recording_settings_dialog.ui
@@ -0,0 +1,273 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>recording_settings_dialog</class>
+ <widget class="QDialog" name="recording_settings_dialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>692</width>
+    <height>734</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Recording Settings</string>
+  </property>
+  <layout class="QVBoxLayout" name="main_layout">
+   <item>
+    <widget class="QTabWidget" name="tabWidget">
+     <property name="currentIndex">
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="presets_tab">
+      <attribute name="title">
+       <string>Presets</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="layout_presets_tab">
+       <item>
+        <widget class="QGroupBox" name="gb_presets">
+         <property name="title">
+          <string>Preset</string>
+         </property>
+         <layout class="QVBoxLayout" name="layout_gb_presets">
+          <item>
+           <widget class="QComboBox" name="combo_presets"/>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="gb_info">
+         <property name="title">
+          <string>Info</string>
+         </property>
+         <layout class="QHBoxLayout" name="layout_gb_info">
+          <item>
+           <widget class="QLabel" name="label_info_keys">
+            <property name="text">
+             <string>Keys</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="label_info_values">
+            <property name="text">
+             <string>Values</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <spacer name="info_spacer">
+            <property name="orientation">
+             <enum>Qt::Orientation::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>0</width>
+              <height>0</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <spacer name="spacer_presets_tab">
+         <property name="orientation">
+          <enum>Qt::Orientation::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>0</width>
+           <height>0</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="advanced_tab">
+      <attribute name="title">
+       <string>Advanced</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="layout_advanced_tab">
+       <item>
+        <widget class="QGroupBox" name="gb_advanced_video">
+         <property name="title">
+          <string>Video</string>
+         </property>
+         <layout class="QVBoxLayout" name="layout_gb_advanced_video">
+          <item>
+           <widget class="QGroupBox" name="gb_video_codec">
+            <property name="title">
+             <string>Codec</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_video_codec">
+             <item>
+              <widget class="QComboBox" name="combo_video_codec"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGroupBox" name="gb_resolution">
+            <property name="title">
+             <string>Resolution</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_resolution">
+             <item>
+              <widget class="QComboBox" name="combo_resolution"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGroupBox" name="gb_framerate">
+            <property name="title">
+             <string>Framerate</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_framerate">
+             <item>
+              <widget class="QComboBox" name="combo_framerate"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGroupBox" name="gb_video_bitrate">
+            <property name="title">
+             <string>Bitrate</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_video_bitrate">
+             <item>
+              <widget class="QSpinBox" name="spinbox_video_bitrate"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGroupBox" name="gb_gop_size">
+            <property name="title">
+             <string>Group of Pictures Size</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_gop_size">
+             <item>
+              <widget class="QSpinBox" name="spinbox_gop_size"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGroupBox" name="gb_max_b_frames">
+            <property name="title">
+             <string>Max. B-Frames</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_max_b_frames">
+             <item>
+              <widget class="QSpinBox" name="spinbox_max_b_frames"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="gb_advanced_audio">
+         <property name="title">
+          <string>Audio</string>
+         </property>
+         <layout class="QVBoxLayout" name="layout_gb_advanced_audio">
+          <item>
+           <widget class="QGroupBox" name="gb_audio_codec">
+            <property name="title">
+             <string>Codec</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_audio_codec">
+             <item>
+              <widget class="QComboBox" name="combo_audio_codec"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+          <item>
+           <widget class="QGroupBox" name="gb_audio_bitrate">
+            <property name="title">
+             <string>Bitrate</string>
+            </property>
+            <layout class="QVBoxLayout" name="layout_gb_audio_bitrate">
+             <item>
+              <widget class="QSpinBox" name="spinbox_audio_bitrate"/>
+             </item>
+            </layout>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <spacer name="spacer_advanced_tab">
+         <property name="orientation">
+          <enum>Qt::Orientation::Vertical</enum>
+         </property>
+         <property name="sizeHint" stdset="0">
+          <size>
+           <width>0</width>
+           <height>0</height>
+          </size>
+         </property>
+        </spacer>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Orientation::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::StandardButton::Cancel|QDialogButtonBox::StandardButton::RestoreDefaults|QDialogButtonBox::StandardButton::Save</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>recording_settings_dialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>recording_settings_dialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>

From ab03d76ed6ce7910ded0e67db756c36a098822f6 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 29 Mar 2026 18:32:44 +0200
Subject: [PATCH 62/98] overlays: show latching message for fatal errors

---
 rpcs3/Emu/RSX/Overlays/overlay_controls.cpp     |  8 ++++----
 rpcs3/Emu/RSX/Overlays/overlay_controls.h       |  4 ++--
 rpcs3/Emu/RSX/Overlays/overlay_edit_text.cpp    |  4 ++--
 rpcs3/Emu/RSX/Overlays/overlay_edit_text.hpp    |  4 ++--
 rpcs3/Emu/RSX/Overlays/overlay_message.cpp      |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_message.h        |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_progress_bar.cpp |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_progress_bar.hpp |  2 +-
 rpcs3/Emu/RSX/Overlays/overlay_utils.cpp        | 14 +++++++-------
 rpcs3/Emu/RSX/Overlays/overlay_utils.h          | 12 ++++++------
 rpcs3/Emu/System.cpp                            |  2 +-
 rpcs3/rpcs3.cpp                                 |  8 +++++++-
 12 files changed, 35 insertions(+), 29 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
index 93148d655c..5208efd747 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.cpp
@@ -431,25 +431,25 @@ namespace rsx
 			m_is_compiled = false;
 		}
 
-		void overlay_element::set_text(const std::string& text)
+		void overlay_element::set_text(std::string_view text)
 		{
 			std::u32string new_text = utf8_to_u32string(text);
 			const bool is_dirty = this->text != new_text;
-			this->text = std::move(new_text);
 
 			if (is_dirty)
 			{
+				this->text = std::move(new_text);
 				m_is_compiled = false;
 			}
 		}
 
-		void overlay_element::set_unicode_text(const std::u32string& text)
+		void overlay_element::set_unicode_text(std::u32string_view text)
 		{
 			const bool is_dirty = this->text != text;
-			this->text = text;
 
 			if (is_dirty)
 			{
+				this->text = text;
 				m_is_compiled = false;
 			}
 		}
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_controls.h b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
index 04b6820287..8fa835f595 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_controls.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_controls.h
@@ -242,8 +242,8 @@ namespace rsx
 			// NOTE: Functions as a simple position offset. Top left corner is the anchor.
 			virtual void set_margin(u16 left, u16 top);
 			virtual void set_margin(u16 margin);
-			virtual void set_text(const std::string& text);
-			virtual void set_unicode_text(const std::u32string& text);
+			virtual void set_text(std::string_view text);
+			virtual void set_unicode_text(std::u32string_view text);
 			void set_text(localized_string_id id);
 			void set_text(const localized_string& container);
 			virtual void set_font(const char* font_name, u16 font_size);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_edit_text.cpp b/rpcs3/Emu/RSX/Overlays/overlay_edit_text.cpp
index ba3d138f96..4fad1f65e9 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_edit_text.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_edit_text.cpp
@@ -95,12 +95,12 @@ namespace rsx
 			}
 		}
 
-		void edit_text::set_text(const std::string& text)
+		void edit_text::set_text(std::string_view text)
 		{
 			set_unicode_text(utf8_to_u32string(text));
 		}
 
-		void edit_text::set_unicode_text(const std::u32string& text)
+		void edit_text::set_unicode_text(std::u32string_view text)
 		{
 			value = text;
 
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_edit_text.hpp b/rpcs3/Emu/RSX/Overlays/overlay_edit_text.hpp
index 624580e4f4..7d4f6d93b5 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_edit_text.hpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_edit_text.hpp
@@ -26,8 +26,8 @@ namespace rsx
 
 			using label::label;
 
-			void set_text(const std::string& text) override;
-			void set_unicode_text(const std::u32string& text) override;
+			void set_text(std::string_view text) override;
+			void set_unicode_text(std::u32string_view text) override;
 
 			void set_placeholder(const std::u32string& placeholder_text);
 
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_message.cpp b/rpcs3/Emu/RSX/Overlays/overlay_message.cpp
index 304e54de1e..1c49401d02 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_message.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_message.cpp
@@ -90,7 +90,7 @@ namespace rsx
 			return m_loc_id == id;
 		}
 
-		bool message_item::text_matches(const std::u32string& text) const
+		bool message_item::text_matches(std::u32string_view text) const
 		{
 			return m_text.text == text;
 		}
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_message.h b/rpcs3/Emu/RSX/Overlays/overlay_message.h
index 219103e843..e8cb1a3285 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_message.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_message.h
@@ -31,7 +31,7 @@ namespace rsx
 			compiled_resource& get_compiled() override;
 
 			bool id_matches(localized_string_id id) const;
-			bool text_matches(const std::u32string& text) const;
+			bool text_matches(std::u32string_view text) const;
 
 			void set_label_text(const std::string& text);
 
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.cpp b/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.cpp
index 860f54544a..b9140f2a69 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.cpp
@@ -58,7 +58,7 @@ namespace rsx
 			set_pos(x + dx, y + dy);
 		}
 
-		void progress_bar::set_text(const std::string& str)
+		void progress_bar::set_text(std::string_view str)
 		{
 			text_view.set_text(str);
 			text_view.align_text(text_align::center);
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.hpp b/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.hpp
index 6ed6b73c77..d622796dae 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.hpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_progress_bar.hpp
@@ -24,7 +24,7 @@ namespace rsx
 			void set_pos(s16 _x, s16 _y) override;
 			void set_size(u16 _w, u16 _h) override;
 			void translate(s16 dx, s16 dy) override;
-			void set_text(const std::string& str) override;
+			void set_text(std::string_view str) override;
 
 			compiled_resource& get_compiled() override;
 		};
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_utils.cpp b/rpcs3/Emu/RSX/Overlays/overlay_utils.cpp
index 18eac492e9..047ca6fff3 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_utils.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_utils.cpp
@@ -60,7 +60,7 @@ static auto s_ascii_lowering_map = []()
 }();
 
 template<typename F>
-void process_multibyte(const std::string& s, F&& func)
+void process_multibyte(std::string_view s, F&& func)
 {
 	const usz end = s.length();
 	for (usz index = 0; index < end; ++index)
@@ -110,7 +110,7 @@ void process_multibyte(const std::string& s, F&& func)
 	}
 }
 
-std::string utf8_to_ascii8(const std::string& utf8_string)
+std::string utf8_to_ascii8(std::string_view utf8_string)
 {
 	std::string out;
 	out.reserve(utf8_string.length());
@@ -135,7 +135,7 @@ std::string utf8_to_ascii8(const std::string& utf8_string)
 	return out;
 }
 
-std::string utf16_to_ascii8(const std::u16string& utf16_string)
+std::string utf16_to_ascii8(std::u16string_view utf16_string)
 {
 	// Strip extended codes, map to '#' instead (placeholder)
 	std::string out;
@@ -152,7 +152,7 @@ std::string utf16_to_ascii8(const std::u16string& utf16_string)
 	return out;
 }
 
-std::u16string ascii8_to_utf16(const std::string& ascii_string)
+std::u16string ascii8_to_utf16(std::string_view ascii_string)
 {
 	std::u16string out;
 	out.reserve(ascii_string.length());
@@ -168,7 +168,7 @@ std::u16string ascii8_to_utf16(const std::string& ascii_string)
 	return out;
 }
 
-std::u32string utf8_to_u32string(const std::string& utf8_string)
+std::u32string utf8_to_u32string(std::string_view utf8_string)
 {
 	std::u32string result;
 	result.reserve(utf8_string.size());
@@ -181,7 +181,7 @@ std::u32string utf8_to_u32string(const std::string& utf8_string)
 	return result;
 }
 
-std::u16string u32string_to_utf16(const std::u32string& utf32_string)
+std::u16string u32string_to_utf16(std::u32string_view utf32_string)
 {
 	std::u16string result;
 	result.reserve(utf32_string.size());
@@ -194,7 +194,7 @@ std::u16string u32string_to_utf16(const std::u32string& utf32_string)
 	return result;
 }
 
-std::u32string utf16_to_u32string(const std::u16string& utf16_string)
+std::u32string utf16_to_u32string(std::u16string_view utf16_string)
 {
 	std::u32string result;
 	result.reserve(utf16_string.size());
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_utils.h b/rpcs3/Emu/RSX/Overlays/overlay_utils.h
index aaa70f09a3..ab3ec0894d 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_utils.h
+++ b/rpcs3/Emu/RSX/Overlays/overlay_utils.h
@@ -218,9 +218,9 @@ void operator < (const vector3_base<T>& lhs, T rhs)
 using vector3i = vector3_base<int>;
 using vector3f = vector3_base<float>;
 
-std::string utf8_to_ascii8(const std::string& utf8_string);
-std::string utf16_to_ascii8(const std::u16string& utf16_string);
-std::u16string ascii8_to_utf16(const std::string& ascii_string);
-std::u32string utf8_to_u32string(const std::string& utf8_string);
-std::u16string u32string_to_utf16(const std::u32string& utf32_string);
-std::u32string utf16_to_u32string(const std::u16string& utf16_string);
+std::string utf8_to_ascii8(std::string_view utf8_string);
+std::string utf16_to_ascii8(std::u16string_view utf16_string);
+std::u16string ascii8_to_utf16(std::string_view ascii_string);
+std::u32string utf8_to_u32string(std::string_view utf8_string);
+std::u16string u32string_to_utf16(std::u32string_view utf32_string);
+std::u32string utf16_to_u32string(std::u16string_view utf16_string);
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index 4fdb5e47f3..8736ae70a2 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -2837,7 +2837,7 @@ bool Emulator::Pause(bool freeze_emulation, bool show_resume_message)
 		auto msg_ref = std::make_shared<atomic_t<u32>>(1);
 
 		// No timeout
-		rsx::overlays::queue_message(status == system_state::paused ? localized_string_id::EMULATION_PAUSED_RESUME_WITH_START : localized_string_id::EMULATION_FROZEN, -1, msg_ref);
+		rsx::overlays::queue_message(status == system_state::paused ? localized_string_id::EMULATION_PAUSED_RESUME_WITH_START : localized_string_id::EMULATION_FROZEN, umax, msg_ref);
 		m_pause_msgs_refs.emplace_back(msg_ref);
 
 		auto refresh_l = [this, msg_ref, status]()
diff --git a/rpcs3/rpcs3.cpp b/rpcs3/rpcs3.cpp
index 86e3c47171..921394e311 100644
--- a/rpcs3/rpcs3.cpp
+++ b/rpcs3/rpcs3.cpp
@@ -69,6 +69,7 @@ DYNAMIC_IMPORT("ntdll.dll", NtSetTimerResolution, NTSTATUS(ULONG DesiredResoluti
 #include "rpcs3_version.h"
 #include "Emu/System.h"
 #include "Emu/system_utils.hpp"
+#include "Emu/RSX/Overlays/overlay_message.h"
 #include <thread>
 #include <charconv>
 
@@ -312,7 +313,8 @@ public:
 	{
 		if (msg == logs::level::fatal || (msg == logs::level::always && m_log_always))
 		{
-			std::string _msg = "RPCS3: ";
+			static const std::string rpcs3_prefix =  "RPCS3: ";
+			std::string _msg = rpcs3_prefix;
 
 			if (!prefix.empty())
 			{
@@ -351,7 +353,11 @@ public:
 #endif
 			if (msg == logs::level::fatal)
 			{
+				std::string overlay_msg = "Fatal error: " + _msg.substr(rpcs3_prefix.size());
+				fmt::trim_back(overlay_msg, " \t\n");
+
 				// Pause emulation if fatal error encountered
+				rsx::overlays::queue_message(overlay_msg, umax);
 				Emu.Pause(true);
 			}
 		}

From 44dc29e52b5342c8c03f1b480c9313f4b3a72298 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Tue, 24 Mar 2026 19:35:46 +0100
Subject: [PATCH 63/98] Qt: Add some some more thread names

---
 rpcs3/Emu/System.cpp                     | 6 +++++-
 rpcs3/rpcs3qt/downloader.cpp             | 3 +++
 rpcs3/rpcs3qt/memory_viewer_panel.cpp    | 2 ++
 rpcs3/rpcs3qt/movie_item_base.cpp        | 5 +++++
 rpcs3/rpcs3qt/ps_move_tracker_dialog.cpp | 2 ++
 rpcs3/rpcs3qt/screenshot_item.cpp        | 3 +++
 rpcs3/rpcs3qt/update_manager.cpp         | 1 -
 7 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index 8736ae70a2..da7251e291 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -3160,7 +3160,11 @@ void Emulator::GracefulShutdown(bool allow_autoexit, bool async_op, bool savesta
 
 	if (async_op)
 	{
-		std::thread{perform_kill}.detach();
+		std::thread{[perform_kill]()
+		{
+			thread_base::set_name("Perform Kill");
+			perform_kill();
+		}}.detach();
 	}
 	else
 	{
diff --git a/rpcs3/rpcs3qt/downloader.cpp b/rpcs3/rpcs3qt/downloader.cpp
index 852449c0af..9a5038fcc1 100644
--- a/rpcs3/rpcs3qt/downloader.cpp
+++ b/rpcs3/rpcs3qt/downloader.cpp
@@ -8,6 +8,7 @@
 #include "progress_dialog.h"
 
 #include "util/logs.hpp"
+#include "Utilities/Thread.h"
 
 #include <thread>
 
@@ -82,6 +83,8 @@ void downloader::start(const std::string& url, bool follow_location, bool show_p
 
 	m_thread = QThread::create([this]
 	{
+		thread_base::set_name("Downloader");
+
 		// Reset error buffer before we call curl_easy_perform
 		m_curl->reset_error_buffer();
 
diff --git a/rpcs3/rpcs3qt/memory_viewer_panel.cpp b/rpcs3/rpcs3qt/memory_viewer_panel.cpp
index bcaa6537ef..0c779a9558 100644
--- a/rpcs3/rpcs3qt/memory_viewer_panel.cpp
+++ b/rpcs3/rpcs3qt/memory_viewer_panel.cpp
@@ -504,6 +504,8 @@ memory_viewer_panel::memory_viewer_panel(QWidget* parent, std::shared_ptr<CPUDis
 
 			m_search_thread = QThread::create([this, wstr, m_modes = m_modes]()
 			{
+				thread_base::set_name("MemViewerSearch");
+
 				gui_log.notice("Searching for %s (mode: %s)", wstr, m_modes);
 
 				u64 found = 0;
diff --git a/rpcs3/rpcs3qt/movie_item_base.cpp b/rpcs3/rpcs3qt/movie_item_base.cpp
index 669aec515d..cef8fa89c9 100644
--- a/rpcs3/rpcs3qt/movie_item_base.cpp
+++ b/rpcs3/rpcs3qt/movie_item_base.cpp
@@ -1,5 +1,6 @@
 #include "stdafx.h"
 #include "movie_item_base.h"
+#include "Utilities/Thread.h"
 
 movie_item_base::movie_item_base() : qt_video_source()
 {
@@ -33,6 +34,8 @@ void movie_item_base::call_icon_load_func(int index)
 	m_icon_loading = true;
 	m_icon_load_thread.reset(QThread::create([this, index]()
 	{
+		thread_base::set_name(fmt::format("IconLoad %d", index));
+
 		if (m_icon_load_callback)
 		{
 			m_icon_load_callback(index);
@@ -63,6 +66,8 @@ void movie_item_base::call_size_calc_func()
 	m_size_on_disk_loading = true;
 	m_size_calc_thread.reset(QThread::create([this]()
 	{
+		thread_base::set_name("SizeCalc");
+
 		if (m_size_calc_callback)
 		{
 			m_size_calc_callback();
diff --git a/rpcs3/rpcs3qt/ps_move_tracker_dialog.cpp b/rpcs3/rpcs3qt/ps_move_tracker_dialog.cpp
index f00d66245a..218ccfc809 100644
--- a/rpcs3/rpcs3qt/ps_move_tracker_dialog.cpp
+++ b/rpcs3/rpcs3qt/ps_move_tracker_dialog.cpp
@@ -405,6 +405,8 @@ void ps_move_tracker_dialog::reset_camera()
 
 	m_tracker_thread.reset(QThread::create([this]()
 	{
+		thread_base::set_name("PS Move Tracker");
+
 		while (!m_stop_threads)
 		{
 			process_camera_frame();
diff --git a/rpcs3/rpcs3qt/screenshot_item.cpp b/rpcs3/rpcs3qt/screenshot_item.cpp
index dbfd96d44d..2d24c7cb36 100644
--- a/rpcs3/rpcs3qt/screenshot_item.cpp
+++ b/rpcs3/rpcs3qt/screenshot_item.cpp
@@ -1,5 +1,6 @@
 #include "screenshot_item.h"
 #include "qt_utils.h"
+#include "Utilities/Thread.h"
 
 #include <QVBoxLayout>
 
@@ -10,6 +11,8 @@ screenshot_item::screenshot_item(QWidget* parent)
 	{
 		m_thread.reset(QThread::create([this]()
 		{
+			thread_base::set_name("Screenshot item");
+
 			const QPixmap pixmap = gui::utils::get_aligned_pixmap(icon_path, icon_size, 1.0, Qt::SmoothTransformation, gui::utils::align_h::center, gui::utils::align_v::center);
 			Q_EMIT signal_icon_update(pixmap);
 		}));
diff --git a/rpcs3/rpcs3qt/update_manager.cpp b/rpcs3/rpcs3qt/update_manager.cpp
index d32a1810b9..a34292ce0e 100644
--- a/rpcs3/rpcs3qt/update_manager.cpp
+++ b/rpcs3/rpcs3qt/update_manager.cpp
@@ -19,7 +19,6 @@
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QJsonDocument>
-#include <QThread>
 
 #if defined(_WIN32) || defined(__APPLE__)
 #include <7z.h>

From b94e6d486412bc098b998f00159d0e7c50a50196 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 29 Mar 2026 09:43:35 +0200
Subject: [PATCH 64/98] Fix some warnings

---
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp            | 6 +++---
 rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 7511b2ae7b..948c6e8b14 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -2323,7 +2323,7 @@ public:
 					llvm::Value* loop_dictator_after_adjustment{};
 
 					spu_opcode_t reg_target{};
-					reg_target.rt = reduced_loop_info->cond_val_register_idx;
+					reg_target.rt = static_cast<u32>(reduced_loop_info->cond_val_register_idx);
 
 					if (reg_target.rt != reduced_loop_info->cond_val_register_idx)
 					{
@@ -2375,7 +2375,7 @@ public:
 					else
 					{
 						spu_opcode_t reg_incr{};
-						reg_incr.rt = reduced_loop_info->cond_val_incr;
+						reg_incr.rt = static_cast<u32>(reduced_loop_info->cond_val_incr);
 
 						if (reg_incr.rt != reduced_loop_info->cond_val_incr)
 						{
@@ -2425,7 +2425,7 @@ public:
 					else
 					{
 						spu_opcode_t reg_target2{};
-						reg_target2.rt = reduced_loop_info->cond_val_register_argument_idx;
+						reg_target2.rt = static_cast<u32>(reduced_loop_info->cond_val_register_argument_idx);
 
 						if (reg_target2.rt != reduced_loop_info->cond_val_register_argument_idx)
 						{
diff --git a/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp b/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
index e62097c71c..635833c9d8 100644
--- a/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlay_perf_metrics.cpp
@@ -948,7 +948,7 @@ namespace rsx
 					perf_overlay->set_update_interval(perf_settings.update_interval);
 					perf_overlay->set_font(perf_settings.font);
 					perf_overlay->set_font_size(perf_settings.font_size);
-					perf_overlay->set_margins(perf_settings.margin_x, perf_settings.margin_y, perf_settings.center_x.get(), perf_settings.center_y.get());
+					perf_overlay->set_margins(static_cast<f32>(perf_settings.margin_x.get()), static_cast<f32>(perf_settings.margin_y.get()), perf_settings.center_x.get(), perf_settings.center_y.get());
 					perf_overlay->use_window_space = perf_settings.perf_overlay_use_window_space.get();
 					perf_overlay->set_opacity(perf_settings.opacity / 100.f);
 					perf_overlay->set_body_colors(perf_settings.color_body, perf_settings.background_body);

From 433110b4d84a5601f3bf80d35eb50e9f085f5884 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Tue, 24 Mar 2026 19:03:27 +0100
Subject: [PATCH 65/98] Update wolfssl to 5.9.0

---
 3rdparty/wolfssl/wolfssl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3rdparty/wolfssl/wolfssl b/3rdparty/wolfssl/wolfssl
index b077c81eb6..922d04b356 160000
--- a/3rdparty/wolfssl/wolfssl
+++ b/3rdparty/wolfssl/wolfssl
@@ -1 +1 @@
-Subproject commit b077c81eb635392e694ccedbab8b644297ec0285
+Subproject commit 922d04b3568c6428a9fb905ddee3ef5a68db3108

From a10390e52ae51ff1d4c8adfc57d9f72bd19239aa Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 29 Mar 2026 09:45:48 +0200
Subject: [PATCH 66/98] Update libpng to 1.6.56

---
 3rdparty/libpng/libpng | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3rdparty/libpng/libpng b/3rdparty/libpng/libpng
index c3e304954a..d5515b5b8b 160000
--- a/3rdparty/libpng/libpng
+++ b/3rdparty/libpng/libpng
@@ -1 +1 @@
-Subproject commit c3e304954a9cfd154bc0dfbfea2b01cd61d6546d
+Subproject commit d5515b5b8be3901aac04e5bd8bd5c89f287bcd33

From 6dc06b3ff5126469a15fb45a8cd86b3e8e922b3e Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Tue, 24 Mar 2026 18:57:06 +0100
Subject: [PATCH 67/98] Update Qt to 6.11.0

---
 .ci/setup-windows.sh        |  2 +-
 .github/workflows/rpcs3.yml | 14 +++++++-------
 BUILDING.md                 | 10 +++++-----
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/.ci/setup-windows.sh b/.ci/setup-windows.sh
index cee6d624de..d8016d8c13 100755
--- a/.ci/setup-windows.sh
+++ b/.ci/setup-windows.sh
@@ -6,7 +6,7 @@
 QT_HOST="http://qt.mirror.constant.com/"
 QT_URL_VER=$(echo "$QT_VER" | sed "s/\.//g")
 QT_VER_MSVC_UP=$(echo "${QT_VER_MSVC}" | tr '[:lower:]' '[:upper:]')
-QT_PREFIX="online/qtsdkrepository/windows_x86/desktop/qt${QT_VER_MAIN}_${QT_URL_VER}/qt${QT_VER_MAIN}_${QT_URL_VER}/qt.qt${QT_VER_MAIN}.${QT_URL_VER}."
+QT_PREFIX="online/qtsdkrepository/windows_x86/desktop/qt${QT_VER_MAIN}_${QT_URL_VER}/qt${QT_VER_MAIN}_${QT_URL_VER}_${QT_VER_MSVC}_64/qt.qt${QT_VER_MAIN}.${QT_URL_VER}."
 QT_PREFIX_2="win64_${QT_VER_MSVC}_64/${QT_VER}-0-${QT_DATE}"
 QT_SUFFIX="-Windows-Windows_11_24H2-${QT_VER_MSVC_UP}-Windows-Windows_11_24H2-X86_64.7z"
 QT_BASE_URL="${QT_HOST}${QT_PREFIX}${QT_PREFIX_2}qtbase${QT_SUFFIX}"
diff --git a/.github/workflows/rpcs3.yml b/.github/workflows/rpcs3.yml
index 740e844d04..f474643e09 100644
--- a/.github/workflows/rpcs3.yml
+++ b/.github/workflows/rpcs3.yml
@@ -30,23 +30,23 @@ jobs:
       matrix:
         include:
           - os: ubuntu-24.04
-            docker_img: "rpcs3/rpcs3-ci-jammy:1.9"
+            docker_img: "rpcs3/rpcs3-ci-jammy:1.10"
             build_sh: "/rpcs3/.ci/build-linux.sh"
             compiler: clang
             UPLOAD_COMMIT_HASH: d812f1254a1157c80fd402f94446310560f54e5f
             UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-linux"
           - os: ubuntu-24.04
-            docker_img: "rpcs3/rpcs3-ci-jammy:1.9"
+            docker_img: "rpcs3/rpcs3-ci-jammy:1.10"
             build_sh: "/rpcs3/.ci/build-linux.sh"
             compiler: gcc
           - os: ubuntu-24.04-arm
-            docker_img: "rpcs3/rpcs3-ci-jammy-aarch64:1.9"
+            docker_img: "rpcs3/rpcs3-ci-jammy-aarch64:1.10"
             build_sh: "/rpcs3/.ci/build-linux-aarch64.sh"
             compiler: clang
             UPLOAD_COMMIT_HASH: a1d35836e8d45bfc6f63c26f0a3e5d46ef622fe1
             UPLOAD_REPO_FULL_NAME: "rpcs3/rpcs3-binaries-linux-arm64"
           - os: ubuntu-24.04-arm
-            docker_img: "rpcs3/rpcs3-ci-jammy-aarch64:1.9"
+            docker_img: "rpcs3/rpcs3-ci-jammy-aarch64:1.10"
             build_sh: "/rpcs3/.ci/build-linux-aarch64.sh"
             compiler: gcc
     name: RPCS3 Linux ${{ matrix.os }} ${{ matrix.compiler }}
@@ -134,7 +134,7 @@ jobs:
     runs-on: macos-14
     env:
       CCACHE_DIR: /tmp/ccache_dir
-      QT_VER: '6.10.2'
+      QT_VER: '6.11.0'
       QT_VER_MAIN: '6'
       LLVM_COMPILER_VER: '21'
       RELEASE_MESSAGE: ../GitHubReleaseMessage.txt
@@ -213,9 +213,9 @@ jobs:
     env:
       COMPILER: msvc
       QT_VER_MAIN: '6'
-      QT_VER: '6.10.2'
+      QT_VER: '6.11.0'
       QT_VER_MSVC: 'msvc2022'
-      QT_DATE: '202601261212'
+      QT_DATE: '202603180535'
       LLVM_VER: '19.1.7'
       VULKAN_VER: '1.3.268.0'
       VULKAN_SDK_SHA: '8459ef49bd06b697115ddd3d97c9aec729e849cd775f5be70897718a9b3b9db5'
diff --git a/BUILDING.md b/BUILDING.md
index 597621e810..c1774908fd 100644
--- a/BUILDING.md
+++ b/BUILDING.md
@@ -20,26 +20,26 @@ The following tools are required to build RPCS3 on Windows 10 or later:
     with standalone **CMake** tool.
 
 - [Python 3.6+](https://www.python.org/downloads/) (add to PATH)
-- [Qt 6.10.2](https://www.qt.io/download-qt-installer) In case you can't download from the official installer, you can use [Another Qt installer](https://github.com/miurahr/aqtinstall) (In that case you will need to manually add the "qtmultimedia" module when installing Qt)
+- [Qt 6.11.0](https://www.qt.io/download-qt-installer) In case you can't download from the official installer, you can use [Another Qt installer](https://github.com/miurahr/aqtinstall) (In that case you will need to manually add the "qtmultimedia" module when installing Qt)
 - [Vulkan SDK 1.3.268.0](https://vulkan.lunarg.com/sdk/home) (see "Install the SDK" [here](https://vulkan.lunarg.com/doc/sdk/latest/windows/getting_started.html)) for now future SDKs don't work. You need precisely 1.3.268.0.
 
 The `sln` solution available only on **Visual Studio** is the preferred building solution. It easily allows to build the **RPCS3** application in `Release` and `Debug` mode.
 
 In order to build **RPCS3** with the `sln` solution (with **Visual Studio**), **Qt** libs need to be detected. To detect the libs:
-- add and set the `QTDIR` environment variable, e.g. `<QtInstallFolder>\6.10.2\msvc2022_64\`
+- add and set the `QTDIR` environment variable, e.g. `<QtInstallFolder>\6.11.0\msvc2022_64\`
 - or use the [Visual Studio Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.QtVisualStudioTools2022)
 
   **NOTE:** If you have issues with the **Visual Studio Qt Plugin**, you may want to uninstall it and install the [Legacy Qt Plugin](https://marketplace.visualstudio.com/items?itemName=TheQtCompany.LEGACYQtVisualStudioTools2022) instead.
 
 In order to build **RPCS3** with the `CMake` solution (with both **Visual Studio** and standalone **CMake** tool):
-- add and set the `Qt6_ROOT` environment variable to the **Qt** libs path, e.g. `<QtInstallFolder>\6.10.2\msvc2022_64\`
+- add and set the `Qt6_ROOT` environment variable to the **Qt** libs path, e.g. `<QtInstallFolder>\6.11.0\msvc2022_64\`
 
 ### Linux
 
 These are the essentials tools to build RPCS3 on Linux. Some of them can be installed through your favorite package manager:
 - Clang 17+ or GCC 13+
 - [CMake 3.28.0+](https://www.cmake.org/download/)
-- [Qt 6.10.2](https://www.qt.io/download-qt-installer)
+- [Qt 6.11.0](https://www.qt.io/download-qt-installer)
 - [Vulkan SDK 1.3.268.0](https://vulkan.lunarg.com/sdk/home) (See "Install the SDK" [here](https://vulkan.lunarg.com/doc/sdk/latest/linux/getting_started.html)) for now future SDKs don't work. You need precisely 1.3.268.0.
 - [SDL3](https://github.com/libsdl-org/SDL/releases) (for the FAudio backend)
 
@@ -123,7 +123,7 @@ Start **Visual Studio**, click on `Open a project or solution` and select the `r
 ##### Configuring the Qt Plugin (if used)
 
 1) go to `Extensions->Qt VS Tools->Qt Versions`
-2) add the path to your Qt installation with compiler e.g. `<QtInstallFolder>\6.10.2\msvc2022_64`, version will fill in automatically
+2) add the path to your Qt installation with compiler e.g. `<QtInstallFolder>\6.11.0\msvc2022_64`, version will fill in automatically
 3) go to `Extensions->Qt VS Tools->Options->Legacy Project Format`. (Only available in the **Legacy Qt Plugin**)
 4) set `Build: Run pre-build setup` to `true`. (Only available in the **Legacy Qt Plugin**)
 

From 3e60bd2aa600c328eebccb7b905f9c5e6d394aef Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Wed, 18 Mar 2026 18:56:46 +0100
Subject: [PATCH 68/98] steam: disable steam input for shortcuts

---
 rpcs3/rpcs3qt/steam_utils.cpp | 188 ++++++++++++++++++++++++++++++++--
 rpcs3/rpcs3qt/steam_utils.h   |   4 +-
 2 files changed, 184 insertions(+), 8 deletions(-)

diff --git a/rpcs3/rpcs3qt/steam_utils.cpp b/rpcs3/rpcs3qt/steam_utils.cpp
index 2642e25b37..e5aedf9e20 100644
--- a/rpcs3/rpcs3qt/steam_utils.cpp
+++ b/rpcs3/rpcs3qt/steam_utils.cpp
@@ -71,6 +71,8 @@ namespace gui::utils
 		}
 
 		const std::vector<u8> data = vdf.to_vector<u8>();
+		vdf.close();
+
 		usz last_pos = 0;
 		usz pos = 0;
 
@@ -507,9 +509,17 @@ namespace gui::utils
 			sys_log.success("Removed steam shortcut(s) for '%s'", entry.app_name);
 		}
 
+		update_steam_input_config(user_dir);
+
 		return true;
 	}
 
+	bool steam_shortcut::steam_installed()
+	{
+		const std::string path = get_steam_path();
+		return !path.empty() && fs::is_dir(path);
+	}
+
 	u32 steam_shortcut::crc32(const std::string& data)
 	{
 		u32 crc = 0xFFFFFFFF;
@@ -527,12 +537,6 @@ namespace gui::utils
 		return ~crc;
 	}
 
-	bool steam_shortcut::steam_installed()
-	{
-		const std::string path = get_steam_path();
-		return !path.empty() && fs::is_dir(path);
-	}
-
 	u32 steam_shortcut::steam_appid(const std::string& exe, const std::string& name)
 	{
 		return crc32(exe + name) | 0x80000000;
@@ -667,8 +671,177 @@ namespace gui::utils
 		return str;
 	}
 
+	void steam_shortcut::update_steam_input_config(const std::string& user_dir)
+	{
+		if (m_entries_to_add.empty() && m_entries_to_remove.empty())
+		{
+			return;
+		}
+
+		const std::string vdf_path = user_dir + "localconfig.vdf";
+		const std::string backup_path = fs::get_config_dir() + "/localconfig.vdf.backup";
+
+		if (fs::is_file(vdf_path) && !fs::copy_file(vdf_path, backup_path, true))
+		{
+			sys_log.error("Failed to backup steam localconfig file '%s'", vdf_path);
+			return;
+		}
+
+		fs::file vdf(vdf_path);
+		if (!vdf)
+		{
+			sys_log.error("update_steam_input_config: Failed to open steam localconfig file '%s': %s", vdf_path, fs::g_tls_error);
+			return;
+		}
+
+		std::string content = vdf.to_string();
+		vdf.close();
+
+		static const std::string app_section_start = "\n\t\"apps\"\n\t{";
+		static const std::string app_section_end = "\n\t}\n";
+		static const std::string entry_section_end = "\n\t\t}";
+
+		bool nothing_to_remove = m_entries_to_remove.empty();
+
+		usz app_pos = content.rfind(app_section_start);
+		if (app_pos == umax)
+		{
+			if (!nothing_to_remove)
+			{
+				// We don't have to remove anything because this section did not exist
+				sys_log.notice("update_steam_input_config: Could not find \"apps\" section. No need to remove anything.");
+				nothing_to_remove = true;
+			}
+
+			if (m_entries_to_add.empty())
+			{
+				return; // Nothing to do anyway
+			}
+
+			const usz insert_pos = content.rfind("\n}");
+			if (insert_pos == umax)
+			{
+				sys_log.error("update_steam_input_config: Could not find main section end");
+				return;
+			}
+
+			sys_log.notice("update_steam_input_config: Inserting missing \"apps\" section");
+			content.insert(insert_pos, fmt::format("%s\n\t}", app_section_start));
+
+			app_pos = content.rfind(app_section_start);
+			ensure(app_pos != umax);
+		}
+
+		const usz search_start = app_pos + app_section_start.size();
+
+		const usz insert_pos = content.find(app_section_end, search_start);
+		if (insert_pos == umax)
+		{
+			sys_log.error("update_steam_input_config: Could not find apps section end");
+			return;
+		}
+
+		const auto appid_string = [](s32 signed_appid)
+		{
+			return fmt::format("\n\t\t\"%d\"\n", signed_appid);
+		};
+
+		const auto find_entry = [&content, &appid_string, search_start, insert_pos](s32 signed_appid) -> usz
+		{
+			const usz pos = content.find(appid_string(signed_appid), search_start);
+			if (pos >= insert_pos) return umax;
+			return pos;
+		};
+
+		bool dirty = false;
+
+		for (const shortcut_entry& entry : m_entries_to_remove)
+		{
+			constexpr bool removal_diabled = true; // Disabled for now. Steam doesn't seem to remove the entries either
+			if constexpr (removal_diabled)
+			{
+				break;
+			}
+
+			if (nothing_to_remove)
+			{
+				break;
+			}
+
+			const s32 signed_appid = static_cast<s32>(entry.appid);
+			const usz pos = find_entry(signed_appid);
+
+			if (pos == umax)
+			{
+				// does not exist, do nothing
+				sys_log.notice("update_steam_input_config: Entry for '%s' with appid '%d' does not exist. Skipping removal", entry.app_name, signed_appid);
+				continue;
+			}
+
+			// Find the opening brace of this entry
+			const usz pos_brace_open = content.find('{', pos);
+			if (pos_brace_open == umax || pos_brace_open >= insert_pos)
+			{
+				sys_log.error("update_steam_input_config: Can't find opening brace for entry for '%s' with appid '%d'.", entry.app_name, signed_appid);
+				continue;
+			}
+
+			// Find the closing brace
+			const usz pos_brace_close = content.find(entry_section_end, pos_brace_open);
+			if (pos_brace_close == umax || pos_brace_close >= insert_pos)
+			{
+				sys_log.error("update_steam_input_config: Can't find closing brace for entry for '%s' with appid '%d'.", entry.app_name, signed_appid);
+				continue;
+			}
+
+			// Include the closing brace line
+			const usz erase_end = pos_brace_close + entry_section_end.size();
+
+			// Erase the whole block
+			content.erase(pos, erase_end - pos);
+
+			sys_log.notice("update_steam_input_config: Removed '%s' with appid '%d'", entry.app_name, signed_appid);
+
+			dirty = true;
+		}
+
+		for (const shortcut_entry& entry : m_entries_to_add)
+		{
+			const s32 signed_appid = static_cast<s32>(entry.appid);
+			const usz pos = find_entry(signed_appid);
+
+			if (pos != umax)
+			{
+				// already exists, do nothing
+				sys_log.notice("update_steam_input_config: Entry for '%s' with appid '%d' already exists", entry.app_name, signed_appid);
+				continue;
+			}
+
+			sys_log.notice("update_steam_input_config: Inserting '%s' with appid '%d'", entry.app_name, signed_appid);
+			content.insert(insert_pos, fmt::format(
+				"%s"
+				"\t\t{\n"
+				"\t\t\t\"UseSteamControllerConfig\"\t\t\"0\"\n"
+				//"\t\t\t\"SteamControllerRumble\"\t\t\"-1\"\n"
+				//"\t\t\t\"SteamControllerRumbleIntensity\"\t\t\"320\"\n"
+				"\t\t}", appid_string(signed_appid)));
+
+			dirty = true;
+		}
+
+		if (dirty && !fs::write_file(vdf_path, fs::rewrite, content))
+		{
+			sys_log.error("Failed to update steam localconfig '%s': '%s'", vdf_path, fs::g_tls_error);
+
+			if (!fs::copy_file(backup_path, vdf_path, true))
+			{
+				sys_log.error("Failed to restore steam localconfig backup: '%s'", fs::g_tls_error);
+			}
+		}
+	}
+
 #ifdef _WIN32
-	std::string get_registry_string(const wchar_t* key, const wchar_t* name)
+	static std::string get_registry_string(const wchar_t* key, const wchar_t* name)
 	{
 		HKEY hkey = NULL;
 		LSTATUS status = RegOpenKeyW(HKEY_CURRENT_USER, key, &hkey);
@@ -832,6 +1005,7 @@ namespace gui::utils
 		// }
 
 		const std::string content = vdf.to_string();
+		vdf.close();
 
 		usz user_count = 0;
 
diff --git a/rpcs3/rpcs3qt/steam_utils.h b/rpcs3/rpcs3qt/steam_utils.h
index 369ee084a2..deb7c0dad7 100644
--- a/rpcs3/rpcs3qt/steam_utils.h
+++ b/rpcs3/rpcs3qt/steam_utils.h
@@ -103,6 +103,8 @@ namespace gui::utils
 
 		bool parse_file(const std::string& path);
 
+		void update_steam_input_config(const std::string& user_dir);
+
 		static u32 crc32(const std::string& data);
 		static u32 steam_appid(const std::string& exe, const std::string& name);
 
@@ -115,7 +117,7 @@ namespace gui::utils
 		static std::string steamid64_to_32(const std::string& steam_id);
 		static std::string get_steam_path();
 		static std::string get_last_active_steam_user(const std::string& steam_path);
-		
+
 		static std::string get_steam_banner_path(steam_banner banner, const std::string& grid_dir, u32 appid);
 		static void create_steam_banner(steam_banner banner, const std::string& src_path, const QPixmap& src_icon, const std::string& grid_dir, const shortcut_entry& entry);
 

From 789bab97be41cb5413cbc832a06729a10e2238eb Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 30 Mar 2026 12:39:46 +0200
Subject: [PATCH 69/98] Qt: add some sorting options to the screenshot manager

---
 rpcs3/rpcs3qt/main_window.cpp               |   4 +-
 rpcs3/rpcs3qt/qt_utils.cpp                  |   5 +
 rpcs3/rpcs3qt/screenshot_item.cpp           |  39 +++-
 rpcs3/rpcs3qt/screenshot_item.h             |  17 +-
 rpcs3/rpcs3qt/screenshot_manager_dialog.cpp | 197 +++++++++++++++-----
 rpcs3/rpcs3qt/screenshot_manager_dialog.h   |  34 +++-
 6 files changed, 232 insertions(+), 64 deletions(-)

diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index b4776d2fc1..130434f0c2 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -3119,9 +3119,9 @@ void main_window::CreateConnects()
 		m_game_list_frame->Refresh(true); // New user may have different games unlocked.
 	});
 
-	connect(ui->actionManage_Screenshots, &QAction::triggered, this, []
+	connect(ui->actionManage_Screenshots, &QAction::triggered, this, [this]
 	{
-		screenshot_manager_dialog* screenshot_manager = new screenshot_manager_dialog();
+		screenshot_manager_dialog* screenshot_manager = new screenshot_manager_dialog(m_game_list_frame ? m_game_list_frame->GetGameInfo() : std::vector<game_info>{});
 		screenshot_manager->show();
 	});
 
diff --git a/rpcs3/rpcs3qt/qt_utils.cpp b/rpcs3/rpcs3qt/qt_utils.cpp
index 7c0760f3a8..ede9f6be9a 100644
--- a/rpcs3/rpcs3qt/qt_utils.cpp
+++ b/rpcs3/rpcs3qt/qt_utils.cpp
@@ -279,6 +279,11 @@ namespace gui
 			exp_img.setDevicePixelRatio(device_pixel_ratio);
 			exp_img.fill(Qt::transparent);
 
+			if (pixmap.isNull())
+			{
+				return exp_img;
+			}
+
 			// Load scaled pixmap
 			pixmap = pixmap.scaled(icon_size, Qt::KeepAspectRatio, mode);
 
diff --git a/rpcs3/rpcs3qt/screenshot_item.cpp b/rpcs3/rpcs3qt/screenshot_item.cpp
index 2d24c7cb36..2897cf968c 100644
--- a/rpcs3/rpcs3qt/screenshot_item.cpp
+++ b/rpcs3/rpcs3qt/screenshot_item.cpp
@@ -4,26 +4,37 @@
 
 #include <QVBoxLayout>
 
-screenshot_item::screenshot_item(QWidget* parent)
+screenshot_item::screenshot_item(QWidget* parent, QSize icon_size, const QString& icon_path, const QPixmap& placeholder)
 	: flow_widget_item(parent)
+	, m_icon_path(icon_path)
+	, m_icon_size(icon_size)
 {
+	setToolTip(icon_path);
+
 	cb_on_first_visibility = [this]()
 	{
 		m_thread.reset(QThread::create([this]()
 		{
 			thread_base::set_name("Screenshot item");
 
-			const QPixmap pixmap = gui::utils::get_aligned_pixmap(icon_path, icon_size, 1.0, Qt::SmoothTransformation, gui::utils::align_h::center, gui::utils::align_v::center);
+			const QPixmap src_icon = QPixmap(m_icon_path);
+			if (src_icon.isNull()) return;
+
+			const QPixmap pixmap = gui::utils::get_aligned_pixmap(src_icon, m_icon_size, 1.0, Qt::SmoothTransformation, gui::utils::align_h::center, gui::utils::align_v::center);
 			Q_EMIT signal_icon_update(pixmap);
 		}));
 		m_thread->start();
 	};
 
-	label = new QLabel(this);
+	m_label = new QLabel(this);
+	m_label->setPixmap(placeholder);
+
 	QVBoxLayout* layout = new QVBoxLayout(this);
 	layout->setContentsMargins(0, 0, 0, 0);
-	layout->addWidget(label);
+	layout->addWidget(m_label);
 	setLayout(layout);
+
+	connect(this, &screenshot_item::signal_icon_update, this, &screenshot_item::update_icon, Qt::ConnectionType::QueuedConnection);
 }
 
 screenshot_item::~screenshot_item()
@@ -33,3 +44,23 @@ screenshot_item::~screenshot_item()
 		m_thread->wait();
 	}
 }
+
+void screenshot_item::update_icon(const QPixmap& pixmap)
+{
+	if (m_label)
+	{
+		m_label->setPixmap(pixmap);
+	}
+}
+
+void screenshot_item::mouseDoubleClickEvent(QMouseEvent* ev)
+{
+	flow_widget_item::mouseDoubleClickEvent(ev);
+
+	if (!ev) return;
+
+	if (ev->button() == Qt::LeftButton)
+	{
+		Q_EMIT signal_icon_preview(m_icon_path);
+	}
+}
diff --git a/rpcs3/rpcs3qt/screenshot_item.h b/rpcs3/rpcs3qt/screenshot_item.h
index 36f0232b1f..df223783f3 100644
--- a/rpcs3/rpcs3qt/screenshot_item.h
+++ b/rpcs3/rpcs3qt/screenshot_item.h
@@ -3,22 +3,29 @@
 #include "flow_widget_item.h"
 #include <QLabel>
 #include <QThread>
+#include <QMouseEvent>
 
 class screenshot_item : public flow_widget_item
 {
 	Q_OBJECT
 
 public:
-	screenshot_item(QWidget* parent);
+	screenshot_item(QWidget* parent, QSize icon_size, const QString& icon_path, const QPixmap& placeholder);
 	virtual ~screenshot_item();
 
-	QString icon_path;
-	QSize icon_size;
-	QLabel* label{};
-
 private:
+	QLabel* m_label{};
+	QString m_icon_path;
+	QSize m_icon_size;
 	std::unique_ptr<QThread> m_thread;
 
+protected:
+	void mouseDoubleClickEvent(QMouseEvent* ev) override;
+
 Q_SIGNALS:
 	void signal_icon_update(const QPixmap& pixmap);
+	void signal_icon_preview(const QString& path);
+
+public Q_SLOTS:
+	void update_icon(const QPixmap& pixmap);
 };
diff --git a/rpcs3/rpcs3qt/screenshot_manager_dialog.cpp b/rpcs3/rpcs3qt/screenshot_manager_dialog.cpp
index 3825dfd747..d99ce35605 100644
--- a/rpcs3/rpcs3qt/screenshot_manager_dialog.cpp
+++ b/rpcs3/rpcs3qt/screenshot_manager_dialog.cpp
@@ -10,13 +10,15 @@
 #include <QApplication>
 #include <QDir>
 #include <QDirIterator>
+#include <QGroupBox>
 #include <QScreen>
 #include <QVBoxLayout>
 #include <QtConcurrent>
 
 LOG_CHANNEL(gui_log, "GUI");
 
-screenshot_manager_dialog::screenshot_manager_dialog(QWidget* parent) : QDialog(parent)
+screenshot_manager_dialog::screenshot_manager_dialog(const std::vector<game_info>& games, QWidget* parent)
+	: QDialog(parent), m_games(games)
 {
 	setWindowTitle(tr("Screenshots"));
 	setAttribute(Qt::WA_DeleteOnClose);
@@ -28,11 +30,50 @@ screenshot_manager_dialog::screenshot_manager_dialog(QWidget* parent) : QDialog(
 	m_placeholder = QPixmap(m_icon_size);
 	m_placeholder.fill(Qt::gray);
 
-	connect(this, &screenshot_manager_dialog::signal_icon_preview, this, &screenshot_manager_dialog::show_preview);
-	connect(this, &screenshot_manager_dialog::signal_entry_parsed, this, &screenshot_manager_dialog::add_entry);
+	connect(this, &screenshot_manager_dialog::signal_entry_parsed, this, &screenshot_manager_dialog::add_entry, Qt::ConnectionType::QueuedConnection);
 
-	QVBoxLayout* layout = new QVBoxLayout;
+	m_combo_sort_filter = new QComboBox();
+	m_combo_sort_filter->setSizeAdjustPolicy(QComboBox::AdjustToContents);
+	m_combo_sort_filter->addItem(tr("Sort by Game"), static_cast<int>(sort_filter::game));
+	m_combo_sort_filter->addItem(tr("Sort by Date"), static_cast<int>(sort_filter::date));
+	connect(m_combo_sort_filter, &QComboBox::currentIndexChanged, this, [this](int /*index*/){ reload(); });
+
+	m_combo_type_filter = new QComboBox();
+	m_combo_type_filter->setSizeAdjustPolicy(QComboBox::AdjustToContents);
+	m_combo_type_filter->addItem(tr("All Screenshots"), static_cast<int>(type_filter::all));
+	m_combo_type_filter->addItem(tr("RPCS3 Screenshots"), static_cast<int>(type_filter::rpcs3));
+	m_combo_type_filter->addItem(tr("Cell Screenshots"), static_cast<int>(type_filter::cell));
+	connect(m_combo_type_filter, &QComboBox::currentIndexChanged, this, [this](int /*index*/){ reload(); });
+
+	m_combo_game_filter = new QComboBox();
+	m_combo_game_filter->setSizeAdjustPolicy(QComboBox::AdjustToContents);
+	m_combo_game_filter->addItem(tr("All Games"), QString());
+	connect(m_combo_game_filter, &QComboBox::currentIndexChanged, this, [this](int /*index*/){ reload(); });
+
+	QHBoxLayout* sort_layout = new QHBoxLayout();
+	sort_layout->addWidget(m_combo_sort_filter);
+	QGroupBox* gb_sort = new QGroupBox(tr("Sort"));
+	gb_sort->setLayout(sort_layout);
+
+	QHBoxLayout* type_layout = new QHBoxLayout();
+	type_layout->addWidget(m_combo_type_filter);
+	QGroupBox* gb_type = new QGroupBox(tr("Filter Type"));
+	gb_type->setLayout(type_layout);
+
+	QHBoxLayout* game_layout = new QHBoxLayout();
+	game_layout->addWidget(m_combo_game_filter);
+	QGroupBox* gb_game = new QGroupBox(tr("Filter Game"));
+	gb_game->setLayout(game_layout);
+
+	QHBoxLayout* top_layout = new QHBoxLayout();
+	top_layout->addWidget(gb_sort);
+	top_layout->addWidget(gb_type);
+	top_layout->addWidget(gb_game);
+	top_layout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::MinimumExpanding, QSizePolicy::Minimum));
+
+	QVBoxLayout* layout = new QVBoxLayout();
 	layout->setContentsMargins(0, 0, 0, 0);
+	layout->addLayout(top_layout);
 	layout->addWidget(m_flow_widget);
 	setLayout(layout);
 
@@ -47,14 +88,8 @@ screenshot_manager_dialog::~screenshot_manager_dialog()
 
 void screenshot_manager_dialog::add_entry(const QString& path)
 {
-	screenshot_item* item = new screenshot_item(m_flow_widget);
-	ensure(item->label);
-	item->setToolTip(path);
-	item->installEventFilter(this);
-	item->label->setPixmap(m_placeholder);
-	item->icon_path = path;
-	item->icon_size = m_icon_size;
-	connect(item, &screenshot_item::signal_icon_update, this, &screenshot_manager_dialog::update_icon);
+	screenshot_item* item = new screenshot_item(m_flow_widget, m_icon_size, path, m_placeholder);
+	connect(item, &screenshot_item::signal_icon_preview, this, &screenshot_manager_dialog::show_preview);
 
 	m_flow_widget->add_widget(item);
 }
@@ -65,28 +100,74 @@ void screenshot_manager_dialog::show_preview(const QString& path)
 	preview->show();
 }
 
-void screenshot_manager_dialog::update_icon(const QPixmap& pixmap)
-{
-	if (screenshot_item* item = static_cast<screenshot_item*>(QObject::sender()))
-	{
-		if (item->label)
-		{
-			item->label->setPixmap(pixmap);
-		}
-	}
-}
-
 void screenshot_manager_dialog::reload()
 {
 	m_abort_parsing = true;
+	m_parsing_watcher.disconnect();
 	gui::utils::stop_future_watcher(m_parsing_watcher, true);
 
-	const std::string screenshot_path_qt   = fs::get_config_dir() + "screenshots/";
-	const std::string screenshot_path_cell = rpcs3::utils::get_hdd0_dir() + "/photo/";
+	const type_filter t_filter = static_cast<type_filter>(m_combo_type_filter->currentData().toInt());
+	const sort_filter s_filter = static_cast<sort_filter>(m_combo_sort_filter->currentData().toInt());
+	const QString game_filter = m_combo_game_filter->currentData().toString();
+
+	const std::string screenshot_path_rpcs3 = fs::get_config_dir() + "screenshots/";
+	const std::string screenshot_path_cell  = rpcs3::utils::get_hdd0_dir() + "/photo/";
+
+	std::vector<std::string> folders;
+	switch (t_filter)
+	{
+	case type_filter::all:
+		folders.push_back(screenshot_path_rpcs3);
+		folders.push_back(screenshot_path_cell);
+		break;
+	case type_filter::rpcs3:
+		folders.push_back(screenshot_path_rpcs3);
+		break;
+	case type_filter::cell:
+		folders.push_back(screenshot_path_cell);
+		break;
+	}
 
 	m_flow_widget->clear();
+	m_game_folders.clear();
 	m_abort_parsing = false;
-	m_parsing_watcher.setFuture(QtConcurrent::map(m_parsing_threads, [this, screenshot_path_qt, screenshot_path_cell](int index)
+
+	connect(&m_parsing_watcher, &QFutureWatcher<void>::finished, this, [this]()
+	{
+		std::vector<std::pair<QString, QString>> games;
+		for (const auto& [dirname, paths] : m_game_folders)
+		{
+			const std::string serial = dirname.toStdString();
+			std::string text = serial;
+			for (const auto& game : m_games)
+			{
+				if (game && game->info.serial == serial)
+				{
+					text = fmt::format("%s (%s)", game->info.name, serial);
+					break;
+				}
+			}
+			games.push_back(std::pair(dirname, QString::fromStdString(text)));
+		}
+
+		std::sort(games.begin(), games.end(), [](const std::pair<QString, QString>& l, const std::pair<QString, QString>& r)
+		{
+			return l.second < r.second;
+		});
+
+		const QString old_filter = m_combo_game_filter->currentData().toString();
+		m_combo_game_filter->blockSignals(true);
+		m_combo_game_filter->clear();
+		m_combo_game_filter->addItem(tr("All Games"), QString());
+		for (const auto& [dirname, text] : games)
+		{
+			m_combo_game_filter->addItem(text, dirname);
+		}
+		m_combo_game_filter->setCurrentIndex(m_combo_game_filter->findData(old_filter));
+		m_combo_game_filter->blockSignals(false);
+	});
+
+	m_parsing_watcher.setFuture(QtConcurrent::map(m_parsing_threads, [this, folders, game_filter, s_filter](int index)
 	{
 		if (index != 0)
 		{
@@ -95,26 +176,68 @@ void screenshot_manager_dialog::reload()
 
 		const QStringList filter{ QStringLiteral("*.png") };
 
-		for (const std::string& path : { screenshot_path_qt, screenshot_path_cell })
+		for (const std::string& folder : folders)
 		{
 			if (m_abort_parsing)
 			{
 				return;
 			}
 
-			if (path.empty())
+			if (folder.empty())
 			{
 				gui_log.error("Screenshot manager: Trying to load screenshots from empty path!");
 				continue;
 			}
 
-			QDirIterator dir_iter(QString::fromStdString(path), filter, QDir::Files | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
+			QDirIterator dir_iter(QString::fromStdString(folder), filter, QDir::Files | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
 
 			while (dir_iter.hasNext() && !m_abort_parsing)
 			{
-				Q_EMIT signal_entry_parsed(dir_iter.next());
+				QFileInfo info(dir_iter.next());
+				const QString dirname = info.dir().dirName();
+				m_game_folders[dirname].push_back(std::move(info));
 			}
 		}
+
+		switch (s_filter)
+		{
+		case sort_filter::game:
+		{
+			for (const auto& [dirname, infos] : m_game_folders)
+			{
+				if (game_filter.isEmpty() || game_filter == dirname)
+				{
+					for (const QFileInfo& info : infos)
+					{
+						Q_EMIT signal_entry_parsed(info.filePath());
+					}
+				}
+			}
+			break;
+		}
+		case sort_filter::date:
+		{
+			std::vector<QFileInfo> sorted_infos;
+			for (const auto& [dirname, infos] : m_game_folders)
+			{
+				if (game_filter.isEmpty() || game_filter == dirname)
+				{
+					sorted_infos.insert(sorted_infos.end(), infos.begin(), infos.end());
+				}
+			}
+
+			std::sort(sorted_infos.begin(), sorted_infos.end(), [](const QFileInfo& a, const QFileInfo& b)
+			{
+				return a.lastModified() < b.lastModified();
+			});
+
+			for (const QFileInfo& info : sorted_infos)
+			{
+				Q_EMIT signal_entry_parsed(info.filePath());
+			}
+			break;
+		}
+		}
 	}));
 }
 
@@ -123,17 +246,3 @@ void screenshot_manager_dialog::showEvent(QShowEvent* event)
 	QDialog::showEvent(event);
 	reload();
 }
-
-bool screenshot_manager_dialog::eventFilter(QObject* watched, QEvent* event)
-{
-	if (event && event->type() == QEvent::MouseButtonDblClick && static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton)
-	{
-		if (screenshot_item* item = static_cast<screenshot_item*>(watched))
-		{
-			Q_EMIT signal_icon_preview(item->icon_path);
-			return true;
-		}
-	}
-
-	return false;
-}
diff --git a/rpcs3/rpcs3qt/screenshot_manager_dialog.h b/rpcs3/rpcs3qt/screenshot_manager_dialog.h
index ab4d7c13a8..a236eb5e0d 100644
--- a/rpcs3/rpcs3qt/screenshot_manager_dialog.h
+++ b/rpcs3/rpcs3qt/screenshot_manager_dialog.h
@@ -1,30 +1,29 @@
 #pragma once
 
 #include "flow_widget.h"
+#include "gui_game_info.h"
 
+#include <QComboBox>
 #include <QDialog>
+#include <QFileInfo>
 #include <QFutureWatcher>
 #include <QPixmap>
 #include <QSize>
-#include <QEvent>
+#include <QShowEvent>
 #include <array>
+#include <vector>
+#include <map>
 
 class screenshot_manager_dialog : public QDialog
 {
 	Q_OBJECT
 
 public:
-	screenshot_manager_dialog(QWidget* parent = nullptr);
+	screenshot_manager_dialog(const std::vector<game_info>& games, QWidget* parent = nullptr);
 	~screenshot_manager_dialog();
 
-	bool eventFilter(QObject* watched, QEvent* event) override;
-
 Q_SIGNALS:
 	void signal_entry_parsed(const QString& path);
-	void signal_icon_preview(const QString& path);
-
-public Q_SLOTS:
-	void update_icon(const QPixmap& pixmap);
 
 private Q_SLOTS:
 	void add_entry(const QString& path);
@@ -36,11 +35,28 @@ protected:
 private:
 	void reload();
 
+	enum class type_filter
+	{
+		all,
+		rpcs3,
+		cell
+	};
+
+	enum class sort_filter
+	{
+		game,
+		date
+	};
+
+	std::vector<game_info> m_games;
 	bool m_abort_parsing = false;
 	const std::array<int, 1> m_parsing_threads{0};
 	QFutureWatcher<void> m_parsing_watcher;
 	flow_widget* m_flow_widget = nullptr;
-
+	QComboBox* m_combo_sort_filter = nullptr;
+	QComboBox* m_combo_game_filter = nullptr;
+	QComboBox* m_combo_type_filter = nullptr;
 	QSize m_icon_size;
 	QPixmap m_placeholder;
+	std::map<QString, std::vector<QFileInfo>> m_game_folders;
 };

From f92677fa7ed2345e225b9bb963894d6daf1722d4 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 30 Mar 2026 12:47:26 +0200
Subject: [PATCH 70/98] rsx: Add missing break

---
 rpcs3/Emu/Cell/PPUThread.cpp | 2 +-
 rpcs3/Emu/RSX/RSXThread.cpp  | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp
index 0062bc2825..f5d91cc519 100644
--- a/rpcs3/Emu/Cell/PPUThread.cpp
+++ b/rpcs3/Emu/Cell/PPUThread.cpp
@@ -1286,7 +1286,7 @@ extern bool ppu_patch(u32 addr, u32 value)
 {
 	if (addr % 4)
 	{
-		ppu_log.fatal("Patch failed at 0x%x: unanligned memory address.", addr);
+		ppu_log.fatal("Patch failed at 0x%x: unaligned memory address.", addr);
 		return false;
 	}
 
diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp
index 5158ce9a29..3392b9693b 100644
--- a/rpcs3/Emu/RSX/RSXThread.cpp
+++ b/rpcs3/Emu/RSX/RSXThread.cpp
@@ -1868,6 +1868,7 @@ namespace rsx
 		}
 		default:
 			rsx_log.fatal("Unhandled framebuffer option changed 0x%x", opt);
+			break;
 		}
 	}
 

From b0dbac9a0774cc97f9628dca56ef7c69e7d0df95 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 29 Mar 2026 17:16:54 +0200
Subject: [PATCH 71/98] Qt: hide log frame by default

---
 rpcs3/rpcs3qt/debugger_frame.cpp  | 1 +
 rpcs3/rpcs3qt/game_list_frame.cpp | 2 ++
 rpcs3/rpcs3qt/gui_settings.h      | 2 +-
 rpcs3/rpcs3qt/log_frame.cpp       | 2 ++
 rpcs3/rpcs3qt/main_window.cpp     | 3 ---
 5 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/rpcs3/rpcs3qt/debugger_frame.cpp b/rpcs3/rpcs3qt/debugger_frame.cpp
index b8ed1d642f..2184974d85 100644
--- a/rpcs3/rpcs3qt/debugger_frame.cpp
+++ b/rpcs3/rpcs3qt/debugger_frame.cpp
@@ -58,6 +58,7 @@ debugger_frame::debugger_frame(std::shared_ptr<gui_settings> gui_settings, QWidg
 	: custom_dock_widget(tr("Debugger [Press F1 for Help]"), parent)
 	, m_gui_settings(std::move(gui_settings))
 {
+	setObjectName("debugger");
 	setContentsMargins(0, 0, 0, 0);
 
 	m_update = new QTimer(this);
diff --git a/rpcs3/rpcs3qt/game_list_frame.cpp b/rpcs3/rpcs3qt/game_list_frame.cpp
index 7ef27ea0f9..36e26cf43d 100644
--- a/rpcs3/rpcs3qt/game_list_frame.cpp
+++ b/rpcs3/rpcs3qt/game_list_frame.cpp
@@ -40,6 +40,8 @@ game_list_frame::game_list_frame(std::shared_ptr<gui_settings> gui_settings, std
 	, m_emu_settings(std::move(emu_settings))
 	, m_persistent_settings(std::move(persistent_settings))
 {
+	setObjectName("gamelist");
+
 	m_game_list_actions = std::make_shared<game_list_actions>(this, m_gui_settings);
 
 	m_icon_size       = gui::gl_icon_size_min; // ensure a valid size
diff --git a/rpcs3/rpcs3qt/gui_settings.h b/rpcs3/rpcs3qt/gui_settings.h
index c15b4166bf..41be2732ab 100644
--- a/rpcs3/rpcs3qt/gui_settings.h
+++ b/rpcs3/rpcs3qt/gui_settings.h
@@ -173,7 +173,7 @@ namespace gui
 	const gui_save fd_save_log     = gui_save(main_window, "lastExplorePathSaveLog", "");
 
 	const gui_save mw_debugger         = gui_save(main_window, "debuggerVisible",  false);
-	const gui_save mw_logger           = gui_save(main_window, "loggerVisible",    true);
+	const gui_save mw_logger           = gui_save(main_window, "loggerVisible",    false);
 	const gui_save mw_gamelist         = gui_save(main_window, "gamelistVisible",  true);
 	const gui_save mw_toolBarVisible   = gui_save(main_window, "toolBarVisible",   true);
 	const gui_save mw_titleBarsVisible = gui_save(main_window, "titleBarsVisible", true);
diff --git a/rpcs3/rpcs3qt/log_frame.cpp b/rpcs3/rpcs3qt/log_frame.cpp
index cf570eea7a..61ca66a909 100644
--- a/rpcs3/rpcs3qt/log_frame.cpp
+++ b/rpcs3/rpcs3qt/log_frame.cpp
@@ -113,6 +113,8 @@ static gui_listener s_gui_listener;
 log_frame::log_frame(std::shared_ptr<gui_settings> _gui_settings, QWidget* parent)
 	: custom_dock_widget(tr("Log"), parent), m_gui_settings(std::move(_gui_settings))
 {
+	setObjectName("logger");
+
 	const int max_block_count_log = m_gui_settings->GetValue(gui::l_limit).toInt();
 	const int max_block_count_tty = m_gui_settings->GetValue(gui::l_limit_tty).toInt();
 
diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index 130434f0c2..2a366705ab 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -3512,11 +3512,8 @@ void main_window::CreateDockWindows()
 	m_mw->setContextMenuPolicy(Qt::PreventContextMenu);
 
 	m_game_list_frame = new game_list_frame(m_gui_settings, m_emu_settings, m_persistent_settings, m_mw);
-	m_game_list_frame->setObjectName("gamelist");
 	m_debugger_frame = new debugger_frame(m_gui_settings, m_mw);
-	m_debugger_frame->setObjectName("debugger");
 	m_log_frame = new log_frame(m_gui_settings, m_mw);
-	m_log_frame->setObjectName("logger");
 
 	m_mw->addDockWidget(Qt::LeftDockWidgetArea, m_game_list_frame);
 	m_mw->addDockWidget(Qt::LeftDockWidgetArea, m_log_frame);

From cb3a83cba743cba540dee72d8448308a488d6f35 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 30 Mar 2026 15:32:37 +0200
Subject: [PATCH 72/98] overlays: add setting for fatal error hint (disabled by
 default)

---
 .../Overlays/HomeMenu/overlay_home_menu_settings.cpp   |  1 +
 rpcs3/Emu/localized_string_id.h                        |  1 +
 rpcs3/Emu/system_config.h                              |  1 +
 rpcs3/rpcs3.cpp                                        | 10 +++++++---
 rpcs3/rpcs3qt/emu_settings_type.h                      |  2 ++
 rpcs3/rpcs3qt/localized_emu.h                          |  1 +
 rpcs3/rpcs3qt/settings_dialog.cpp                      |  3 +++
 rpcs3/rpcs3qt/settings_dialog.ui                       |  7 +++++++
 rpcs3/rpcs3qt/tooltips.h                               |  1 +
 9 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
index 65a3b4263d..d9efa0522a 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
@@ -229,6 +229,7 @@ namespace rsx
 			add_checkbox(&g_cfg.misc.show_pressure_intensity_toggle_hint, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_PRESSURE_INTENSITY_TOGGLE_HINT);
 			add_checkbox(&g_cfg.misc.show_analog_limiter_toggle_hint, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_ANALOG_LIMITER_TOGGLE_HINT);
 			add_checkbox(&g_cfg.misc.show_mouse_and_keyboard_toggle_hint, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_MOUSE_AND_KB_TOGGLE_HINT);
+			add_checkbox(&g_cfg.misc.show_fatal_error_hints, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_FATAL_ERROR_HINTS);
 			add_checkbox(&g_cfg.video.record_with_overlays, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_RECORD_WITH_OVERLAYS);
 
 			apply_layout();
diff --git a/rpcs3/Emu/localized_string_id.h b/rpcs3/Emu/localized_string_id.h
index 0bcf1caf8b..0a2e654d4e 100644
--- a/rpcs3/Emu/localized_string_id.h
+++ b/rpcs3/Emu/localized_string_id.h
@@ -254,6 +254,7 @@ enum class localized_string_id
 	HOME_MENU_SETTINGS_OVERLAYS_SHOW_PRESSURE_INTENSITY_TOGGLE_HINT,
 	HOME_MENU_SETTINGS_OVERLAYS_SHOW_ANALOG_LIMITER_TOGGLE_HINT,
 	HOME_MENU_SETTINGS_OVERLAYS_SHOW_MOUSE_AND_KB_TOGGLE_HINT,
+	HOME_MENU_SETTINGS_OVERLAYS_SHOW_FATAL_ERROR_HINTS,
 	HOME_MENU_SETTINGS_OVERLAYS_RECORD_WITH_OVERLAYS,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE,
diff --git a/rpcs3/Emu/system_config.h b/rpcs3/Emu/system_config.h
index 099e0243a1..85b84d6b85 100644
--- a/rpcs3/Emu/system_config.h
+++ b/rpcs3/Emu/system_config.h
@@ -357,6 +357,7 @@ struct cfg_root : cfg::node
 		cfg::_bool show_pressure_intensity_toggle_hint{ this, "Show pressure intensity toggle hint", true, true };
 		cfg::_bool show_analog_limiter_toggle_hint{ this, "Show analog limiter toggle hint", true, true };
 		cfg::_bool show_mouse_and_keyboard_toggle_hint{ this, "Show mouse and keyboard toggle hint", true, true };
+		cfg::_bool show_fatal_error_hints{ this, "Show fatal error hints", false, true };
 		cfg::_bool show_capture_hints{ this, "Show capture hints", true, true };
 		cfg::_bool use_native_interface{ this, "Use native user interface", true };
 		cfg::string gdb_server{ this, "GDB Server", "127.0.0.1:2345" };
diff --git a/rpcs3/rpcs3.cpp b/rpcs3/rpcs3.cpp
index 921394e311..011dfbe39f 100644
--- a/rpcs3/rpcs3.cpp
+++ b/rpcs3/rpcs3.cpp
@@ -68,6 +68,7 @@ DYNAMIC_IMPORT("ntdll.dll", NtSetTimerResolution, NTSTATUS(ULONG DesiredResoluti
 #include "util/media_utils.h"
 #include "rpcs3_version.h"
 #include "Emu/System.h"
+#include "Emu/system_config.h"
 #include "Emu/system_utils.hpp"
 #include "Emu/RSX/Overlays/overlay_message.h"
 #include <thread>
@@ -353,11 +354,14 @@ public:
 #endif
 			if (msg == logs::level::fatal)
 			{
-				std::string overlay_msg = "Fatal error: " + _msg.substr(rpcs3_prefix.size());
-				fmt::trim_back(overlay_msg, " \t\n");
+				if (g_cfg.misc.show_fatal_error_hints)
+				{
+					std::string overlay_msg = "Fatal error: " + _msg.substr(rpcs3_prefix.size());
+					fmt::trim_back(overlay_msg, " \t\n");
+					rsx::overlays::queue_message(overlay_msg, umax);
+				}
 
 				// Pause emulation if fatal error encountered
-				rsx::overlays::queue_message(overlay_msg, umax);
 				Emu.Pause(true);
 			}
 		}
diff --git a/rpcs3/rpcs3qt/emu_settings_type.h b/rpcs3/rpcs3qt/emu_settings_type.h
index 9b9f8a9279..3748aae000 100644
--- a/rpcs3/rpcs3qt/emu_settings_type.h
+++ b/rpcs3/rpcs3qt/emu_settings_type.h
@@ -189,6 +189,7 @@ enum class emu_settings_type
 	ShowPressureIntensityToggleHint,
 	ShowAnalogLimiterToggleHint,
 	ShowMouseAndKeyboardToggleHint,
+	ShowFatalErrorHints,
 	ShowCaptureHints,
 	WindowTitleFormat,
 	PauseDuringHomeMenu,
@@ -405,6 +406,7 @@ inline static const std::map<emu_settings_type, cfg_location> settings_location
 	{ emu_settings_type::ShowPressureIntensityToggleHint, { "Miscellaneous", "Show pressure intensity toggle hint"}},
 	{ emu_settings_type::ShowAnalogLimiterToggleHint,     { "Miscellaneous", "Show analog limiter toggle hint"}},
 	{ emu_settings_type::ShowMouseAndKeyboardToggleHint,  { "Miscellaneous", "Show mouse and keyboard toggle hint"}},
+	{ emu_settings_type::ShowFatalErrorHints,             { "Miscellaneous", "Show fatal error hints"}},
 	{ emu_settings_type::ShowCaptureHints,                { "Miscellaneous", "Show capture hints" }},
 	{ emu_settings_type::SilenceAllLogs,                  { "Miscellaneous", "Silence All Logs" }},
 	{ emu_settings_type::WindowTitleFormat,               { "Miscellaneous", "Window Title Format" }},
diff --git a/rpcs3/rpcs3qt/localized_emu.h b/rpcs3/rpcs3qt/localized_emu.h
index fe0451b44c..d4de0bf282 100644
--- a/rpcs3/rpcs3qt/localized_emu.h
+++ b/rpcs3/rpcs3qt/localized_emu.h
@@ -274,6 +274,7 @@ private:
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_PRESSURE_INTENSITY_TOGGLE_HINT: return tr("Show Pressure Intensity Toggle Hint", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_ANALOG_LIMITER_TOGGLE_HINT: return tr( "Show Analog Limiter Toggle Hint", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_MOUSE_AND_KB_TOGGLE_HINT: return tr("Show Mouse And Keyboard Toggle Hint", "Overlays");
+		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_FATAL_ERROR_HINTS: return tr("Show Fatal Error Hints", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_RECORD_WITH_OVERLAYS: return tr("Record With Overlays", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY: return tr("Performance Overlay");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE: return tr("Enable Performance Overlay", "Performance Overlay");
diff --git a/rpcs3/rpcs3qt/settings_dialog.cpp b/rpcs3/rpcs3qt/settings_dialog.cpp
index f4fcee4985..7bf4f02662 100644
--- a/rpcs3/rpcs3qt/settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/settings_dialog.cpp
@@ -1847,6 +1847,9 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	m_emu_settings->EnhanceCheckBox(ui->showMouseAndKeyboardToggleHint, emu_settings_type::ShowMouseAndKeyboardToggleHint);
 	SubscribeTooltip(ui->showMouseAndKeyboardToggleHint, tooltips.settings.show_mouse_and_keyboard_toggle_hint);
 
+	m_emu_settings->EnhanceCheckBox(ui->showFatalErrorHints, emu_settings_type::ShowFatalErrorHints);
+	SubscribeTooltip(ui->showFatalErrorHints, tooltips.settings.show_fatal_error_hints);
+
 	m_emu_settings->EnhanceCheckBox(ui->showCaptureHints, emu_settings_type::ShowCaptureHints);
 	SubscribeTooltip(ui->showCaptureHints, tooltips.settings.show_capture_hints);
 
diff --git a/rpcs3/rpcs3qt/settings_dialog.ui b/rpcs3/rpcs3qt/settings_dialog.ui
index 282826fcd6..a5bcc011b7 100644
--- a/rpcs3/rpcs3qt/settings_dialog.ui
+++ b/rpcs3/rpcs3qt/settings_dialog.ui
@@ -3037,6 +3037,13 @@
                  </property>
                 </widget>
                </item>
+               <item>
+                <widget class="QCheckBox" name="showFatalErrorHints">
+                 <property name="text">
+                  <string>Show fatal error hints</string>
+                 </property>
+                </widget>
+               </item>
                <item>
                 <widget class="QCheckBox" name="showMouseAndKeyboardToggleHint">
                  <property name="text">
diff --git a/rpcs3/rpcs3qt/tooltips.h b/rpcs3/rpcs3qt/tooltips.h
index 0276ac0f82..f09642a826 100644
--- a/rpcs3/rpcs3qt/tooltips.h
+++ b/rpcs3/rpcs3qt/tooltips.h
@@ -154,6 +154,7 @@ public:
 		const QString show_pressure_intensity_toggle_hint = tr("Shows pressure intensity toggle hint using the native overlay.");
 		const QString show_analog_limiter_toggle_hint = tr("Shows analog limiter toggle hint using the native overlay.");
 		const QString show_mouse_and_keyboard_toggle_hint = tr("Shows mouse and keyboard toggle hint using the native overlay.");
+		const QString show_fatal_error_hints       = tr("Shows fatal error hints using the native overlay.");
 		const QString show_capture_hints           = tr("Shows screenshot and recording hints using the native overlay.");
 		const QString use_native_interface         = tr("Enables use of native HUD within the game window that can interact with game controllers.\nWhen disabled, regular Qt dialogs are used instead.\nCurrently, the on-screen keyboard only supports the English key layout.");
 		const QString record_with_overlays         = tr("Enables recording with overlays.\nThis also affects screenshots.");

From 7c9261a4615de0cc45363cb44915ed34ef081a63 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Mon, 30 Mar 2026 15:57:17 +0200
Subject: [PATCH 73/98] overlays: add toggle for boot sequence music

---
 .../RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp   | 1 +
 rpcs3/Emu/RSX/RSXThread.cpp                                | 7 +++++--
 rpcs3/Emu/localized_string_id.h                            | 1 +
 rpcs3/Emu/system_config.h                                  | 1 +
 rpcs3/rpcs3qt/emu_settings_type.h                          | 2 ++
 rpcs3/rpcs3qt/localized_emu.h                              | 1 +
 rpcs3/rpcs3qt/settings_dialog.cpp                          | 3 +++
 rpcs3/rpcs3qt/settings_dialog.ui                           | 7 +++++++
 rpcs3/rpcs3qt/tooltips.h                                   | 1 +
 9 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
index d9efa0522a..9147b7e5c5 100644
--- a/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
+++ b/rpcs3/Emu/RSX/Overlays/HomeMenu/overlay_home_menu_settings.cpp
@@ -221,6 +221,7 @@ namespace rsx
 		home_menu_settings_overlays::home_menu_settings_overlays(s16 x, s16 y, u16 width, u16 height, bool use_separators, home_menu_page* parent)
 			: home_menu_settings_page(x, y, width, height, use_separators, parent, get_localized_string(localized_string_id::HOME_MENU_SETTINGS_OVERLAYS))
 		{
+			add_checkbox(&g_cfg.misc.play_music_during_boot, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_PLAY_MUSIC_DURING_BOOT);
 			add_checkbox(&g_cfg.misc.show_trophy_popups, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_TROPHY_POPUPS);
 			add_checkbox(&g_cfg.misc.show_rpcn_popups, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_RPCN_POPUPS);
 			add_checkbox(&g_cfg.misc.show_shader_compilation_hint, localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_SHADER_COMPILATION_HINT);
diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp
index 3392b9693b..a7338cbf56 100644
--- a/rpcs3/Emu/RSX/RSXThread.cpp
+++ b/rpcs3/Emu/RSX/RSXThread.cpp
@@ -712,9 +712,12 @@ namespace rsx
 		{
 			m_overlay_manager = g_fxo->init<rsx::overlays::display_manager>(0);
 
-			if (const std::string audio_path = Emu.GetSfoDir(true) + "/SND0.AT3"; fs::is_file(audio_path))
+			if (g_cfg.misc.play_music_during_boot)
 			{
-				m_overlay_manager->start_audio(audio_path);
+				if (const std::string audio_path = Emu.GetSfoDir(true) + "/SND0.AT3"; fs::is_file(audio_path))
+				{
+					m_overlay_manager->start_audio(audio_path);
+				}
 			}
 		}
 
diff --git a/rpcs3/Emu/localized_string_id.h b/rpcs3/Emu/localized_string_id.h
index 0a2e654d4e..c411f6e480 100644
--- a/rpcs3/Emu/localized_string_id.h
+++ b/rpcs3/Emu/localized_string_id.h
@@ -256,6 +256,7 @@ enum class localized_string_id
 	HOME_MENU_SETTINGS_OVERLAYS_SHOW_MOUSE_AND_KB_TOGGLE_HINT,
 	HOME_MENU_SETTINGS_OVERLAYS_SHOW_FATAL_ERROR_HINTS,
 	HOME_MENU_SETTINGS_OVERLAYS_RECORD_WITH_OVERLAYS,
+	HOME_MENU_SETTINGS_OVERLAYS_PLAY_MUSIC_DURING_BOOT,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE,
 	HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE_FRAMERATE_GRAPH,
diff --git a/rpcs3/Emu/system_config.h b/rpcs3/Emu/system_config.h
index 85b84d6b85..9dbaa0c723 100644
--- a/rpcs3/Emu/system_config.h
+++ b/rpcs3/Emu/system_config.h
@@ -364,6 +364,7 @@ struct cfg_root : cfg::node
 		cfg::_bool silence_all_logs{ this, "Silence All Logs", false, true };
 		cfg::string title_format{ this, "Window Title Format", "FPS: %F | %R | %V | %T [%t]", true };
 		cfg::_bool pause_during_home_menu{this, "Pause Emulation During Home Menu", false, false };
+		cfg::_bool play_music_during_boot{this, "Play music during boot sequence", true, true };
 		cfg::_bool enable_gamemode{ this, "Enable GameMode", false, false };
 
 	} misc{ this };
diff --git a/rpcs3/rpcs3qt/emu_settings_type.h b/rpcs3/rpcs3qt/emu_settings_type.h
index 3748aae000..db3e3556da 100644
--- a/rpcs3/rpcs3qt/emu_settings_type.h
+++ b/rpcs3/rpcs3qt/emu_settings_type.h
@@ -193,6 +193,7 @@ enum class emu_settings_type
 	ShowCaptureHints,
 	WindowTitleFormat,
 	PauseDuringHomeMenu,
+	PlayMusicDuringBoot,
 	EnableGamemode,
 
 	// Network
@@ -411,6 +412,7 @@ inline static const std::map<emu_settings_type, cfg_location> settings_location
 	{ emu_settings_type::SilenceAllLogs,                  { "Miscellaneous", "Silence All Logs" }},
 	{ emu_settings_type::WindowTitleFormat,               { "Miscellaneous", "Window Title Format" }},
 	{ emu_settings_type::PauseDuringHomeMenu,             { "Miscellaneous", "Pause Emulation During Home Menu" }},
+	{ emu_settings_type::PlayMusicDuringBoot,             { "Miscellaneous", "Play music during boot sequence" }},
 	{ emu_settings_type::EnableGamemode,                  { "Miscellaneous", "Enable GameMode" }},
 
 	// Networking
diff --git a/rpcs3/rpcs3qt/localized_emu.h b/rpcs3/rpcs3qt/localized_emu.h
index d4de0bf282..ba4960aa73 100644
--- a/rpcs3/rpcs3qt/localized_emu.h
+++ b/rpcs3/rpcs3qt/localized_emu.h
@@ -276,6 +276,7 @@ private:
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_MOUSE_AND_KB_TOGGLE_HINT: return tr("Show Mouse And Keyboard Toggle Hint", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_SHOW_FATAL_ERROR_HINTS: return tr("Show Fatal Error Hints", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_RECORD_WITH_OVERLAYS: return tr("Record With Overlays", "Overlays");
+		case localized_string_id::HOME_MENU_SETTINGS_OVERLAYS_PLAY_MUSIC_DURING_BOOT: return tr("Play music during boot sequence.", "Overlays");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY: return tr("Performance Overlay");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE: return tr("Enable Performance Overlay", "Performance Overlay");
 		case localized_string_id::HOME_MENU_SETTINGS_PERFORMANCE_OVERLAY_ENABLE_FRAMERATE_GRAPH: return tr("Enable Framerate Graph", "Performance Overlay");
diff --git a/rpcs3/rpcs3qt/settings_dialog.cpp b/rpcs3/rpcs3qt/settings_dialog.cpp
index 7bf4f02662..7e7f115d22 100644
--- a/rpcs3/rpcs3qt/settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/settings_dialog.cpp
@@ -1829,6 +1829,9 @@ settings_dialog::settings_dialog(std::shared_ptr<gui_settings> gui_settings, std
 	ui->enableGamemode->setVisible(false);
 #endif
 
+	m_emu_settings->EnhanceCheckBox(ui->playMusicDuringBoot, emu_settings_type::PlayMusicDuringBoot);
+	SubscribeTooltip(ui->playMusicDuringBoot, tooltips.settings.play_music_during_boot);
+
 	m_emu_settings->EnhanceCheckBox(ui->showShaderCompilationHint, emu_settings_type::ShowShaderCompilationHint);
 	SubscribeTooltip(ui->showShaderCompilationHint, tooltips.settings.show_shader_compilation_hint);
 
diff --git a/rpcs3/rpcs3qt/settings_dialog.ui b/rpcs3/rpcs3qt/settings_dialog.ui
index a5bcc011b7..d3b98a2608 100644
--- a/rpcs3/rpcs3qt/settings_dialog.ui
+++ b/rpcs3/rpcs3qt/settings_dialog.ui
@@ -3009,6 +3009,13 @@
                <string>Overlay Settings</string>
               </property>
               <layout class="QVBoxLayout" name="gb_overlay_settings_layout">
+               <item>
+                <widget class="QCheckBox" name="playMusicDuringBoot">
+                 <property name="text">
+                  <string>Play music during boot sequence</string>
+                 </property>
+                </widget>
+               </item>
                <item>
                 <widget class="QCheckBox" name="recordWithOverlays">
                  <property name="text">
diff --git a/rpcs3/rpcs3qt/tooltips.h b/rpcs3/rpcs3qt/tooltips.h
index f09642a826..caccc1c47b 100644
--- a/rpcs3/rpcs3qt/tooltips.h
+++ b/rpcs3/rpcs3qt/tooltips.h
@@ -159,6 +159,7 @@ public:
 		const QString use_native_interface         = tr("Enables use of native HUD within the game window that can interact with game controllers.\nWhen disabled, regular Qt dialogs are used instead.\nCurrently, the on-screen keyboard only supports the English key layout.");
 		const QString record_with_overlays         = tr("Enables recording with overlays.\nThis also affects screenshots.");
 		const QString pause_during_home_menu       = tr("When enabled, opening the home menu will also pause emulation.\nWhile most games pause themselves while the home menu is shown, some do not.\nIn that case it can be helpful to pause the emulation whenever the home menu is open.");
+		const QString play_music_during_boot       = tr("Play music during boot sequence if available.");
 
 		const QString perf_overlay_enabled                 = tr("Enables or disables the performance overlay.");
 		const QString perf_overlay_framerate_graph_enabled = tr("Enables or disables the framerate graph.");

From 1c37f64a58583b2f80ad9bd12f928b49176b60fd Mon Sep 17 00:00:00 2001
From: kayforbe <125169722+kayforbe@users.noreply.github.com>
Date: Mon, 30 Mar 2026 20:47:52 +0300
Subject: [PATCH 74/98] Add missing <set> include for MSVC compatibility
 (#18486)

Added missing #include <set> in shortcut_utils.h to fix MSVC build
errors (C2059)
---
 rpcs3/rpcs3qt/shortcut_utils.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/rpcs3/rpcs3qt/shortcut_utils.h b/rpcs3/rpcs3qt/shortcut_utils.h
index d1ed3962e2..f41741ecdf 100644
--- a/rpcs3/rpcs3qt/shortcut_utils.h
+++ b/rpcs3/rpcs3qt/shortcut_utils.h
@@ -1,4 +1,5 @@
 #pragma once
+#include <set>
 
 struct gui_game_info;
 class iso_archive;

From 615f416af3081801a9e7973da84b9229173c41a0 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Mon, 30 Mar 2026 13:25:51 +0300
Subject: [PATCH 75/98] SPU Anlyzer: Verify bitset index

---
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 34 +++++++++++++-------------
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp   |  7 +++++-
 rpcs3/Emu/Cell/SPURecompiler.h         | 17 ++++++++++---
 3 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index b10845889b..6a9ed7e7ee 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -6087,17 +6087,17 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 			u32 ra = s_reg_max, rb = s_reg_max, rc = s_reg_max;
 
-			if (m_use_ra.test(pos / 4))
+			if (::at32(m_use_ra, pos / 4))
 			{
 				ra = op.ra;
 			}
 
-			if (m_use_rb.test(pos / 4))
+			if (::at32(m_use_rb, pos / 4))
 			{
 				rb = op.rb;
 			}
 
-			if (m_use_rc.test(pos / 4))
+			if (::at32(m_use_rc, pos / 4))
 			{
 				rc = op.rc;
 			}
@@ -6361,11 +6361,11 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					const auto& b = ::at32(m_bbs, reduced_loop->loop_pc); 
 					const auto& b2 = ::at32(m_bbs, bpc); 
 
-					if (!reduced_loop->loop_dicts.test(i))
+					if (!::at32(reduced_loop->loop_dicts, i))
 					{
-						if (b.reg_use[i] || (!b.reg_mod.test(i) && b2.reg_use[i]))
+						if (b.reg_use[i] || (!::at32(b.reg_mod, i) && b2.reg_use[i]))
 						{
-							if ((b.reg_use[i] && b.reg_mod.test(i)) || b2.reg_mod.test(i))
+							if ((b.reg_use[i] && ::at32(b.reg_mod, i)) || ::at32(b2.reg_mod, i))
 							{
 								reduced_loop->is_constant_expression = false;
 								reduced_loop->loop_writes.set(i);
@@ -6598,7 +6598,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 				for (u32 i = 0; i < reg->regs.size() && reduced_loop->active; i++)
 				{
-					if (reg->regs.test(i))
+					if (::at32(reg->regs, i))
 					{
 						if (0) if (i == op_rt || reg->modified == 0)
 						{
@@ -6644,11 +6644,11 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 						auto reg_org = reduced_loop->find_reg(i);
 						u32 reg_index = i;
 
-						if (reg_org && !cond_val_incr_before_cond && reg_org->modified == 0 && reg_org->regs.count() - 1u <= 1u && !reg_org->regs.test(i))
+						if (reg_org && !cond_val_incr_before_cond && reg_org->modified == 0 && reg_org->regs.count() - 1u <= 1u && !::at32(reg_org->regs, i))
 						{
 							for (u32 j = 0; j <= s_reg_127; j++)
 							{
-								if (reg_org->regs.test(j))
+								if (::at32(reg_org->regs, j))
 								{
 									if (const auto reg_found = reduced_loop->find_reg(j))
 									{
@@ -7040,11 +7040,11 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 						const auto& b = ::at32(m_bbs, reduced_loop->loop_pc); 
 						const auto& b2 = ::at32(m_bbs, bpc); 
 
-						if (!reduced_loop->loop_dicts.test(i))
+						if (!::at32(reduced_loop->loop_dicts, i))
 						{
-							if (b.reg_use[i] || (!b.reg_mod.test(i) && b2.reg_use[i]))
+							if (b.reg_use[i] || (!::at32(b.reg_mod, i) && b2.reg_use[i]))
 							{
-								if ((b.reg_use[i] && b.reg_mod.test(i)) || b2.reg_mod.test(i))
+								if ((b.reg_use[i] && ::at32(b.reg_mod, i)) || ::at32(b2.reg_mod, i))
 								{
 									reduced_loop->is_constant_expression = false;
 									reduced_loop->loop_writes.set(i);
@@ -8298,17 +8298,17 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 				u32 ra = s_reg_max, rb = s_reg_max, rc = s_reg_max;
 
-				if (m_use_ra.test(pos / 4))
+				if (::at32(m_use_ra, pos / 4))
 				{
 					ra = op.ra;
 				}
 
-				if (m_use_rb.test(pos / 4))
+				if (::at32(m_use_rb, pos / 4))
 				{
 					rb = op.rb;
 				}
 
-				if (m_use_rc.test(pos / 4))
+				if (::at32(m_use_rc, pos / 4))
 				{
 					rc = op.rc;
 				}
@@ -8575,7 +8575,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 			for (u32 i = 0; i < s_reg_max; i++)
 			{
-				if (pattern.loop_writes.test(i))
+				if (::at32(pattern.loop_writes, i))
 				{
 					if (regs.size() != 1)
 					{
@@ -8585,7 +8585,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					fmt::append(regs, " r%u-w", i);
 				}
 
-				if (pattern.loop_args.test(i))
+				if (::at32(pattern.loop_args, i))
 				{
 					if (regs.size() != 1)
 					{
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 948c6e8b14..b13c27e376 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -180,7 +180,7 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 
 		bool is_gpr_not_NaN_hint(u32 i) const noexcept
 		{
-			return block_wide_reg_store_elimination && bb->reg_maybe_float[i] && bb->reg_use[i] >= 3 && !bb->reg_mod[i];
+			return block_wide_reg_store_elimination && ::at32(bb->reg_maybe_float, i) && ::at32(bb->reg_use, i) >= 3 && !::at32(bb->reg_mod, i);
 		}
 	};
 
@@ -2536,6 +2536,11 @@ public:
 								condition = m_ir->CreateAnd(cond_nans, condition);
 								prev_i = umax;
 							}
+
+							if (is_last)
+							{
+								break;
+							}
 						}
 					}
 
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 1fd295f2f6..54ddcb2f1e 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -11,6 +11,17 @@
 #include <string>
 #include <deque>
 
+// std::bitset
+template <typename CT, typename T>
+	requires requires(std::remove_cvref_t<CT>& x, T&& y) { x.count(); x.test(y); x.flip(y); }
+[[nodiscard]] constexpr bool at32(CT&& container, T&& index, std::source_location src_loc = std::source_location::current())
+{
+	const usz csv = container.size();
+	if (csv <= std::forward<T>(index)) [[unlikely]]
+		fmt::raw_range_error(src_loc, format_object_simplified(index), csv);
+	return container[std::forward<T>(index)];
+}
+
 // Helper class
 class spu_cache
 {
@@ -421,7 +432,7 @@ public:
 					return true;
 				}
 
-				return regs.count() == 1 && regs.test(reg_val);
+				return regs.count() == 1 && ::at32(regs, reg_val);
 			}
 
 			bool is_loop_dictator(u32 reg_val, bool test_predictable = false, bool should_predictable = true) const
@@ -431,7 +442,7 @@ public:
 					return false;
 				}
 
-				if (regs.count() >= 1 && regs.test(reg_val))
+				if (regs.count() >= 1 && ::at32(regs, reg_val))
 				{
 					if (!test_predictable)
 					{
@@ -490,7 +501,7 @@ public:
 					return false;
 				}
 
-				if (regs.count() - (regs.test(reg_val) ? 1 : 0))
+				if (regs.count() - (::at32(regs, reg_val) ? 1 : 0))
 				{
 					return false;
 				}

From 80f972cd384a5d6304e29fad33582003f36ac9bd Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Mon, 30 Mar 2026 20:30:35 +0300
Subject: [PATCH 76/98] SPU Analyzer: Acknowledge unknown targets

---
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 6a9ed7e7ee..fd0a8c33bf 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -2957,7 +2957,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			if (g_cfg.core.spu_block_size == spu_block_size_type::safe)
 			{
 				// Stop on special instructions (TODO)
-				m_targets[pos];
+				m_targets[pos].push_back(SPU_LS_SIZE);
 				next_block();
 				break;
 			}
@@ -2978,7 +2978,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				spu_log.error("[0x%x] Invalid interrupt flags (DE)", pos);
 			}
 
-			m_targets[pos];
+			m_targets[pos].push_back(SPU_LS_SIZE);
 			next_block();
 			break;
 		}
@@ -3278,7 +3278,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			{
 				if (type == spu_itype::BI || g_cfg.core.spu_block_size == spu_block_size_type::safe || is_no_return)
 				{
-					m_targets[pos];
+					m_targets[pos].push_back(SPU_LS_SIZE);
 				}
 				else
 				{
@@ -3291,6 +3291,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			else
 			{
 				m_targets[pos].push_back(pos + 4);
+				m_targets[pos].push_back(SPU_LS_SIZE);
 				add_block(pos + 4);
 			}
 

From 83bfbc1399217e35b17ad797d6a119fe56442b82 Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Sun, 29 Mar 2026 20:38:27 +0300
Subject: [PATCH 77/98] rsx/fp: Fix lane mask computation for varying registers

---
 rpcs3/Emu/RSX/Program/Assembler/FPOpcodes.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Program/Assembler/FPOpcodes.cpp b/rpcs3/Emu/RSX/Program/Assembler/FPOpcodes.cpp
index d00a104e8f..2ec3e2e384 100644
--- a/rpcs3/Emu/RSX/Program/Assembler/FPOpcodes.cpp
+++ b/rpcs3/Emu/RSX/Program/Assembler/FPOpcodes.cpp
@@ -343,7 +343,8 @@ namespace rsx::assembler::FP
 		std::unordered_set<u32> inputs;
 		SRC_Common src { .HEX = instruction->bytecode[operand + 1] };
 
-		if (src.reg_type != RSX_FP_REGISTER_TYPE_TEMP)
+		if (src.reg_type != RSX_FP_REGISTER_TYPE_TEMP &&
+			src.reg_type != RSX_FP_REGISTER_TYPE_INPUT)
 		{
 			return 0;
 		}

From 122ccca50e3508905aff79200e5ada12308275eb Mon Sep 17 00:00:00 2001
From: kd-11 <karokidii@gmail.com>
Date: Tue, 31 Mar 2026 00:13:25 +0300
Subject: [PATCH 78/98] rsx: Propagate texture flags when MSAA sampling is
 required

---
 rpcs3/Emu/RSX/Program/GLSLCommon.cpp                         | 5 +++++
 .../Program/GLSLSnippets/RSXProg/RSXFragmentTextureOps.glsl  | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/Program/GLSLCommon.cpp b/rpcs3/Emu/RSX/Program/GLSLCommon.cpp
index 28cbaa61f0..febb5c93bd 100644
--- a/rpcs3/Emu/RSX/Program/GLSLCommon.cpp
+++ b/rpcs3/Emu/RSX/Program/GLSLCommon.cpp
@@ -418,6 +418,11 @@ namespace glsl
 				enabled_options.push_back("_ENABLE_DEPTH_FORMAT_RECONSTRUCTION");
 			}
 
+			if (props.require_msaa_ops)
+			{
+				enabled_options.push_back("_ENABLE_TEXTURE_MULTISAMPLE");
+			}
+
 			program_common::define_glsl_switches(OS, enabled_options);
 			enabled_options.clear();
 
diff --git a/rpcs3/Emu/RSX/Program/GLSLSnippets/RSXProg/RSXFragmentTextureOps.glsl b/rpcs3/Emu/RSX/Program/GLSLSnippets/RSXProg/RSXFragmentTextureOps.glsl
index aaf4dc434a..19f3ff3f9c 100644
--- a/rpcs3/Emu/RSX/Program/GLSLSnippets/RSXProg/RSXFragmentTextureOps.glsl
+++ b/rpcs3/Emu/RSX/Program/GLSLSnippets/RSXProg/RSXFragmentTextureOps.glsl
@@ -46,7 +46,7 @@ R"(
 			_texture_bx2_active = false; \
 		} while (false)
 	#define TEX_FLAGS(index) ((TEX_PARAM(index).flags & ~(_texture_flag_erase)) | _texture_flag_override)
-#elif defined(_ENABLE_TEXTURE_ALPHA_KILL) || defined(_ENABLE_FORMAT_CONVERSION) || defined(_ENABLE_DEPTH_FORMAT_RECONSTRUCTION)
+#elif defined(_ENABLE_TEXTURE_ALPHA_KILL) || defined(_ENABLE_FORMAT_CONVERSION) || defined(_ENABLE_DEPTH_FORMAT_RECONSTRUCTION) || defined(_ENABLE_TEXTURE_MULTISAMPLE)
 	#define TEX_FLAGS(index) (TEX_PARAM(index).flags)
 #else
 	#define TEX_FLAGS(index) 0

From bd95c728f0c964849a01769d3d7785e9f87face0 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Mon, 30 Mar 2026 23:04:44 +0300
Subject: [PATCH 79/98] sys_fs: Implement ENOTDIR

---
 Utilities/File.cpp            |   2 +
 Utilities/File.h              |   1 +
 rpcs3/Emu/Cell/lv2/sys_fs.cpp | 156 +++++++++++++++++++++++++++++++---
 rpcs3/Loader/ISO.cpp          |   6 +-
 4 files changed, 150 insertions(+), 15 deletions(-)

diff --git a/Utilities/File.cpp b/Utilities/File.cpp
index 490605c792..aff4537dea 100644
--- a/Utilities/File.cpp
+++ b/Utilities/File.cpp
@@ -166,6 +166,7 @@ static fs::error to_error(int e)
 	case ENOTEMPTY: return fs::error::notempty;
 	case EROFS: return fs::error::readonly;
 	case EISDIR: return fs::error::isdir;
+	case ENOTDIR: return fs::error::notdir;
 	case ENOSPC: return fs::error::nospace;
 	case EXDEV: return fs::error::xdev;
 	default: return fs::error::unknown;
@@ -2833,6 +2834,7 @@ void fmt_class_string<fs::error>::format(std::string& out, u64 arg)
 		case fs::error::notempty: return "Not empty";
 		case fs::error::readonly: return "Read only";
 		case fs::error::isdir: return "Is a directory";
+		case fs::error::notdir: return "Not a directory";
 		case fs::error::toolong: return "Path too long";
 		case fs::error::nospace: return "Not enough space on the device";
 		case fs::error::xdev: return "Device mismatch";
diff --git a/Utilities/File.h b/Utilities/File.h
index dd2db42a46..3d332dd0be 100644
--- a/Utilities/File.h
+++ b/Utilities/File.h
@@ -683,6 +683,7 @@ namespace fs
 		notempty,
 		readonly,
 		isdir,
+		notdir,
 		toolong,
 		nospace,
 		xdev,
diff --git a/rpcs3/Emu/Cell/lv2/sys_fs.cpp b/rpcs3/Emu/Cell/lv2/sys_fs.cpp
index beec0fc4e4..2534f6a8c1 100644
--- a/rpcs3/Emu/Cell/lv2/sys_fs.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_fs.cpp
@@ -140,6 +140,32 @@ bool verify_mself(const fs::file& mself_file)
 	return true;
 }
 
+// TODO: May not be thread-safe (or even, process-safe)
+bool has_non_directory_components(std::string_view path)
+{
+	std::string path0{path};
+
+	while (true)
+	{
+		const std::string sub_path = fs::get_parent_dir(path0);
+
+		if (sub_path.size() >= path0.size())
+		{
+			break;
+		}
+
+		fs::stat_t stat{};
+		if (fs::get_stat(sub_path, stat))
+		{
+			return !stat.is_directory;
+		}
+
+		path0 = std::move(sub_path);
+	}
+
+	return false;
+}
+
 lv2_fs_mount_info_map::lv2_fs_mount_info_map()
 {
 	for (auto mp = &g_mp_sys_dev_root; mp; mp = mp->next) // Scan and keep track of pre-mounted devices
@@ -899,8 +925,17 @@ lv2_file::open_raw_result_t lv2_file::open_raw(const std::string& local_path, s3
 
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir: return {CELL_ENOTDIR};
 		case fs::error::noent: return {CELL_ENOENT};
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return {CELL_ENOTDIR};
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -1372,6 +1407,11 @@ error_code sys_fs_opendir(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<u32> fd)
 		}
 		default:
 		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
 			fmt::throw_exception("unknown error %s", error);
 		}
 		}
@@ -1555,6 +1595,10 @@ error_code sys_fs_stat(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<CellFsStat>
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir:
+		{
+			return { CELL_ENOTDIR, path};
+		}
 		case fs::error::noent:
 		{
 			// Try to analyse split file (TODO)
@@ -1594,6 +1638,11 @@ error_code sys_fs_stat(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<CellFsStat>
 		}
 		default:
 		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
 			fmt::throw_exception("unknown error %s", error);
 		}
 		}
@@ -1720,6 +1769,10 @@ error_code sys_fs_mkdir(ppu_thread& ppu, vm::cptr<char> path, s32 mode)
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir:
+		{
+			return { CELL_ENOTDIR, path};
+		}
 		case fs::error::noent:
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
@@ -1728,7 +1781,15 @@ error_code sys_fs_mkdir(ppu_thread& ppu, vm::cptr<char> path, s32 mode)
 		{
 			return {sys_fs.warning, CELL_EEXIST, path};
 		}
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -1789,9 +1850,18 @@ error_code sys_fs_rename(ppu_thread& ppu, vm::cptr<char> from, vm::cptr<char> to
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir: return {CELL_ENOTDIR, from};
 		case fs::error::noent: return {CELL_ENOENT, from};
 		case fs::error::exist: return {CELL_EEXIST, to};
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_from))
+			{
+				return {CELL_ENOTDIR, from};
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -1842,9 +1912,18 @@ error_code sys_fs_rmdir(ppu_thread& ppu, vm::cptr<char> path)
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir: return {CELL_ENOTDIR, path};
 		case fs::error::noent: return {CELL_ENOENT, path};
 		case fs::error::notempty: return {CELL_ENOTEMPTY, path};
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -1896,11 +1975,23 @@ error_code sys_fs_unlink(ppu_thread& ppu, vm::cptr<char> path)
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir:
+		{
+			return { CELL_ENOTDIR, path };
+		}
 		case fs::error::noent:
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
 		}
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -2737,7 +2828,15 @@ error_code sys_fs_get_block_size(ppu_thread& ppu, vm::cptr<char> path, vm::ptr<u
 		{
 		case fs::error::exist: return {CELL_EISDIR, path};
 		case fs::error::noent: return {CELL_ENOENT, path};
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -2789,11 +2888,23 @@ error_code sys_fs_truncate(ppu_thread& ppu, vm::cptr<char> path, u64 size)
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir:
+		{
+			return { CELL_ENOTDIR, path};
+		}
 		case fs::error::noent:
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
 		}
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -2840,7 +2951,10 @@ error_code sys_fs_ftruncate(ppu_thread& ppu, u32 fd, u64 size)
 		switch (auto error = fs::g_tls_error)
 		{
 		case fs::error::ok:
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
@@ -2887,6 +3001,10 @@ error_code sys_fs_chmod(ppu_thread&, vm::cptr<char> path, s32 mode)
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir:
+		{
+			return { CELL_ENOTDIR, path};
+		}
 		case fs::error::noent:
 		{
 			// Try to locate split files
@@ -2900,8 +3018,12 @@ error_code sys_fs_chmod(ppu_thread&, vm::cptr<char> path, s32 mode)
 		}
 		default:
 		{
-			sys_fs.error("sys_fs_chmod(): unknown error %s", error);
-			return {CELL_EIO, path};
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
 		}
 		}
 	}
@@ -3033,11 +3155,23 @@ error_code sys_fs_utime(ppu_thread& ppu, vm::cptr<char> path, vm::cptr<CellFsUti
 	{
 		switch (auto error = fs::g_tls_error)
 		{
+		case fs::error::notdir:
+		{
+			return { CELL_ENOTDIR, path};
+		}
 		case fs::error::noent:
 		{
 			return {mp == &g_mp_sys_dev_hdd1 ? sys_fs.warning : sys_fs.error, CELL_ENOENT, path};
 		}
-		default: fmt::throw_exception("unknown error %s", error);
+		default:
+		{
+			if (has_non_directory_components(local_path))
+			{
+				return { CELL_ENOTDIR, path };
+			}
+
+			fmt::throw_exception("unknown error %s", error);
+		}
 		}
 	}
 
diff --git a/rpcs3/Loader/ISO.cpp b/rpcs3/Loader/ISO.cpp
index a80d664174..0ddc3e39d9 100644
--- a/rpcs3/Loader/ISO.cpp
+++ b/rpcs3/Loader/ISO.cpp
@@ -585,10 +585,8 @@ std::unique_ptr<fs::dir_base> iso_device::open_dir(const std::string& path)
 
 	if (!node->metadata.is_directory)
 	{
-		// fs::dir::open -> ::readdir should return ENOTDIR when path is
-		// pointing to a file instead of a folder, which translates to error::unknown.
-		// doing the same here.
-		fs::g_tls_error = fs::error::unknown;
+		// fs::dir::open -> ::readdir should return ENOTDIR when path is pointing to a file instead of a folder.
+		fs::g_tls_error = fs::error::notdir;
 		return nullptr;
 	}
 

From ac104a519e80a0960f3b6ce0441aa96c77cabcd2 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Tue, 31 Mar 2026 06:35:34 +0300
Subject: [PATCH 80/98] SPU Analyzer: More fix

---
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 41 +++++++++++++++++---------
 1 file changed, 27 insertions(+), 14 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index fd0a8c33bf..4e8c044113 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -3011,7 +3011,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 			bool is_no_return = false;
 
-			if (pos_next >= lsa && pos_next < limit)
+			if (sl && pos_next >= lsa && pos_next < limit)
 			{
 				const u32 data_next = ls[pos_next / 4];
 				const auto type_next = g_spu_itype.decode(data_next);
@@ -3274,11 +3274,17 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				spu_log.notice("[0x%x] At 0x%x: ignoring indirect branch (SYNC)", entry_point, pos);
 			}
 
+			if (!(af & vf::is_const))
+			{
+				// Possible unknown target
+				m_targets[pos].emplace_back(SPU_LS_SIZE);
+			}
+
 			if (type == spu_itype::BI || sl || is_no_return)
 			{
 				if (type == spu_itype::BI || g_cfg.core.spu_block_size == spu_block_size_type::safe || is_no_return)
 				{
-					m_targets[pos].push_back(SPU_LS_SIZE);
+					m_targets[pos];
 				}
 				else
 				{
@@ -3291,7 +3297,6 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			else
 			{
 				m_targets[pos].push_back(pos + 4);
-				m_targets[pos].push_back(SPU_LS_SIZE);
 				add_block(pos + 4);
 			}
 
@@ -3884,6 +3889,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 			it->second.emplace_back(SPU_LS_SIZE);
 		}
 
+		std::sort(it->second.begin(), it->second.end());
 		it++;
 	}
 
@@ -6313,10 +6319,6 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		case spu_itype::BI:
 		case spu_itype::BISL:
 		case spu_itype::BISLED:
-		case spu_itype::BIZ:
-		case spu_itype::BINZ:
-		case spu_itype::BIHZ:
-		case spu_itype::BIHNZ:
 		{
 			if (op.e || op.d)
 			{
@@ -6417,12 +6419,23 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 		}
 		case spu_itype::BRHZ:
 		case spu_itype::BRHNZ:
-		{
-			const u32 next_pc = spu_branch_target(pos, 1);
-			const u32 target = spu_branch_target(pos, op.i16);
 
-			const bool is_u16_jump = type == spu_itype::BRHZ || type == spu_itype::BRHNZ;
-			const bool is_jump_zero = (type == spu_itype::BRZ || type == spu_itype::BRHZ) ^ reduced_loop->is_two_block_loop;
+		case spu_itype::BIZ:
+		case spu_itype::BINZ:
+		case spu_itype::BIHZ:
+		case spu_itype::BIHNZ:
+		{
+			if (type == spu_itype::spu_itype::BIZ || type == spu_itype::BINZ || type == spu_itype::BIHZ || type == spu_itype::BIHNZ)
+			{
+				if (op.e || op.d)
+				{
+					break_all_patterns(27);
+					break;
+				}
+			}
+
+			const bool is_u16_jump = type == spu_itype::BRHZ || type == spu_itype::BRHNZ || type == spu_itype::BIHZ || type == spu_itype::BIHNZ;
+			const bool is_jump_zero = (type == spu_itype::BRZ || type == spu_itype::BRHZ || type == spu_itype::BIZ || type == spu_itype::BIHZ) ^ reduced_loop->is_two_block_loop;
 
 			while (reduced_loop->active)
 			{
@@ -6729,8 +6742,8 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 						{
 							reduced_loop->cond_val_incr_is_immediate = false;
 
-							const u32 op_ra = spu_opcode_t{reg->IMM}.ra;
-							const u32 op_rb = spu_opcode_t{reg->IMM}.rb;
+							const u32 op_ra = spu_opcode_t{reg_org->IMM}.ra;
+							const u32 op_rb = spu_opcode_t{reg_org->IMM}.rb;
 
 							if (!(op_ra == reg_index || op_rb == reg_index))
 							{

From f63b1b5dc1b8704278ba896ad536b8a2c3ed77bb Mon Sep 17 00:00:00 2001
From: BehroozRezvani <brezvani@outlook.com>
Date: Tue, 31 Mar 2026 20:31:29 +0100
Subject: [PATCH 81/98] Fixes PS button wrong input path check

---
 rpcs3/Emu/Io/GameTablet.cpp         | 6 +++---
 rpcs3/Emu/RSX/Overlays/overlays.cpp | 8 ++++----
 rpcs3/Input/gui_pad_thread.cpp      | 6 +++---
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/rpcs3/Emu/Io/GameTablet.cpp b/rpcs3/Emu/Io/GameTablet.cpp
index 4c2330d908..1d0fcf24fe 100644
--- a/rpcs3/Emu/Io/GameTablet.cpp
+++ b/rpcs3/Emu/Io/GameTablet.cpp
@@ -229,6 +229,9 @@ void usb_device_gametablet::interrupt_transfer(u32 buf_size, u8* buf, u32 /*endp
 					case CELL_PAD_CTRL_LEFT:
 						left = true;
 						break;
+					case CELL_PAD_CTRL_PS:
+						gt.btn_ps |= 1;
+						break;
 					default:
 						break;
 					}
@@ -249,9 +252,6 @@ void usb_device_gametablet::interrupt_transfer(u32 buf_size, u8* buf, u32 /*endp
 					case CELL_PAD_CTRL_TRIANGLE:
 						gt.btn_triangle |= 1;
 						break;
-					case CELL_PAD_CTRL_PS:
-						gt.btn_ps |= 1;
-						break;
 					default:
 						break;
 					}
diff --git a/rpcs3/Emu/RSX/Overlays/overlays.cpp b/rpcs3/Emu/RSX/Overlays/overlays.cpp
index f44647daa0..954c8cf0fe 100644
--- a/rpcs3/Emu/RSX/Overlays/overlays.cpp
+++ b/rpcs3/Emu/RSX/Overlays/overlays.cpp
@@ -289,6 +289,7 @@ namespace rsx
 							handle_button_press(pad_button::R3,         !!(digital1 & CELL_PAD_CTRL_R3),       pad_index);
 							handle_button_press(pad_button::select,     !!(digital1 & CELL_PAD_CTRL_SELECT),   pad_index);
 							handle_button_press(pad_button::start,      !!(digital1 & CELL_PAD_CTRL_START),    pad_index);
+							handle_button_press(pad_button::ps,         !!(digital1 & CELL_PAD_CTRL_PS),       pad_index);
 						}
 
 						//if (pad->ldd_data.len > CELL_PAD_BTN_OFFSET_DIGITAL2)
@@ -303,7 +304,6 @@ namespace rsx
 							handle_button_press(pad_button::R1,         !!(digital2 & CELL_PAD_CTRL_R1),       pad_index);
 							handle_button_press(pad_button::L2,         !!(digital2 & CELL_PAD_CTRL_L2),       pad_index);
 							handle_button_press(pad_button::R2,         !!(digital2 & CELL_PAD_CTRL_R2),       pad_index);
-							handle_button_press(pad_button::ps,         !!(digital2 & CELL_PAD_CTRL_PS),       pad_index);
 						}
 
 						const auto handle_ldd_stick_input = [&](s32 offset, pad_button id_small, pad_button id_large)
@@ -372,6 +372,9 @@ namespace rsx
 							case CELL_PAD_CTRL_START:
 								button_id = pad_button::start;
 								break;
+							case CELL_PAD_CTRL_PS:
+								button_id = pad_button::ps;
+								break;
 							default:
 								break;
 							}
@@ -404,9 +407,6 @@ namespace rsx
 							case CELL_PAD_CTRL_R2:
 								button_id = pad_button::R2;
 								break;
-							case CELL_PAD_CTRL_PS:
-								button_id = pad_button::ps;
-								break;
 							default:
 								break;
 							}
diff --git a/rpcs3/Input/gui_pad_thread.cpp b/rpcs3/Input/gui_pad_thread.cpp
index e467c9ae0a..2df53f6f32 100644
--- a/rpcs3/Input/gui_pad_thread.cpp
+++ b/rpcs3/Input/gui_pad_thread.cpp
@@ -507,6 +507,9 @@ void gui_pad_thread::process_input()
 			case CELL_PAD_CTRL_START:
 				button_id = pad_button::start;
 				break;
+			case CELL_PAD_CTRL_PS:
+				button_id = pad_button::ps;
+				break;
 			default:
 				break;
 			}
@@ -539,9 +542,6 @@ void gui_pad_thread::process_input()
 			case CELL_PAD_CTRL_R2:
 				button_id = pad_button::R2;
 				break;
-			case CELL_PAD_CTRL_PS:
-				button_id = pad_button::ps;
-				break;
 			default:
 				break;
 			}

From a03a78dbd2ec96a9a6349cc52755234419e7bd24 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Wed, 1 Apr 2026 09:27:51 +0300
Subject: [PATCH 82/98] SPU: Verify SPU Reduced loop completability

---
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp |  7 +++++++
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp   | 19 +++++++++++++++++--
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 4e8c044113..d5791c30dd 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -6731,6 +6731,13 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 							break;
 						}
 
+						if (reg_index != i && ::at32(reg->regs, reg_index))
+						{
+							// Unimplemented
+							break_reduced_loop_pattern(30, reduced_loop->discard());
+							break;
+						}
+
 						u32 cond_val_incr = static_cast<s32>(reg_org->IMM);
 
 						if (reg_org->mod1_type == spu_itype::AI || reg_org->mod1_type == spu_itype::AHI)
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index b13c27e376..9880c167e8 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -2542,9 +2542,24 @@ public:
 								break;
 							}
 						}
-					}
 
-					//condition = m_ir->getInt1(0);
+						// TODO: Optimze so constant evalatuated cases will not be checked
+						const bool is_cond_need_runtime_verify = compare == ICmpInst::ICMP_NE && (!m_reduced_loop_info->cond_val_is_immediate || m_reduced_loop_info->cond_val_incr % 2 == 0);
+
+						if (is_cond_need_runtime_verify)
+						{
+							// Verify that it is actually possible to finish the loop and it is not an infinite loop
+
+							// First: create a mask of the bits that definitely do not change between iterations (0 results in umax which is accurate here)
+							const auto no_change_bits = m_ir->CreateAnd(m_ir->CreateNot(cond_val_incr), m_ir->CreateSub(cond_val_incr, m_ir->getIntN(type_bits, 1)));
+
+							// Compare that when the mask applied to both the result and the original value is the same
+							const auto cond_verify = m_ir->CreateICmpEQ(m_ir->CreateAnd(loop_dictator_after_adjustment, no_change_bits), m_ir->CreateAnd(loop_argument, no_change_bits));
+
+							// Amend condition
+							condition = m_ir->CreateAnd(cond_verify, condition);
+						}
+					}
 
 					m_ir->CreateCondBr(condition, optimization_block, block_optimization_next);
 				};

From 555ace09556cba51cb3af96f4cf900cda0a155ae Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Wed, 1 Apr 2026 10:15:29 +0300
Subject: [PATCH 83/98] rsx: Silence Unknown render mode error

---
 rpcs3/Emu/RSX/NV47/HW/nv4097.cpp | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/RSX/NV47/HW/nv4097.cpp b/rpcs3/Emu/RSX/NV47/HW/nv4097.cpp
index 43c8a5d9f4..3cc40efed1 100644
--- a/rpcs3/Emu/RSX/NV47/HW/nv4097.cpp
+++ b/rpcs3/Emu/RSX/NV47/HW/nv4097.cpp
@@ -633,9 +633,17 @@ namespace rsx
 			case 2:
 				break;
 			default:
-				rsx_log.error("Unknown render mode %d", mode);
+			{
+				struct logged_t
+				{
+					atomic_t<u8> logged_cause[256]{};
+				};
+
+				const auto& is_error = ::at32(g_fxo->get<logged_t>().logged_cause, mode).try_inc(10);
+				(is_error ? rsx_log.error : rsx_log.trace)("Unknown render mode %d", mode);
 				return;
 			}
+			}
 
 			const u32 offset = arg & 0xffffff;
 			auto address_ptr = util::get_report_data_impl(ctx, offset);

From ff4444b18edeb78e1fdb016fcb73f6b3edd357c6 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Wed, 1 Apr 2026 17:35:56 +0300
Subject: [PATCH 84/98] Silence cellNetCtlGetInfo

---
 rpcs3/Emu/Cell/Modules/cellNetCtl.cpp | 41 ++++++++++++++++++++++++++-
 1 file changed, 40 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellNetCtl.cpp b/rpcs3/Emu/Cell/Modules/cellNetCtl.cpp
index 97375c4e6d..83b001cc52 100644
--- a/rpcs3/Emu/Cell/Modules/cellNetCtl.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellNetCtl.cpp
@@ -192,7 +192,46 @@ error_code cellNetCtlDelHandler(s32 hid)
 
 error_code cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 {
-	cellNetCtl.warning("cellNetCtlGetInfo(code=0x%x (%s), info=*0x%x)", code, InfoCodeToName(code), info);
+	bool log_it_once = false;
+
+	switch (code)
+	{
+	case CELL_NET_CTL_INFO_ETHER_ADDR:
+	case CELL_NET_CTL_INFO_DEVICE:
+	case CELL_NET_CTL_INFO_MTU:
+	case CELL_NET_CTL_INFO_LINK_TYPE:
+	case CELL_NET_CTL_INFO_IP_CONFIG:
+	case CELL_NET_CTL_INFO_IP_ADDRESS:
+	case CELL_NET_CTL_INFO_NETMASK:
+	case CELL_NET_CTL_INFO_DEFAULT_ROUTE:
+	case CELL_NET_CTL_INFO_HTTP_PROXY_CONFIG:
+	case CELL_NET_CTL_INFO_UPNP_CONFIG:
+	{
+		log_it_once = true;
+		break;
+	}
+	default:
+	{
+		break;
+	}
+	}
+
+	bool log_it = true;
+
+	if (log_it_once && vm::check_addr(info.addr()))
+	{
+		struct logged_t
+		{
+			std::array<atomic_t<bool>, 256> logged_code{};
+		};
+
+		if (g_fxo->get<logged_t>().logged_code[::narrow<u8>(code)].exchange(true))
+		{
+			log_it = false;
+		}
+	}
+
+	(log_it ? cellNetCtl.warning : cellNetCtl.trace)("cellNetCtlGetInfo(code=0x%x (%s), info=*0x%x)", code, InfoCodeToName(code), info);
 
 	auto& nph = g_fxo->get<named_thread<np::np_handler>>();
 

From 13de8233b08df42c4126bd79bd0e023647b0c690 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Thu, 2 Apr 2026 21:00:25 +0300
Subject: [PATCH 85/98] SPU Analyzer: Fix register origin for Reduced Loop

---
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 8 +++++++-
 rpcs3/Emu/Cell/SPURecompiler.h         | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index d5791c30dd..1b7c37dc51 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -6194,7 +6194,7 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				{
 					const auto arg = reduced_loop->find_reg(reg);
 
-					if (arg && reg != op_rt)
+					if (arg && arg->regs.count() != 0)
 					{
 						if (reg_first == reg)
 						{
@@ -6217,6 +6217,12 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 				}
 			}
 
+			if (type & spu_itype::memory || type == spu_itype::RDCH || type == spu_itype::RCHCNT)
+			{
+				// Register external origin
+				org.add_register_origin(s_reg_max);
+			}
+
 			*ensure(reduced_loop->find_reg(op_rt)) = org;
 		}
 
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 54ddcb2f1e..13a868448a 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -364,7 +364,7 @@ public:
 
 		struct origin_t
 		{
-			std::bitset<s_reg_max> regs{};
+			std::bitset<s_reg_max + 1> regs{};
 			u32 modified = 0;
 			spu_itype_t mod1_type = spu_itype::UNK;
 			spu_itype_t mod2_type = spu_itype::UNK;

From 02eb5492088564cb5f4ba01f422b40bb1978ab36 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Thu, 2 Apr 2026 21:32:58 +0300
Subject: [PATCH 86/98]  SPU LLVM: Fix register updates in second block of
 Reduced Loop

---
 rpcs3/Emu/Cell/SPUCommonRecompiler.cpp | 112 ++++++++++++++++++-----
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp   | 121 ++++++++++++++++---------
 rpcs3/Emu/Cell/SPURecompiler.h         |   7 ++
 3 files changed, 173 insertions(+), 67 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
index 1b7c37dc51..53dc0df200 100644
--- a/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPUCommonRecompiler.cpp
@@ -6365,26 +6365,55 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 					}
 				}
 
+				std::array<u32, s_reg_max> reg_use{};
+				std::bitset<s_reg_max> reg_maybe_float{};
+				std::bitset<s_reg_max> reg_mod{};
+
+				for (auto it = m_bbs.find(reduced_loop->loop_pc); it != m_bbs.end() && it->first <= bpc; it++)
+				{
+					for (u32 i = 0; i < s_reg_max; i++)
+					{
+						if (!reg_mod[i])
+						{
+							reg_use[i] += it->second.reg_use[i];
+						}
+					}
+
+					reg_maybe_float |= it->second.reg_maybe_float;
+					reg_mod |= it->second.reg_mod;
+
+					// Note: update when sup_conds are implemented
+					if (it->first == bpc && it->first != reduced_loop->loop_pc)
+					{
+						reduced_loop->loop_may_update |= it->second.reg_mod;
+					}
+				}
+
 				for (u32 i = 0; i < s_reg_max; i++)
 				{
-					const auto& b = ::at32(m_bbs, reduced_loop->loop_pc); 
-					const auto& b2 = ::at32(m_bbs, bpc); 
-
 					if (!::at32(reduced_loop->loop_dicts, i))
 					{
-						if (b.reg_use[i] || (!::at32(b.reg_mod, i) && b2.reg_use[i]))
+						if (reg_use[i] && reg_mod[i])
 						{
-							if ((b.reg_use[i] && ::at32(b.reg_mod, i)) || ::at32(b2.reg_mod, i))
+							reduced_loop->is_constant_expression = false;
+							reduced_loop->loop_writes.set(i);
+							reduced_loop->loop_may_update.reset(i);
+						}
+						else if (reg_use[i])
+						{
+							reduced_loop->loop_args.set(i);
+
+							if (reg_use[i] >= 3 && reg_maybe_float[i])
 							{
-								reduced_loop->is_constant_expression = false;
-								reduced_loop->loop_writes.set(i);
-							}
-							else
-							{
-								reduced_loop->loop_args.set(i);
+								reduced_loop->gpr_not_nans.set(i);
 							}
 						}
 					}
+					else
+					{
+						// Cleanup
+						reduced_loop->loop_may_update.reset(i);
+					}
 				}
 
 				reduced_loop_all.emplace(reduced_loop->loop_pc, *reduced_loop);
@@ -7062,26 +7091,55 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 						}
 					}
 
+					std::array<u32, s_reg_max> reg_use{};
+					std::bitset<s_reg_max> reg_maybe_float{};
+					std::bitset<s_reg_max> reg_mod{};
+
+					for (auto it = m_bbs.find(reduced_loop->loop_pc); it != m_bbs.end() && it->first <= bpc; it++)
+					{
+						for (u32 i = 0; i < s_reg_max; i++)
+						{
+							if (!reg_mod[i])
+							{
+								reg_use[i] += it->second.reg_use[i];
+							}
+						}
+
+						reg_maybe_float |= it->second.reg_maybe_float;
+						reg_mod |= it->second.reg_mod;
+
+						// Note: update when sup_conds are implemented
+						if (it->first == bpc && it->first != reduced_loop->loop_pc)
+						{
+							reduced_loop->loop_may_update |= it->second.reg_mod;
+						}
+					}
+
 					for (u32 i = 0; i < s_reg_max; i++)
 					{
-						const auto& b = ::at32(m_bbs, reduced_loop->loop_pc); 
-						const auto& b2 = ::at32(m_bbs, bpc); 
-
 						if (!::at32(reduced_loop->loop_dicts, i))
 						{
-							if (b.reg_use[i] || (!::at32(b.reg_mod, i) && b2.reg_use[i]))
+							if (reg_use[i] && reg_mod[i])
 							{
-								if ((b.reg_use[i] && ::at32(b.reg_mod, i)) || ::at32(b2.reg_mod, i))
+								reduced_loop->is_constant_expression = false;
+								reduced_loop->loop_writes.set(i);
+								reduced_loop->loop_may_update.reset(i);
+							}
+							else if (reg_use[i])
+							{
+								reduced_loop->loop_args.set(i);
+
+								if (reg_use[i] >= 3 && reg_maybe_float[i])
 								{
-									reduced_loop->is_constant_expression = false;
-									reduced_loop->loop_writes.set(i);
-								}
-								else
-								{
-									reduced_loop->loop_args.set(i);
+									reduced_loop->gpr_not_nans.set(i);
 								}
 							}
 						}
+						else
+						{
+							// Cleanup
+							reduced_loop->loop_may_update.reset(i);
+						}
 					}
 
 					reduced_loop_all.emplace(reduced_loop->loop_pc, *reduced_loop);
@@ -8621,6 +8679,16 @@ spu_program spu_recompiler_base::analyse(const be_t<u32>* ls, u32 entry_point, s
 
 					fmt::append(regs, " r%u-r", i);
 				}
+
+				if (::at32(pattern.loop_may_update, i))
+				{
+					if (regs.size() != 1)
+					{
+						regs += ",";
+					}
+
+					fmt::append(regs, " r%u-m", i);
+				}
 			}
 
 			regs += " }";
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 9880c167e8..c47a25d9f0 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -60,6 +60,7 @@ const extern spu_decoder<spu_iflag> g_spu_iflag;
 #pragma GCC diagnostic pop
 #endif
 
+#pragma optimize("", off)
 #ifdef ARCH_ARM64
 #include "Emu/CPU/Backends/AArch64/AArch64JIT.h"
 #endif
@@ -152,6 +153,9 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 		// Current register values
 		std::array<llvm::Value*, s_reg_max> reg{};
 
+		// Opimization: restoring register state for registers that would be rewritten in other blocks
+		std::array<llvm::Value*, s_reg_max> reg_save_and_restore{};
+
 		// PHI nodes created for this block (if any)
 		std::array<llvm::PHINode*, s_reg_max> phi{};
 
@@ -177,11 +181,6 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 			const usz first_id = store_context_first_id[i];
 			return counter != 1 && first_id != umax && counter < first_id;
 		}
-
-		bool is_gpr_not_NaN_hint(u32 i) const noexcept
-		{
-			return block_wide_reg_store_elimination && ::at32(bb->reg_maybe_float, i) && ::at32(bb->reg_use, i) >= 3 && !::at32(bb->reg_mod, i);
-		}
 	};
 
 	struct function_info
@@ -197,10 +196,13 @@ class spu_llvm_recompiler : public spu_recompiler_base, public cpu_translator
 	};
 
 	// Current block
-	block_info* m_block;
+	block_info* m_block = nullptr;
 
 	// Current function or chunk
-	function_info* m_finfo;
+	function_info* m_finfo = nullptr;
+
+	// Reduced Loop Pattern information (if available)
+	reduced_loop_t* m_reduced_loop_info = nullptr;
 
 	// All blocks in the current function chunk
 	std::unordered_map<u32, block_info, value_hash<u32, 2>> m_blocks;
@@ -2280,7 +2282,7 @@ public:
 				}
 
 				const bool is_reduced_loop = m_inst_attrs[(baddr - start) / 4] == inst_attr::reduced_loop;
-				const auto reduced_loop_info = is_reduced_loop ? std::static_pointer_cast<reduced_loop_t>(ensure(m_patterns.at(baddr - start).info_ptr)) : nullptr;
+				m_reduced_loop_info = is_reduced_loop ? std::static_pointer_cast<reduced_loop_t>(ensure(m_patterns.at(baddr - start).info_ptr)).get() : nullptr;
 
 				BasicBlock* block_optimization_phi_parent =  nullptr;
 				const auto block_optimization_inner = is_reduced_loop ? BasicBlock::Create(m_context, fmt::format("b-loop-it-0x%x", m_pos), m_function) : nullptr;
@@ -2290,11 +2292,24 @@ public:
 				std::array<llvm::PHINode*, s_reg_max> reduced_loop_phi_nodes{};
 				std::array<llvm::Value*, s_reg_max> reduced_loop_init_regs{};
 
-				auto make_reduced_loop_condition = [&](llvm::BasicBlock* optimization_block, bool is_second_time, u32 reserve_iterations)
+				// Reserve additional iteration for rare case where GPR may not be rewritten after the iteration
+				// So that it would have to be rewritten by future code
+				// This avoids using additional PHI connectors
+				const u32 reserve_iterations = m_reduced_loop_info && m_reduced_loop_info->loop_may_update.count() != 0 ? 3 : 2;
+
+				for (u32 i = 0; i < s_reg_max; i++)
+				{
+					if (m_reduced_loop_info && m_reduced_loop_info->loop_may_update.test(i))
+					{
+						m_block->reg_save_and_restore[i] = m_block->reg[i];
+					}
+				}
+
+				auto make_reduced_loop_condition = [&](llvm::BasicBlock* optimization_block, bool is_second_time)
 				{
 					llvm::ICmpInst::Predicate compare{};
 
-					switch (reduced_loop_info->cond_val_compare)
+					switch (m_reduced_loop_info->cond_val_compare)
 					{
 					case CMP_SLESS:  compare = ICmpInst::ICMP_SLT; break;
 					case CMP_SGREATER: compare = ICmpInst::ICMP_SGT; break;
@@ -2323,11 +2338,11 @@ public:
 					llvm::Value* loop_dictator_after_adjustment{};
 
 					spu_opcode_t reg_target{};
-					reg_target.rt = static_cast<u32>(reduced_loop_info->cond_val_register_idx);
+					reg_target.rt = static_cast<u32>(m_reduced_loop_info->cond_val_register_idx);
 
-					if (reg_target.rt != reduced_loop_info->cond_val_register_idx)
+					if (reg_target.rt != m_reduced_loop_info->cond_val_register_idx)
 					{
-						fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition register index: 0x%llx", reduced_loop_info->cond_val_register_idx);
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition register index: 0x%llx", m_reduced_loop_info->cond_val_register_idx);
 					}
 
 					if (!m_block->reg[reg_target.rt])
@@ -2335,7 +2350,7 @@ public:
 						m_block->reg[reg_target.rt] = reduced_loop_init_regs[reg_target.rt];
 					}
 
-					switch (reduced_loop_info->cond_val_mask)
+					switch (m_reduced_loop_info->cond_val_mask)
 					{
 					case u8{umax}:
 					{
@@ -2360,28 +2375,28 @@ public:
 					}
 					default:
 					{
-						fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition bit mask: 0x%llx", reduced_loop_info->cond_val_mask);
+						fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition bit mask: 0x%llx", m_reduced_loop_info->cond_val_mask);
 					}
 					}
 
-					const u32 type_bits = std::popcount(reduced_loop_info->cond_val_mask);
+					const u32 type_bits = std::popcount(m_reduced_loop_info->cond_val_mask);
 
 					llvm::Value* cond_val_incr = nullptr;
 
-					if (reduced_loop_info->cond_val_incr_is_immediate)
+					if (m_reduced_loop_info->cond_val_incr_is_immediate)
 					{
-						cond_val_incr = m_ir->getIntN(type_bits, reduced_loop_info->cond_val_incr & reduced_loop_info->cond_val_mask);
+						cond_val_incr = m_ir->getIntN(type_bits, m_reduced_loop_info->cond_val_incr & m_reduced_loop_info->cond_val_mask);
 					}
 					else
 					{
 						spu_opcode_t reg_incr{};
-						reg_incr.rt = static_cast<u32>(reduced_loop_info->cond_val_incr);
+						reg_incr.rt = static_cast<u32>(m_reduced_loop_info->cond_val_incr);
 
-						if (reg_incr.rt != reduced_loop_info->cond_val_incr)
+						if (reg_incr.rt != m_reduced_loop_info->cond_val_incr)
 						{
-							fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal increment arguemnt register index: 0x%llx", reduced_loop_info->cond_val_incr);
+							fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal increment arguemnt register index: 0x%llx", m_reduced_loop_info->cond_val_incr);
 						}
-						switch (reduced_loop_info->cond_val_mask)
+						switch (m_reduced_loop_info->cond_val_mask)
 						{
 						case u8{umax}:
 						{
@@ -2407,7 +2422,7 @@ public:
 						}
 					}
 
-					if (reduced_loop_info->cond_val_incr_before_cond && !reduced_loop_info->cond_val_incr_before_cond_taken_in_account)
+					if (m_reduced_loop_info->cond_val_incr_before_cond && !m_reduced_loop_info->cond_val_incr_before_cond_taken_in_account)
 					{
 						loop_dictator_after_adjustment = m_ir->CreateAdd(loop_dictator_before_adjustment, cond_val_incr);
 					}
@@ -2418,21 +2433,21 @@ public:
 
 					llvm::Value* loop_argument = nullptr;
 
-					if (reduced_loop_info->cond_val_is_immediate)
+					if (m_reduced_loop_info->cond_val_is_immediate)
 					{
-						loop_argument = m_ir->CreateTrunc(m_ir->getInt64(reduced_loop_info->cond_val_min & reduced_loop_info->cond_val_mask), loop_dictator_before_adjustment->getType());
+						loop_argument = m_ir->CreateTrunc(m_ir->getInt64(m_reduced_loop_info->cond_val_min & m_reduced_loop_info->cond_val_mask), loop_dictator_before_adjustment->getType());
 					}
 					else
 					{
 						spu_opcode_t reg_target2{};
-						reg_target2.rt = static_cast<u32>(reduced_loop_info->cond_val_register_argument_idx);
+						reg_target2.rt = static_cast<u32>(m_reduced_loop_info->cond_val_register_argument_idx);
 
-						if (reg_target2.rt != reduced_loop_info->cond_val_register_argument_idx)
+						if (reg_target2.rt != m_reduced_loop_info->cond_val_register_argument_idx)
 						{
-							fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition arguemnt register index: 0x%llx", reduced_loop_info->cond_val_register_argument_idx);
+							fmt::throw_exception("LLVM: Reduced Loop Pattern: Illegal condition arguemnt register index: 0x%llx", m_reduced_loop_info->cond_val_register_argument_idx);
 						}
 
-						switch (reduced_loop_info->cond_val_mask)
+						switch (m_reduced_loop_info->cond_val_mask)
 						{
 						case u8{umax}:
 						{
@@ -2464,7 +2479,7 @@ public:
 					{
 						condition = m_ir->CreateICmp(compare, loop_dictator_after_adjustment, loop_argument);
 					}
-					// else if ((reduced_loop_info->cond_val_compare == CMP_LGREATER || (reduced_loop_info->cond_val_compare == CMP_LGREATER_EQUAL && reduced_loop_info->cond_val_is_immediate && reduced_loop_info->cond_val_incr)) && cond_val_incr->getSExtValue() < 0)
+					// else if ((m_reduced_loop_info->cond_val_compare == CMP_LGREATER || (m_reduced_loop_info->cond_val_compare == CMP_LGREATER_EQUAL && m_reduced_loop_info->cond_val_is_immediate && m_reduced_loop_info->cond_val_incr)) && cond_val_incr->getSExtValue() < 0)
 					// {
 					// 	const auto cond_val_incr_multiplied = m_ir->CreateMul(cond_val_incr, reserve_iterations - 1);
 					// 	condition = m_ir->CreateICmp(compare, select(m_ir->CreateICmpUGE(cond_val_incr_multiplied, loop_dictator_after_adjustment), m_ir->CreateAdd(loop_dictator_after_adjustment, cond_val_incr_multiplied), m_ir->getIntN(type_bits, 0)), loop_argument);
@@ -2493,7 +2508,7 @@ public:
 						{
 							const bool is_last = !(count <= 20 && i < s_reg_max);
 
-							if (is_last || m_block->is_gpr_not_NaN_hint(i))
+							if (is_last || m_reduced_loop_info->is_gpr_not_NaN_hint(i))
 							{
 								count++;
 
@@ -2570,7 +2585,7 @@ public:
 					{
 						llvm::Type* type = g_cfg.core.spu_xfloat_accuracy == xfloat_accuracy::accurate && bb.reg_maybe_xf[i] ? get_type<f64[4]>() : get_reg_type(i);
 
-						if (i < reduced_loop_info->loop_dicts.size() && (reduced_loop_info->loop_dicts.test(i) || reduced_loop_info->loop_writes.test(i)))
+						if (i < m_reduced_loop_info->loop_dicts.size() && (m_reduced_loop_info->loop_dicts.test(i) || m_reduced_loop_info->loop_writes.test(i)))
 						{
 							// Connect registers which are used and then modified by the block
 							auto value = m_block->reg[i];
@@ -2582,7 +2597,7 @@ public:
 
 							reduced_loop_init_regs[i] = value;
 						}
-						else if (i < reduced_loop_info->loop_dicts.size() && reduced_loop_info->loop_args.test(i))
+						else if (i < m_reduced_loop_info->loop_dicts.size() && m_reduced_loop_info->loop_args.test(i))
 						{
 							// Load registers used as arguments of the loop
 							if (!m_block->reg[i])
@@ -2595,8 +2610,8 @@ public:
 					const auto prev_insert_block = m_ir->GetInsertBlock();
 
 					block_optimization_phi_parent = prev_insert_block;
-	
-					make_reduced_loop_condition(block_optimization_inner, false, 2);
+
+					make_reduced_loop_condition(block_optimization_inner, false);
 					m_ir->SetInsertPoint(block_optimization_inner);
 
 					for (u32 i = 0; i < s_reg_max; i++)
@@ -2626,7 +2641,7 @@ public:
 
 				for (u32 iteration_emit = 0; is_reduced_loop; m_pos += 4)
 				{
-					if (m_pos != baddr && m_block_info[m_pos / 4] && reduced_loop_info->loop_end < m_pos)
+					if (m_pos != baddr && m_block_info[m_pos / 4] && m_reduced_loop_info->loop_end < m_pos)
 					{
 						fmt::throw_exception("LLVM: Reduced Loop Pattern: Exit(1) too early at 0x%x", m_pos);
 					}
@@ -2682,8 +2697,8 @@ public:
 							}
 						}
 
-						ensure(!!m_block->reg[reduced_loop_info->cond_val_register_idx]);
-						make_reduced_loop_condition(block_optimization_inner, true, 2);
+						ensure(!!m_block->reg[m_reduced_loop_info->cond_val_register_idx]);
+						make_reduced_loop_condition(block_optimization_inner, true);
 						m_ir->SetInsertPoint(block_optimization_next);
 						m_block->block_wide_reg_store_elimination = false;
 
@@ -2778,6 +2793,22 @@ public:
 					}
 				}
 
+				for (u32 i = 0; i < s_reg_max; i++)
+				{
+					if (m_reduced_loop_info && m_reduced_loop_info->loop_may_update.test(i))
+					{
+						m_block->reg[i] = m_block->reg_save_and_restore[i];
+
+						if (m_block->reg[i])
+						{
+							m_block->reg[i] = m_ir->CreateAdd(bitcast(m_block->reg[i], get_type<u32[4]>()), splat<u32[4]>(1).eval(m_ir));
+							m_block->reg[i] = m_ir->CreateAdd(bitcast(m_block->reg[i], get_type<u32[4]>()), splat<u32[4]>(0 - 1).eval(m_ir));
+						}
+					}
+				}
+
+				m_reduced_loop_info = nullptr;
+
 				// Emit instructions
 				for (m_pos = baddr; m_pos >= start && m_pos < end && !m_ir->GetInsertBlock()->getTerminator(); m_pos += 4)
 				{
@@ -6993,7 +7024,7 @@ public:
 
 	value_t<f32[4]> clamp_smax(value_t<f32[4]> v, u32 gpr = s_reg_max)
 	{
-		if (m_block && gpr < s_reg_max && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(gpr))
+		if (m_reduced_loop_info && gpr < s_reg_max && m_reduced_loop_info->is_gpr_not_NaN_hint(gpr))
 		{
 			return v;
 		}
@@ -7144,12 +7175,12 @@ public:
 				}
 			}
 
-			if (m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.ra))
+			if (m_reduced_loop_info && m_reduced_loop_info->is_gpr_not_NaN_hint(op.ra))
 			{
 				safe_finite_compare.set(0);
 			}
 
-			if (m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.rb))
+			if (m_reduced_loop_info && m_reduced_loop_info->is_gpr_not_NaN_hint(op.rb))
 			{
 				safe_finite_compare.set(1);
 			}
@@ -7343,8 +7374,8 @@ public:
 			}
 		});
 
-		const u32 a_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.ra) ? 1 : 0;
-		const u32 b_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.rb) ? 1 : 0;
+		const u32 a_notnan = m_reduced_loop_info && m_reduced_loop_info->is_gpr_not_NaN_hint(op.ra) ? 1 : 0;
+		const u32 b_notnan = m_reduced_loop_info && m_reduced_loop_info->is_gpr_not_NaN_hint(op.rb) ? 1 : 0;
 
 		if (op.ra == op.rb && !m_interp_magn)
 		{
@@ -7780,8 +7811,8 @@ public:
 		const auto [a, b, c] = get_vrs<f32[4]>(op.ra, op.rb, op.rc);
 		static const auto MT = match<f32[4]>();
 
-		const u32 a_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.ra) ? 1 : 0;
-		const u32 b_notnan = m_block && m_block->block_wide_reg_store_elimination && m_block->is_gpr_not_NaN_hint(op.rb) ? 1 : 0;
+		const u32 a_notnan = m_reduced_loop_info && m_reduced_loop_info->is_gpr_not_NaN_hint(op.ra) ? 1 : 0;
+		const u32 b_notnan = m_reduced_loop_info && m_reduced_loop_info->is_gpr_not_NaN_hint(op.rb) ? 1 : 0;
 
 		auto check_sqrt_pattern_for_float = [&](f32 float_value) -> bool
 		{
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 13a868448a..6c629571d9 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -361,6 +361,8 @@ public:
 		std::bitset<s_reg_max> loop_args;
 		std::bitset<s_reg_max> loop_dicts;
 		std::bitset<s_reg_max> loop_writes;
+		std::bitset<s_reg_max> loop_may_update;
+		std::bitset<s_reg_max> gpr_not_nans;
 
 		struct origin_t
 		{
@@ -680,6 +682,11 @@ public:
 			return true;
 		}
 
+		bool is_gpr_not_NaN_hint(u32 i) const noexcept
+		{
+			return ::at32(gpr_not_nans, i);
+		}
+
 		origin_t get_reg(u32 reg_val) noexcept
 		{
 			const auto org = find_reg(reg_val);

From ceb2168375da5f4f65608568a59403129e40389e Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Fri, 3 Apr 2026 23:17:05 +0300
Subject: [PATCH 87/98] SPU LLVM: Remove debug code

---
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index c47a25d9f0..85d391aceb 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -2798,12 +2798,6 @@ public:
 					if (m_reduced_loop_info && m_reduced_loop_info->loop_may_update.test(i))
 					{
 						m_block->reg[i] = m_block->reg_save_and_restore[i];
-
-						if (m_block->reg[i])
-						{
-							m_block->reg[i] = m_ir->CreateAdd(bitcast(m_block->reg[i], get_type<u32[4]>()), splat<u32[4]>(1).eval(m_ir));
-							m_block->reg[i] = m_ir->CreateAdd(bitcast(m_block->reg[i], get_type<u32[4]>()), splat<u32[4]>(0 - 1).eval(m_ir));
-						}
 					}
 				}
 

From aa841ac332195a58d58c556d7de182b5f7fce3e4 Mon Sep 17 00:00:00 2001
From: Elad <18193363+elad335@users.noreply.github.com>
Date: Fri, 3 Apr 2026 23:23:00 +0300
Subject: [PATCH 88/98] LLVM: Add source location for bitcast error

---
 Utilities/JIT.h                 | 4 ++++
 rpcs3/Emu/CPU/CPUTranslator.cpp | 4 ++--
 rpcs3/Emu/CPU/CPUTranslator.h   | 3 ++-
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/Utilities/JIT.h b/Utilities/JIT.h
index 6dfa9e7cd0..86fc72ed55 100644
--- a/Utilities/JIT.h
+++ b/Utilities/JIT.h
@@ -493,6 +493,10 @@ inline FT build_function_asm(std::string_view name, F&& builder, ::jit_runtime*
 	return reinterpret_cast<FT>(uptr(result));
 }
 
+#if defined(__INTELLISENSE__) && !defined(LLVM_AVAILABLE)
+#define LLVM_AVAILABLE
+#endif
+
 #ifdef LLVM_AVAILABLE
 
 namespace llvm
diff --git a/rpcs3/Emu/CPU/CPUTranslator.cpp b/rpcs3/Emu/CPU/CPUTranslator.cpp
index 22413f62b8..6bd7924ea5 100644
--- a/rpcs3/Emu/CPU/CPUTranslator.cpp
+++ b/rpcs3/Emu/CPU/CPUTranslator.cpp
@@ -210,7 +210,7 @@ void cpu_translator::initialize(llvm::LLVMContext& context, llvm::ExecutionEngin
 #endif
 }
 
-llvm::Value* cpu_translator::bitcast(llvm::Value* val, llvm::Type* type) const
+llvm::Value* cpu_translator::bitcast(llvm::Value* val, llvm::Type* type, std::source_location src_loc) const
 {
 	uint s1 = type->getScalarSizeInBits();
 	uint s2 = val->getType()->getScalarSizeInBits();
@@ -222,7 +222,7 @@ llvm::Value* cpu_translator::bitcast(llvm::Value* val, llvm::Type* type) const
 
 	if (s1 != s2)
 	{
-		fmt::throw_exception("cpu_translator::bitcast(): incompatible type sizes (%u vs %u)", s1, s2);
+		fmt::throw_exception("cpu_translator::bitcast(): incompatible type sizes (%u vs %u)\nCalled from: %s", s1, s2, src_loc);
 	}
 
 	if (val->getType() == type)
diff --git a/rpcs3/Emu/CPU/CPUTranslator.h b/rpcs3/Emu/CPU/CPUTranslator.h
index 738932808d..ab2aed8156 100644
--- a/rpcs3/Emu/CPU/CPUTranslator.h
+++ b/rpcs3/Emu/CPU/CPUTranslator.h
@@ -43,6 +43,7 @@
 
 #include <functional>
 #include <unordered_map>
+#include <source_location>
 
 // Helper function
 llvm::Value* peek_through_bitcasts(llvm::Value*);
@@ -3239,7 +3240,7 @@ public:
 	}
 
 	// Bitcast with immediate constant folding
-	llvm::Value* bitcast(llvm::Value* val, llvm::Type* type) const;
+	llvm::Value* bitcast(llvm::Value* val, llvm::Type* type, std::source_location src_loc = std::source_location::current()) const;
 
 	template <typename T>
 	llvm::Value* bitcast(llvm::Value* val)

From 110ef818b3fbeb50b09f851c9aa80e2fa280a873 Mon Sep 17 00:00:00 2001
From: oltolm <oleg.tolmatcev@gmail.com>
Date: Sat, 4 Apr 2026 13:57:50 +0200
Subject: [PATCH 89/98] PPU LLVM: fix compilation for PPU Debug option

---
 rpcs3/Emu/Cell/PPUTranslator.cpp     | 10 +++++-----
 rpcs3/Emu/Cell/SPULLVMRecompiler.cpp |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/rpcs3/Emu/Cell/PPUTranslator.cpp b/rpcs3/Emu/Cell/PPUTranslator.cpp
index b12cd9c55d..0205715328 100644
--- a/rpcs3/Emu/Cell/PPUTranslator.cpp
+++ b/rpcs3/Emu/Cell/PPUTranslator.cpp
@@ -340,7 +340,7 @@ Function* PPUTranslator::GetSymbolResolver(const ppu_module<lv2_obj>& info)
 
 	const auto ftype = FunctionType::get(get_type<void>(), {
 		get_type<u8*>(), // Exec base
-		m_ir->getPtrTy(), // PPU context
+		get_type<u8*>(), // PPU context
 		get_type<u64>(), // Segment address (for PRX)
 		get_type<u8*>(), // Memory base
 		get_type<u64>(), // r0
@@ -386,7 +386,7 @@ Function* PPUTranslator::GetSymbolResolver(const ppu_module<lv2_obj>& info)
 	const auto addr_array = new GlobalVariable(*m_module, addr_array_type, false, GlobalValue::PrivateLinkage, ConstantDataArray::get(m_context, vec_addrs));
 
 	// Create an array of function pointers
-	const auto func_table_type = ArrayType::get(m_ir->getPtrTy(), functions.size());
+	const auto func_table_type = ArrayType::get(get_type<u8*>(), functions.size());
 	const auto init_func_table = ConstantArray::get(func_table_type, functions);
 	const auto func_table = new GlobalVariable(*m_module, func_table_type, false, GlobalVariable::PrivateLinkage, init_func_table);
 
@@ -413,7 +413,7 @@ Function* PPUTranslator::GetSymbolResolver(const ppu_module<lv2_obj>& info)
 	const auto func_pc = ZExt(m_ir->CreateLoad(ptr_inst->getResultElementType(), ptr_inst), get_type<u64>());
 
 	ptr_inst = dyn_cast<GetElementPtrInst>(m_ir->CreateGEP(func_table->getValueType(), func_table, {m_ir->getInt64(0), index_value}));
-	assert(ptr_inst->getResultElementType() == m_ir->getPtrTy());
+	assert(ptr_inst->getResultElementType() == get_type<u8*>());
 
 	const auto faddr = m_ir->CreateLoad(ptr_inst->getResultElementType(), ptr_inst);
 	const auto pos_32 = m_reloc ? m_ir->CreateAdd(func_pc, m_seg0) : func_pc;
@@ -622,7 +622,7 @@ void PPUTranslator::CallFunction(u64 target, Value* indirect)
 		const auto pos = m_ir->CreateShl(indirect, 1);
 		const auto ptr = m_ir->CreatePtrAdd(m_exec, pos);
 		const auto val = m_ir->CreateLoad(get_type<u64>(), ptr);
-		callee = FunctionCallee(type, m_ir->CreateIntToPtr(val, m_ir->getPtrTy()));
+		callee = FunctionCallee(type, m_ir->CreateIntToPtr(val, get_type<u8*>()));
 
 		// Load new segment address
 		const auto seg_base_ptr = m_ir->CreatePtrAdd(m_exec, m_ir->getInt64(vm::g_exec_addr_seg_offset));
@@ -5414,7 +5414,7 @@ MDNode* PPUTranslator::CheckBranchProbability(u32 bo)
 void PPUTranslator::build_interpreter()
 {
 #define BUILD_VEC_INST(i) { \
-		m_function = llvm::cast<llvm::Function>(m_module->getOrInsertFunction("op_" #i, get_type<void>(), m_ir->getPtrTy()).getCallee()); \
+		m_function = llvm::cast<llvm::Function>(m_module->getOrInsertFunction("op_" #i, get_type<void>(), get_type<u8*>()).getCallee()); \
 		std::fill(std::begin(m_globals), std::end(m_globals), nullptr); \
 		std::fill(std::begin(m_locals), std::end(m_locals), nullptr); \
 		IRBuilder<> irb(BasicBlock::Create(m_context, "__entry", m_function)); \
diff --git a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
index 85d391aceb..6837baaa97 100644
--- a/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
+++ b/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp
@@ -3586,7 +3586,7 @@ public:
 
 		// Create interpreter table
 		const auto if_type = get_ftype<void, u8*, u8*, u32, u32, u8*, u32, u8*>();
-		m_function_table = new GlobalVariable(*m_module, ArrayType::get(m_ir->getPtrTy(), 1ull << m_interp_magn), true, GlobalValue::InternalLinkage, nullptr);
+		m_function_table = new GlobalVariable(*m_module, ArrayType::get(get_type<u8*>(), 1ull << m_interp_magn), true, GlobalValue::InternalLinkage, nullptr);
 
 		init_luts();
 
@@ -3630,7 +3630,7 @@ public:
 		m_ir->CreateStore(m_ir->CreateCall(get_intrinsic<u64>(Intrinsic::read_register), {rsp_name}), native_sp);
 
 		// Decode (shift) and load function pointer
-		const auto first = m_ir->CreateLoad(m_ir->getPtrTy(), m_ir->CreateGEP(m_ir->getPtrTy(), m_interp_table, m_ir->CreateLShr(m_interp_op, 32u - m_interp_magn)));
+		const auto first = m_ir->CreateLoad(get_type<u8*>(), m_ir->CreateGEP(get_type<u8*>(), m_interp_table, m_ir->CreateLShr(m_interp_op, 32u - m_interp_magn)));
 		const auto call0 = m_ir->CreateCall(if_type, first, {m_lsptr, m_thread, m_interp_pc, m_interp_op, m_interp_table, m_interp_7f0, m_interp_regs});
 		call0->setCallingConv(CallingConv::GHC);
 		m_ir->CreateRetVoid();
@@ -3774,7 +3774,7 @@ public:
 						const auto next_pc = itype & spu_itype::branch ? m_interp_pc : m_interp_pc_next;
 						const auto be32_op = m_ir->CreateLoad(get_type<u32>(), _ptr(m_lsptr, m_ir->CreateZExt(next_pc, get_type<u64>())));
 						const auto next_op = m_ir->CreateCall(get_intrinsic<u32>(Intrinsic::bswap), {be32_op});
-						const auto next_if = m_ir->CreateLoad(m_ir->getPtrTy(), m_ir->CreateGEP(m_ir->getPtrTy(), m_interp_table, m_ir->CreateLShr(next_op, 32u - m_interp_magn)));
+						const auto next_if = m_ir->CreateLoad(get_type<u8*>(), m_ir->CreateGEP(get_type<u8*>(), m_interp_table, m_ir->CreateLShr(next_op, 32u - m_interp_magn)));
 						llvm::cast<LoadInst>(next_if)->setVolatile(true);
 
 						if (!(itype & spu_itype::branch))
@@ -3899,7 +3899,7 @@ public:
 			}
 		}
 
-		m_function_table->setInitializer(ConstantArray::get(ArrayType::get(m_ir->getPtrTy(), 1ull << m_interp_magn), iptrs));
+		m_function_table->setInitializer(ConstantArray::get(ArrayType::get(get_type<u8*>(), 1ull << m_interp_magn), iptrs));
 		m_function_table = nullptr;
 
 		for (auto& f : *_module)

From ec989781a345839423b34656beda5e7e62a98c3e Mon Sep 17 00:00:00 2001
From: Vishrut Sachan <vishrutsachan2004@gmail.com>
Date: Tue, 31 Mar 2026 10:28:03 +0530
Subject: [PATCH 90/98] game_list_table: Allow reordering game list columns

---
 rpcs3/rpcs3qt/game_list_table.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/rpcs3/rpcs3qt/game_list_table.cpp b/rpcs3/rpcs3qt/game_list_table.cpp
index 3d40467bb1..ec88561580 100644
--- a/rpcs3/rpcs3qt/game_list_table.cpp
+++ b/rpcs3/rpcs3qt/game_list_table.cpp
@@ -38,6 +38,7 @@ game_list_table::game_list_table(game_list_frame* frame, std::shared_ptr<persist
 	horizontalHeader()->setStretchLastSection(true);
 	horizontalHeader()->setDefaultSectionSize(150);
 	horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
+	horizontalHeader()->setSectionsMovable(true);
 	setContextMenuPolicy(Qt::CustomContextMenu);
 	setAlternatingRowColors(true);
 	setColumnCount(static_cast<int>(gui::game_list_columns::count));
@@ -72,6 +73,8 @@ void game_list_table::restore_layout(const QByteArray& state)
 		// Nothing to do
 	}
 
+	// Re-apply after restoreState() since it resets setSectionsMovable to false
+	horizontalHeader()->setSectionsMovable(true);
 	// Make sure no columns are squished
 	fix_narrow_columns();
 

From b22d0a0b4a1f319696f6c05a25471f2ba9230396 Mon Sep 17 00:00:00 2001
From: Sanjay Govind <sanjay.govind9@gmail.com>
Date: Sat, 4 Apr 2026 13:51:32 +1300
Subject: [PATCH 91/98] Bump SDL to 3.4.4

---
 3rdparty/libsdl-org/SDL | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3rdparty/libsdl-org/SDL b/3rdparty/libsdl-org/SDL
index 683181b47c..5848e584a1 160000
--- a/3rdparty/libsdl-org/SDL
+++ b/3rdparty/libsdl-org/SDL
@@ -1 +1 @@
-Subproject commit 683181b47cfabd293e3ea409f838915b8297a4fd
+Subproject commit 5848e584a1b606de26e3dbd1c7e4ecbc34f807a6

From afdb57bee95169653c75f1fe32dac0908e2475d4 Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 5 Apr 2026 10:12:38 +0200
Subject: [PATCH 92/98] Update FAudio to 26.04

---
 3rdparty/FAudio | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3rdparty/FAudio b/3rdparty/FAudio
index dc034fc671..0372329dbb 160000
--- a/3rdparty/FAudio
+++ b/3rdparty/FAudio
@@ -1 +1 @@
-Subproject commit dc034fc671b07bbd14e8410d5dd6be6da38fdf6d
+Subproject commit 0372329dbb56e7814d0dea7b6eafa7a613bd8042

From b8e6785789d0b13654be92de675b5d0585ff7bcd Mon Sep 17 00:00:00 2001
From: Megamouse <studienricky89@googlemail.com>
Date: Sun, 5 Apr 2026 10:23:20 +0200
Subject: [PATCH 93/98] Update soundtouch to 2.4.1

---
 3rdparty/SoundTouch/soundtouch | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3rdparty/SoundTouch/soundtouch b/3rdparty/SoundTouch/soundtouch
index 3982730833..a0fba77b6f 160000
--- a/3rdparty/SoundTouch/soundtouch
+++ b/3rdparty/SoundTouch/soundtouch
@@ -1 +1 @@
-Subproject commit 3982730833b6daefe77dcfb32b5c282851640c17
+Subproject commit a0fba77b6f9cfbdb71f8bbec58b6ac4e5e3b1097

From f42b09d1fcf9adde7a20fc621644afbc22595abd Mon Sep 17 00:00:00 2001
From: Daniel Risto <danielristo@icloud.com>
Date: Sun, 22 Mar 2026 13:15:16 +0100
Subject: [PATCH 94/98] Fix SPRX Loader segfault on Apple ARM64 by excluding
 MAP_JIT from memory mapping regions

On Apple ARM64, memory_reserve unconditionally applies MAP_JIT to all
reservations. However, regions marked as is_memory_mapping are later
replaced by file-backed MAP_FIXED mappings via shm::map/map_critical.
Overlaying a file-backed MAP_FIXED mapping onto a MAP_JIT region causes
the resulting pages to be inaccessible, leading to a segfault when the
SPRX Loader attempts to write module data into PS3 memory (g_sudo_addr).

Fix: Only apply MAP_JIT for non-mapping regions. Memory mapping regions
don't need JIT capability since they use shared memory for the PS3
address space, not executable JIT code.

Tested on Apple M3 Max, macOS 26.3.1. The SPRX Loader now successfully
loads all modules and emulation proceeds past the loading stage.
---
 rpcs3/util/vm_native.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/rpcs3/util/vm_native.cpp b/rpcs3/util/vm_native.cpp
index ed1e0060c9..5821300fc3 100644
--- a/rpcs3/util/vm_native.cpp
+++ b/rpcs3/util/vm_native.cpp
@@ -253,7 +253,11 @@ namespace utils
 
 #ifdef __APPLE__
 #ifdef ARCH_ARM64
-		auto ptr = ::mmap(use_addr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE | MAP_JIT | c_map_noreserve, -1, 0);
+		// Memory mapping regions will be replaced by file-backed MAP_FIXED mappings
+		// (via shm::map), which is incompatible with MAP_JIT. Only use MAP_JIT for
+		// non-mapping regions that need JIT executable support.
+		const int jit_flag = is_memory_mapping ? 0 : MAP_JIT;
+		auto ptr = ::mmap(use_addr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE | jit_flag | c_map_noreserve, -1, 0);
 #else
 		auto ptr = ::mmap(use_addr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE | MAP_JIT | c_map_noreserve, -1, 0);
 #endif

From 22fe8648eff001c246e339621459197684282a8a Mon Sep 17 00:00:00 2001
From: capriots <29807355+capriots@users.noreply.github.com>
Date: Sun, 8 Mar 2026 11:04:32 +0100
Subject: [PATCH 95/98] cellDmux implementation

---
 rpcs3/Emu/Cell/Modules/cellDmux.cpp | 2271 +++++++++++++--------------
 rpcs3/Emu/Cell/Modules/cellDmux.h   |  122 +-
 rpcs3/Emu/Cell/lv2/sys_prx.cpp      |    2 +-
 3 files changed, 1163 insertions(+), 1232 deletions(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellDmux.cpp b/rpcs3/Emu/Cell/Modules/cellDmux.cpp
index fb1f32837d..4f51539e8e 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmux.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmux.cpp
@@ -1,16 +1,14 @@
 #include "stdafx.h"
-#include "Emu/System.h"
-#include "Emu/IdManager.h"
-#include "Emu/Cell/PPUModule.h"
+#include "Emu/Cell/lv2/sys_mutex.h"
 #include "Emu/Cell/lv2/sys_sync.h"
+#include "Emu/Cell/lv2/sys_timer.h"
+#include "Emu/Cell/PPUModule.h"
+#include "Emu/savestate_utils.hpp"
+#include "util/asm.hpp"
 
 #include "cellPamf.h"
 #include "cellDmux.h"
 
-#include "util/asm.hpp"
-
-#include <thread>
-
 LOG_CHANNEL(cellDmux);
 
 template <>
@@ -31,1331 +29,1197 @@ void fmt_class_string<CellDmuxError>::format(std::string& out, u64 arg)
 	});
 }
 
-/* Demuxer Thread Classes */
-
-enum
+static error_code get_error(u32 internal_error)
 {
-	/* http://dvd.sourceforge.net/dvdinfo/mpeghdrs.html */
-
-	PACKET_START_CODE_MASK   = 0xffffff00,
-	PACKET_START_CODE_PREFIX = 0x00000100,
-
-	PACK_START_CODE          = 0x000001ba,
-	SYSTEM_HEADER_START_CODE = 0x000001bb,
-	PRIVATE_STREAM_1         = 0x000001bd,
-	PADDING_STREAM           = 0x000001be,
-	PRIVATE_STREAM_2         = 0x000001bf,
-};
-
-struct DemuxerStream
-{
-	u32 addr;
-	u32 size;
-	u64 userdata;
-	bool discontinuity;
-
-	template<typename T>
-	bool get(T& out)
+	switch (internal_error)
 	{
-		if (sizeof(T) > size) return false;
+	case 0: return CELL_OK;
+	case 1: return CELL_DMUX_ERROR_FATAL;
+	case 2: // Error values two to five are all converted to CELL_DMUX_ERROR_ARG.
+	case 3:
+	case 4:
+	case 5: return CELL_DMUX_ERROR_ARG;
+	default: return CELL_DMUX_ERROR_FATAL;
+	}
+}
 
-		std::memcpy(&out, vm::base(addr), sizeof(T));
-		addr += sizeof(T);
-		size -= sizeof(T);
+static inline std::span<vm::bptr<DmuxEsContext>> get_es_handles(vm::ptr<DmuxContext> handle)
+{
+	return { vm::pptr<DmuxEsContext>::make(handle.addr() + sizeof(DmuxContext)).get_ptr(), static_cast<usz>(handle->enabled_es_num) };
+}
 
-		return true;
+static inline vm::ptr<DmuxAuQueueElement> get_au_queue_elements(vm::ptr<DmuxEsContext> es_handle)
+{
+	return vm::ptr<DmuxAuQueueElement>::make(es_handle.addr() + sizeof(DmuxEsContext));
+}
+
+static inline vm::cptr<CellDmuxCoreOps> get_core_ops()
+{
+	return vm::cptr<CellDmuxCoreOps>::make(*ppu_module_manager::cellDmuxPamf.variables.find(0x28b2b7b2)->second.export_addr);
+}
+
+
+// Callbacks for cellDmuxPamf
+
+static error_code notify_demux_done(ppu_thread& ppu, vm::ptr<void> core_handle, u32 error, vm::ptr<DmuxContext> handle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
 	}
 
-	template<typename T>
-	bool peek(T& out, u32 shift = 0)
-	{
-		if (sizeof(T) + shift > size) return false;
+	cellDmux.trace("notify_demux_done(core_handle=*0x%x, error=%d, handle=*0x%x)", core_handle, error, handle);
 
-		std::memcpy(&out, vm::base(addr + shift), sizeof(T));
-		return true;
+	ensure(!!handle); // Not checked on LLE
+
+	ensure(sys_mutex_lock(ppu, handle->_dx_mhd, 0) == CELL_OK); // Failing this check on LLE would result in it dereferencing an invalid pointer.
+	handle->dmux_state = DMUX_STOPPED;
+	ensure(sys_mutex_unlock(ppu, handle->_dx_mhd) == CELL_OK); // Failing this check on LLE would result in it dereferencing an invalid pointer.
+
+	if (handle->_this)
+	{
+		const vm::var<CellDmuxMsg> msg{{ .msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE, .supplementalInfo = handle->user_data }};
+		handle->dmux_cb.cbFunc(ppu, handle, msg, handle->dmux_cb.cbArg);
 	}
 
-	void skip(u32 count)
-	{
-		addr += count;
-		size = size > count ? size - count : 0;
-	}
+	return CELL_OK;
+}
 
-	bool check(u32 count) const
-	{
-		return count <= size;
-	}
-
-	u64 get_ts(u8 c)
-	{
-		u8 v[4]; get(v);
-		return
-			((u64{c} & 0x0e) << 29) |
-			((u64{v[0]}) << 21) |
-			((u64{v[1]} & 0x7e) << 15) |
-			((u64{v[2]}) << 7) | (u64{v[3]} >> 1);
-	}
-};
-
-struct PesHeader
+static error_code notify_fatal_err(ppu_thread& ppu, vm::ptr<void> core_handle, u32 error, vm::ptr<DmuxContext> handle)
 {
-	u64 pts;
-	u64 dts;
-	u8 size;
-	bool has_ts;
-	bool is_ok;
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
 
-	PesHeader(DemuxerStream& stream);
-};
-
-class ElementaryStream;
-class Demuxer;
-
-enum DemuxerJobType
-{
-	dmuxSetStream,
-	dmuxResetStream,
-	dmuxResetStreamAndWaitDone,
-	dmuxEnableEs,
-	dmuxDisableEs,
-	dmuxResetEs,
-	dmuxFlushEs,
-	dmuxClose,
-};
-
-struct DemuxerTask
-{
-	DemuxerJobType type;
-
-	union
+	if (!savestate_lock)
 	{
-		DemuxerStream stream;
+		ppu.state += cpu_flag::again;
+		return {};
+	}
 
-		struct
+	cellDmux.error("notify_fatal_err(core_handle=*0x%x, error=%d, handle=*0x%x)", core_handle, error, handle);
+
+	ensure(!!handle); // Not checked on LLE
+
+	const vm::var<CellDmuxMsg> msg{{ .msgType = CELL_DMUX_MSG_TYPE_FATAL_ERR, .supplementalInfo = static_cast<u32>(get_error(error)) }};
+	return handle->dmux_cb.cbFunc(ppu, handle, msg, handle->dmux_cb.cbArg);
+}
+
+static error_code notify_prog_end_code(ppu_thread& ppu, vm::ptr<void> core_handle, vm::ptr<DmuxContext> handle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("notify_prog_end_code(core_handle=*0x%x, handle=*0x%x)", core_handle, handle);
+
+	ensure(!!handle); // Not checked on LLE
+
+	if (handle->_this)
+	{
+		const vm::var<CellDmuxMsg> msg{{ .msgType = CELL_DMUX_MSG_TYPE_PROG_END_CODE, .supplementalInfo = handle->user_data }};
+		handle->dmux_cb.cbFunc(ppu, handle, msg, handle->dmux_cb.cbArg);
+	}
+
+	return CELL_OK;
+}
+
+static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_handle, vm::cptr<DmuxAuInfo> au_info, vm::ptr<DmuxEsContext> es_handle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.trace("notify_es_au_found(core_es_handle=*0x%x, au_info=*0x%x, es_handle=*0x%x)", core_es_handle, au_info, es_handle);
+
+	ensure(!!au_info && !!es_handle); // Not checked on LLE
+
+	const auto fatal_err = [&](be_t<u32> es_is_enabled, error_code ret)
+	{
+		if (es_is_enabled)
 		{
-			u32 es;
-			u32 auInfo_ptr_addr;
-			u32 auSpec_ptr_addr;
-			ElementaryStream* es_ptr;
-		} es;
+			const vm::var<CellDmuxMsg> demuxerMsg{{ .msgType = CELL_DMUX_MSG_TYPE_FATAL_ERR, .supplementalInfo = static_cast<u64>(ret) }};
+			es_handle->dmux_handle->dmux_cb.cbFunc(ppu, es_handle->dmux_handle, demuxerMsg, es_handle->dmux_handle->dmux_cb.cbArg);
+		}
 	};
 
-	DemuxerTask()
-	{
-	}
-
-	DemuxerTask(DemuxerJobType type)
-		: type(type)
-	{
-	}
-};
-
-class ElementaryStream
-{
-	std::mutex m_mutex;
-
-	squeue_t<u32> entries; // AU starting addresses
-	u32 put_count = 0; // number of AU written
-	u32 got_count = 0; // number of AU obtained by GetAu(Ex)
-	u32 released = 0; // number of AU released
-
-	u32 put; // AU that is being written now
-
-	bool is_full(u32 space);
-
-public:
-	static const u32 id_base = 1;
-	static const u32 id_step = 1;
-	static const u32 id_count = 1023;
-	SAVESTATE_INIT_POS(34);
-
-	ElementaryStream(Demuxer* dmux, vm::ptr<void> addr, u32 size, u32 fidMajor, u32 fidMinor, u32 sup1, u32 sup2, vm::ptr<CellDmuxCbEsMsg> cbFunc, vm::ptr<void> cbArg, u32 spec);
-
-	Demuxer* dmux;
-	const u32 id = idm::last_id();
-	const vm::ptr<void> memAddr;
-	const u32 memSize;
-	const u32 fidMajor;
-	const u32 fidMinor;
-	const u32 sup1;
-	const u32 sup2;
-	const vm::ptr<CellDmuxCbEsMsg> cbFunc;
-	const vm::ptr<void> cbArg;
-	const u32 spec; //addr
-
-	std::vector<u8> raw_data; // demultiplexed data stream (managed by demuxer thread)
-	usz raw_pos = 0; // should be <= raw_data.size()
-	u64 last_dts = CODEC_TS_INVALID;
-	u64 last_pts = CODEC_TS_INVALID;
-
-	void push(DemuxerStream& stream, u32 size); // called by demuxer thread (not multithread-safe)
-
-	bool isfull(u32 space);
-
-	void push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool rap, u32 specific);
-
-	bool release();
-
-	bool peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index);
-
-	void reset();
-};
-
-class Demuxer : public ppu_thread
-{
-public:
-	squeue_t<DemuxerTask, 32> job;
-	const u32 memAddr;
-	const u32 memSize;
-	const vm::ptr<CellDmuxCbMsg> cbFunc;
-	const vm::ptr<void> cbArg;
-	volatile bool is_finished = false;
-	volatile bool is_closed = false;
-	atomic_t<bool> is_running = false;
-	atomic_t<bool> is_working = false;
-
-	Demuxer(u32 addr, u32 size, vm::ptr<CellDmuxCbMsg> func, vm::ptr<void> arg)
-		: ppu_thread({}, "", 0)
-		, memAddr(addr)
-		, memSize(size)
-		, cbFunc(func)
-		, cbArg(arg)
-	{
-	}
-
-	void non_task()
-	{
-		DemuxerTask task;
-		DemuxerStream stream = {};
-		ElementaryStream* esALL[96]{};
-		ElementaryStream** esAVC = &esALL[0]; // AVC (max 16 minus M2V count)
-		//ElementaryStream** esM2V = &esALL[16]; // M2V (max 16 minus AVC count)
-		//ElementaryStream** esDATA = &esALL[32]; // user data (max 16)
-		ElementaryStream** esATX = &esALL[48]; // ATRAC3+ (max 16)
-		//ElementaryStream** esAC3 = &esALL[64]; // AC3 (max 16)
-		//ElementaryStream** esPCM = &esALL[80]; // LPCM (max 16)
-
-		u32 cb_add = 0;
-
-		while (true)
-		{
-			if (Emu.IsStopped() || is_closed)
-			{
-				break;
-			}
-
-			if (!job.try_peek(task) && is_running && stream.addr)
-			{
-				// default task (demuxing) (if there is no other work)
-				be_t<u32> code;
-				be_t<u16> len;
-
-				if (!stream.peek(code))
-				{
-					// demuxing finished
-					is_running = false;
-
-					// callback
-					auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(memAddr + (cb_add ^= 16));
-					dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
-					dmuxMsg->supplementalInfo = stream.userdata;
-					cbFunc(*this, id, dmuxMsg, cbArg);
-					lv2_obj::sleep(*this);
-
-					is_working = false;
-
-					stream = {};
-
-					continue;
-				}
-
-				switch (code)
-				{
-				case PACK_START_CODE:
-				{
-					if (!stream.check(14))
-					{
-						fmt::throw_exception("End of stream (PACK_START_CODE)");
-					}
-					stream.skip(14);
-					break;
-				}
-
-				case SYSTEM_HEADER_START_CODE:
-				{
-					if (!stream.check(18))
-					{
-						fmt::throw_exception("End of stream (SYSTEM_HEADER_START_CODE)");
-					}
-					stream.skip(18);
-					break;
-				}
-
-				case PADDING_STREAM:
-				{
-					if (!stream.check(6))
-					{
-						fmt::throw_exception("End of stream (PADDING_STREAM)");
-					}
-					stream.skip(4);
-					stream.get(len);
-
-					if (!stream.check(len))
-					{
-						fmt::throw_exception("End of stream (PADDING_STREAM, len=%d)", len);
-					}
-					stream.skip(len);
-					break;
-				}
-
-				case PRIVATE_STREAM_2:
-				{
-					if (!stream.check(6))
-					{
-						fmt::throw_exception("End of stream (PRIVATE_STREAM_2)");
-					}
-					stream.skip(4);
-					stream.get(len);
-
-					cellDmux.notice("PRIVATE_STREAM_2 (%d)", len);
-
-					if (!stream.check(len))
-					{
-						fmt::throw_exception("End of stream (PRIVATE_STREAM_2, len=%d)", len);
-					}
-					stream.skip(len);
-					break;
-				}
-
-				case PRIVATE_STREAM_1:
-				{
-					// audio and user data stream
-					DemuxerStream backup = stream;
-
-					if (!stream.check(6))
-					{
-						fmt::throw_exception("End of stream (PRIVATE_STREAM_1)");
-					}
-					stream.skip(4);
-					stream.get(len);
-
-					if (!stream.check(len))
-					{
-						fmt::throw_exception("End of stream (PRIVATE_STREAM_1, len=%d)", len);
-					}
-
-					const PesHeader pes(stream);
-					if (!pes.is_ok)
-					{
-						fmt::throw_exception("PesHeader error (PRIVATE_STREAM_1, len=%d)", len);
-					}
-
-					if (len < pes.size + 4)
-					{
-						fmt::throw_exception("End of block (PRIVATE_STREAM_1, PesHeader + fid_minor, len=%d)", len);
-					}
-					len -= pes.size + 4;
-
-					u8 fid_minor;
-					if (!stream.get(fid_minor))
-					{
-						fmt::throw_exception("End of stream (PRIVATE_STREAM1, fid_minor)");
-					}
-
-					const u32 ch = fid_minor % 16;
-					if ((fid_minor & -0x10) == 0 && esATX[ch])
-					{
-						ElementaryStream& es = *esATX[ch];
-						if (es.raw_data.size() > 1024 * 1024)
-						{
-							stream = backup;
-							std::this_thread::sleep_for(1ms); // hack
-							continue;
-						}
-
-						if (len < 3 || !stream.check(3))
-						{
-							fmt::throw_exception("End of block (ATX, unknown header, len=%d)", len);
-						}
-						len -= 3;
-						stream.skip(3);
-
-						if (pes.has_ts)
-						{
-							es.last_dts = pes.dts;
-							es.last_pts = pes.pts;
-						}
-
-						es.push(stream, len);
-
-						while (true)
-						{
-							auto const size = es.raw_data.size() - es.raw_pos; // size of available new data
-							auto const data = es.raw_data.data() + es.raw_pos; // pointer to available data
-
-							if (size < 8) break; // skip if cannot read ATS header
-
-							if (data[0] != 0x0f || data[1] != 0xd0)
-							{
-								fmt::throw_exception("ATX: 0x0fd0 header not found (ats=0x%llx)", *reinterpret_cast<be_t<u64>*>(data));
-							}
-
-							u32 frame_size = (((u32{data[2]} & 0x3) << 8) | u32{data[3]}) * 8 + 8;
-
-							if (size < frame_size + 8) break; // skip non-complete AU
-
-							if (es.isfull(frame_size + 8)) break; // skip if cannot push AU
-
-							es.push_au(frame_size + 8, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
-
-							//cellDmux.notice("ATX AU pushed (ats=0x%llx, frame_size=%d)", *(be_t<u64>*)data, frame_size);
-
-							auto esMsg = vm::ptr<CellDmuxEsMsg>::make(memAddr + (cb_add ^= 16));
-							esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
-							esMsg->supplementalInfo = stream.userdata;
-							es.cbFunc(*this, id, es.id, esMsg, es.cbArg);
-							lv2_obj::sleep(*this);
-						}
-					}
-					else
-					{
-						cellDmux.notice("PRIVATE_STREAM_1 (len=%d, fid_minor=0x%x)", len, fid_minor);
-						stream.skip(len);
-					}
-					break;
-				}
-
-				case 0x1e0: case 0x1e1: case 0x1e2: case 0x1e3:
-				case 0x1e4: case 0x1e5: case 0x1e6: case 0x1e7:
-				case 0x1e8: case 0x1e9: case 0x1ea: case 0x1eb:
-				case 0x1ec: case 0x1ed: case 0x1ee: case 0x1ef:
-				{
-					// video stream (AVC or M2V)
-					DemuxerStream backup = stream;
-
-					if (!stream.check(6))
-					{
-						fmt::throw_exception("End of stream (video, code=0x%x)", code);
-					}
-					stream.skip(4);
-					stream.get(len);
-
-					if (!stream.check(len))
-					{
-						fmt::throw_exception("End of stream (video, code=0x%x, len=%d)", code, len);
-					}
-
-					const PesHeader pes(stream);
-					if (!pes.is_ok)
-					{
-						fmt::throw_exception("PesHeader error (video, code=0x%x, len=%d)", code, len);
-					}
-
-					if (len < pes.size + 3)
-					{
-						fmt::throw_exception("End of block (video, code=0x%x, PesHeader)", code);
-					}
-					len -= pes.size + 3;
-
-					const u32 ch = code % 16;
-					if (esAVC[ch])
-					{
-						ElementaryStream& es = *esAVC[ch];
-
-						const u32 old_size = ::size32(es.raw_data);
-						if (es.isfull(old_size))
-						{
-							stream = backup;
-							std::this_thread::sleep_for(1ms); // hack
-							continue;
-						}
-
-						if ((pes.has_ts && old_size) || old_size >= 0x69800)
-						{
-							// push AU if it becomes too big or the next packet contains PTS/DTS
-							es.push_au(old_size, es.last_dts, es.last_pts, stream.userdata, false /* TODO: set correct value */, 0);
-
-							// callback
-							auto esMsg = vm::ptr<CellDmuxEsMsg>::make(memAddr + (cb_add ^= 16));
-							esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
-							esMsg->supplementalInfo = stream.userdata;
-							es.cbFunc(*this, id, es.id, esMsg, es.cbArg);
-							lv2_obj::sleep(*this);
-						}
-
-						if (pes.has_ts)
-						{
-							// preserve dts/pts for next AU
-							es.last_dts = pes.dts;
-							es.last_pts = pes.pts;
-						}
-
-						// reconstruction of MPEG2-PS stream for vdec module
-						const u32 size = len + pes.size + 9;
-						stream = backup;
-						es.push(stream, size);
-					}
-					else
-					{
-						cellDmux.notice("Video stream (code=0x%x, len=%d)", code, len);
-						stream.skip(len);
-					}
-					break;
-				}
-
-				default:
-				{
-					if ((code & PACKET_START_CODE_MASK) == PACKET_START_CODE_PREFIX)
-					{
-						fmt::throw_exception("Unknown code found (0x%x)", code);
-					}
-
-					// search
-					stream.skip(1);
-				}
-				}
-
-				continue;
-			}
-
-			// wait for task if no work
-			if (!job.pop(task, &is_closed))
-			{
-				break; // Emu is stopped
-			}
-
-			switch (task.type)
-			{
-			case dmuxSetStream:
-			{
-				if (task.stream.discontinuity)
-				{
-					cellDmux.warning("dmuxSetStream (beginning)");
-					for (u32 i = 0; i < std::size(esALL); i++)
-					{
-						if (esALL[i])
-						{
-							esALL[i]->reset();
-						}
-					}
-				}
-
-				stream = task.stream;
-				//cellDmux.notice("*** stream updated(addr=0x%x, size=0x%x, discont=%d, userdata=0x%llx)",
-					//stream.addr, stream.size, stream.discontinuity, stream.userdata);
-				break;
-			}
-
-			case dmuxResetStream:
-			case dmuxResetStreamAndWaitDone:
-			{
-				// demuxing stopped
-				if (is_running.exchange(false))
-				{
-					// callback
-					auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(memAddr + (cb_add ^= 16));
-					dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
-					dmuxMsg->supplementalInfo = stream.userdata;
-					cbFunc(*this, id, dmuxMsg, cbArg);
-					lv2_obj::sleep(*this);
-
-					stream = {};
-
-					is_working = false;
-				}
-
-				break;
-			}
-
-			case dmuxEnableEs:
-			{
-				ElementaryStream& es = *task.es.es_ptr;
-
-				// TODO: uncomment when ready to use
-				//if ((es.fidMajor & -0x10) == 0xe0 && es.fidMinor == 0 && es.sup1 == 1 && !es.sup2)
-				//{
-				//	esAVC[es.fidMajor % 16] = task.es.es_ptr;
-				//}
-				//else if ((es.fidMajor & -0x10) == 0xe0 && es.fidMinor == 0 && !es.sup1 && !es.sup2)
-				//{
-				//	esM2V[es.fidMajor % 16] = task.es.es_ptr;
-				//}
-				//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0 && !es.sup1 && !es.sup2)
-				//{
-				//	esATX[es.fidMinor % 16] = task.es.es_ptr;
-				//}
-				//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0x20 && !es.sup1 && !es.sup2)
-				//{
-				//	esDATA[es.fidMinor % 16] = task.es.es_ptr;
-				//}
-				//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0x30 && !es.sup1 && !es.sup2)
-				//{
-				//	esAC3[es.fidMinor % 16] = task.es.es_ptr;
-				//}
-				//else if (es.fidMajor == 0xbd && (es.fidMinor & -0x10) == 0x40 && !es.sup1 && !es.sup2)
-				//{
-				//	esPCM[es.fidMinor % 16] = task.es.es_ptr;
-				//}
-				//else
-				{
-					fmt::throw_exception("dmuxEnableEs: unknown filter (0x%x, 0x%x, 0x%x, 0x%x)", es.fidMajor, es.fidMinor, es.sup1, es.sup2);
-				}
-				es.dmux = this;
-				break;
-			}
-
-			case dmuxDisableEs:
-			{
-				ElementaryStream& es = *task.es.es_ptr;
-				if (es.dmux != this)
-				{
-					fmt::throw_exception("dmuxDisableEs: invalid elementary stream");
-				}
-
-				for (u32 i = 0; i < std::size(esALL); i++)
-				{
-					if (esALL[i] == &es)
-					{
-						esALL[i] = nullptr;
-					}
-				}
-				es.dmux = nullptr;
-				idm::remove<ElementaryStream>(task.es.es);
-				break;
-			}
-
-			case dmuxFlushEs:
-			{
-				ElementaryStream& es = *task.es.es_ptr;
-
-				const u32 old_size = ::size32(es.raw_data);
-				if (old_size && (es.fidMajor & -0x10) == 0xe0)
-				{
-					// TODO (it's only for AVC, some ATX data may be lost)
-					while (es.isfull(old_size))
-					{
-						if (Emu.IsStopped() || is_closed) break;
-
-						std::this_thread::sleep_for(1ms); // hack
-					}
-
-					es.push_au(old_size, es.last_dts, es.last_pts, stream.userdata, false, 0);
-
-					// callback
-					auto esMsg = vm::ptr<CellDmuxEsMsg>::make(memAddr + (cb_add ^= 16));
-					esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
-					esMsg->supplementalInfo = stream.userdata;
-					es.cbFunc(*this, id, es.id, esMsg, es.cbArg);
-					lv2_obj::sleep(*this);
-				}
-
-				if (!es.raw_data.empty())
-				{
-					cellDmux.error("dmuxFlushEs: 0x%x bytes lost (es_id=%d)", ::size32(es.raw_data), es.id);
-				}
-
-				// callback
-				auto esMsg = vm::ptr<CellDmuxEsMsg>::make(memAddr + (cb_add ^= 16));
-				esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE;
-				esMsg->supplementalInfo = stream.userdata;
-				es.cbFunc(*this, id, es.id, esMsg, es.cbArg);
-				lv2_obj::sleep(*this);
-				break;
-			}
-
-			case dmuxResetEs:
-			{
-				task.es.es_ptr->reset();
-				break;
-			}
-
-			case dmuxClose:
-			{
-				break;
-			}
-
-			default:
-			{
-				fmt::throw_exception("Demuxer thread error: unknown task (0x%x)", +task.type);
-			}
-			}
-		}
-
-		is_finished = true;
-	}
-};
-
-
-PesHeader::PesHeader(DemuxerStream& stream)
-	: pts(CODEC_TS_INVALID)
-	, dts(CODEC_TS_INVALID)
-	, size(0)
-	, has_ts(false)
-	, is_ok(false)
-{
-	u16 header;
-	if (!stream.get(header))
-	{
-		fmt::throw_exception("End of stream (header)");
-	}
-	if (!stream.get(size))
-	{
-		fmt::throw_exception("End of stream (size)");
-	}
-	if (!stream.check(size))
-	{
-		fmt::throw_exception("End of stream (size=%d)", size);
-	}
-
-	u8 pos = 0;
-	while (pos++ < size)
-	{
-		u8 v;
-		if (!stream.get(v))
-		{
-			return; // should never occur
-		}
-
-		if (v == 0xff) // skip padding bytes
-		{
-			continue;
-		}
-
-		if ((v & 0xf0) == 0x20 && (size - pos) >= 4) // pts only
-		{
-			pos += 4;
-			pts = stream.get_ts(v);
-			has_ts = true;
-		}
-		else if ((v & 0xf0) == 0x30 && (size - pos) >= 9) // pts and dts
-		{
-			pos += 5;
-			pts = stream.get_ts(v);
-			stream.get(v);
-			has_ts = true;
-
-			if ((v & 0xf0) != 0x10)
-			{
-				cellDmux.error("PesHeader(): dts not found (v=0x%x, size=%d, pos=%d)", v, size, pos - 1);
-				stream.skip(size - pos);
-				return;
-			}
-			pos += 4;
-			dts = stream.get_ts(v);
-		}
-		else
-		{
-			cellDmux.warning("PesHeader(): unknown code (v=0x%x, size=%d, pos=%d)", v, size, pos - 1);
-			stream.skip(size - pos);
-			pos = size;
-			break;
-		}
-	}
-
-	is_ok = true;
-}
-
-ElementaryStream::ElementaryStream(Demuxer* dmux, vm::ptr<void> addr, u32 size, u32 fidMajor, u32 fidMinor, u32 sup1, u32 sup2, vm::ptr<CellDmuxCbEsMsg> cbFunc, vm::ptr<void> cbArg, u32 spec)
-	: put(utils::align(addr.addr(), 128))
-	, dmux(dmux)
-	, memAddr(vm::ptr<void>::make(utils::align(addr.addr(), 128)))
-	, memSize(size - (addr.addr() - memAddr.addr()))
-	, fidMajor(fidMajor)
-	, fidMinor(fidMinor)
-	, sup1(sup1)
-	, sup2(sup2)
-	, cbFunc(cbFunc)
-	, cbArg(cbArg)
-	, spec(spec)
-{
-}
-
-bool ElementaryStream::is_full(u32 space)
-{
-	if (released < put_count)
-	{
-		if (entries.is_full())
-		{
-			return true;
-		}
-
-		u32 first = 0;
-		if (!entries.peek(first, 0, &dmux->is_closed) || !first)
-		{
-			fmt::throw_exception("entries.peek() failed");
-		}
-		else if (first >= put)
-		{
-			return first - put < space + 128;
-		}
-		else if (put + space + 128 > memAddr.addr() + memSize)
-		{
-			return first - memAddr.addr() < space + 128;
-		}
-		else
-		{
-			return false;
-		}
-	}
-	else
-	{
-		return false;
-	}
-}
-
-bool ElementaryStream::isfull(u32 space)
-{
-	std::lock_guard lock(m_mutex);
-	return is_full(space);
-}
-
-void ElementaryStream::push_au(u32 size, u64 dts, u64 pts, u64 userdata, bool rap, u32 specific)
-{
-	u32 addr;
-	{
-		std::lock_guard lock(m_mutex);
-		ensure(!is_full(size));
-
-		if (put + size + 128 > memAddr.addr() + memSize)
-		{
-			put = memAddr.addr();
-		}
-
-		std::memcpy(vm::base(put + 128), raw_data.data(), size);
-		raw_data.erase(raw_data.begin(), raw_data.begin() + size);
-
-		auto info = vm::ptr<CellDmuxAuInfoEx>::make(put);
-		info->auAddr.set(put + 128);
-		info->auSize = size;
-		info->dts.lower = static_cast<u32>(dts);
-		info->dts.upper = static_cast<u32>(dts >> 32);
-		info->pts.lower = static_cast<u32>(pts);
-		info->pts.upper = static_cast<u32>(pts >> 32);
-		info->isRap = rap;
-		info->auMaxSize = 0;
-		info->userData = userdata;
-
-		auto spec = vm::ptr<u32>::make(put + u32{sizeof(CellDmuxAuInfoEx)});
-		*spec = specific;
-
-		auto inf = vm::ptr<CellDmuxAuInfo>::make(put + 64);
-		inf->auAddr.set(put + 128);
-		inf->auSize = size;
-		inf->dts.lower = static_cast<u32>(dts);
-		inf->dts.upper = static_cast<u32>(dts >> 32);
-		inf->pts.lower = static_cast<u32>(pts);
-		inf->pts.upper = static_cast<u32>(pts >> 32);
-		inf->auMaxSize = 0; // ?????
-		inf->userData = userdata;
-
-		addr = put;
-
-		put = utils::align(put + 128 + size, 128);
-
-		put_count++;
-	}
-
-	ensure(entries.push(addr, &dmux->is_closed));
-}
-
-void ElementaryStream::push(DemuxerStream& stream, u32 size)
-{
-	auto const old_size = raw_data.size();
-
-	raw_data.resize(old_size + size);
-
-	std::memcpy(raw_data.data() + old_size, vm::base(stream.addr), size); // append bytes
-
-	stream.skip(size);
-}
-
-bool ElementaryStream::release()
-{
-	std::lock_guard lock(m_mutex);
-	if (released >= put_count)
-	{
-		cellDmux.fatal("es::release() error: buffer is empty");
-		return false;
-	}
-	if (released >= got_count)
-	{
-		cellDmux.fatal("es::release() error: buffer has not been seen yet");
-		return false;
-	}
-
-	u32 addr = 0;
-	if (!entries.pop(addr, &dmux->is_closed) || !addr)
-	{
-		cellDmux.fatal("es::release() error: entries.Pop() failed");
-		return false;
-	}
-
-	released++;
-	return true;
-}
-
-bool ElementaryStream::peek(u32& out_data, bool no_ex, u32& out_spec, bool update_index)
-{
-	std::lock_guard lock(m_mutex);
-	if (got_count < released)
-	{
-		cellDmux.fatal("es::peek() error: got_count(%d) < released(%d) (put_count=%d)", got_count, released, put_count);
-		return false;
-	}
-	if (got_count >= put_count)
-	{
-		return false;
-	}
-
-	u32 addr = 0;
-	if (!entries.peek(addr, got_count - released, &dmux->is_closed) || !addr)
-	{
-		cellDmux.fatal("es::peek() error: entries.Peek() failed");
-		return false;
-	}
-
-	out_data = no_ex ? addr + 64 : addr;
-	out_spec = addr + sizeof(CellDmuxAuInfoEx);
-
-	if (update_index)
-	{
-		got_count++;
-	}
-	return true;
-}
-
-void ElementaryStream::reset()
-{
-	std::lock_guard lock(m_mutex);
-	put = memAddr.addr();
-	entries.clear();
-	put_count = 0;
-	got_count = 0;
-	released = 0;
-	raw_data.clear();
-	raw_pos = 0;
-}
-
-void dmuxQueryAttr(u32 /* info_addr, may be 0 */, vm::ptr<CellDmuxAttr> attr)
-{
-	attr->demuxerVerLower = 0x280000; // TODO: check values
-	attr->demuxerVerUpper = 0x260000;
-	attr->memSize = 0x10000; // 0x3e8e6 from ps3
-}
-
-void dmuxQueryEsAttr(u32 /* info, may be 0 */, vm::cptr<CellCodecEsFilterId> esFilterId, u32 /*esSpecificInfo*/, vm::ptr<CellDmuxEsAttr> attr)
-{
-	if (esFilterId->filterIdMajor >= 0xe0)
-	{
-		attr->memSize = 0x500000; // 0x45fa49 from ps3
-	}
-	else
-	{
-		attr->memSize = 0x7000; // 0x73d9 from ps3
-	}
-
-	cellDmux.warning("*** filter(0x%x, 0x%x, 0x%x, 0x%x)", esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2);
-}
-
-error_code cellDmuxQueryAttr(vm::cptr<CellDmuxType> type, vm::ptr<CellDmuxAttr> attr)
-{
-	cellDmux.warning("cellDmuxQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
-
-	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	dmuxQueryAttr(0, attr);
-	return CELL_OK;
-}
-
-error_code cellDmuxQueryAttr2(vm::cptr<CellDmuxType2> type2, vm::ptr<CellDmuxAttr> attr)
-{
-	cellDmux.warning("cellDmuxQueryAttr2(demuxerType2=*0x%x, demuxerAttr=*0x%x)", type2, attr);
-
-	if (type2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	dmuxQueryAttr(type2->streamSpecificInfo, attr);
-	return CELL_OK;
-}
-
-error_code cellDmuxOpen(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResource> res, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
-{
-	cellDmux.warning("cellDmuxOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
-
-	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	// TODO: check demuxerResource and demuxerCb arguments
-	fmt::throw_exception("cellDmux disabled, use LLE.");
-}
-
-error_code cellDmuxOpenEx(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> resEx, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
-{
-	cellDmux.warning("cellDmuxOpenEx(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
-
-	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	// TODO: check demuxerResourceEx and demuxerCb arguments
-	fmt::throw_exception("cellDmux disabled, use LLE.");
-}
-
-error_code cellDmuxOpenExt(vm::cptr<CellDmuxType> type, vm::cptr<CellDmuxResourceEx> resEx, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
-{
-	cellDmux.warning("cellDmuxOpenExt(type=*0x%x, resEx=*0x%x, cb=*0x%x, handle=*0x%x)", type, resEx, cb, handle);
-
-	return cellDmuxOpenEx(type, resEx, cb, handle);
-}
-
-error_code cellDmuxOpen2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellDmuxResource2> res2, vm::cptr<CellDmuxCb> cb, vm::ptr<u32> handle)
-{
-	cellDmux.warning("cellDmuxOpen2(type2=*0x%x, res2=*0x%x, cb=*0x%x, handle=*0x%x)", type2, res2, cb, handle);
-
-	if (type2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	// TODO: check demuxerType2, demuxerResource2 and demuxerCb arguments
-	fmt::throw_exception("cellDmux disabled, use LLE.");
-}
-
-error_code cellDmuxClose(u32 handle)
-{
-	cellDmux.warning("cellDmuxClose(handle=0x%x)", handle);
-
-	const auto dmux = idm::get_unlocked<Demuxer>(handle);
-
-	if (!dmux)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	dmux->is_closed = true;
-	dmux->job.try_push(DemuxerTask(dmuxClose));
-
-	while (!dmux->is_finished)
-	{
-		if (Emu.IsStopped())
-		{
-			cellDmux.warning("cellDmuxClose(%d) aborted", handle);
-			return CELL_OK;
-		}
-
-		std::this_thread::sleep_for(1ms); // hack
-	}
-
-	idm::remove<ppu_thread>(handle);
-	return CELL_OK;
-}
-
-error_code cellDmuxSetStream(u32 handle, u32 streamAddress, u32 streamSize, b8 discontinuity, u64 userData)
-{
-	cellDmux.trace("cellDmuxSetStream(handle=0x%x, streamAddress=0x%x, streamSize=%d, discontinuity=%d, userData=0x%llx)", handle, streamAddress, streamSize, discontinuity, userData);
-
-	const auto dmux = idm::get_unlocked<Demuxer>(handle);
-
-	if (!dmux)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	if (dmux->is_running.exchange(true))
-	{
-		//std::this_thread::sleep_for(1ms); // hack
-		return CELL_DMUX_ERROR_BUSY;
-	}
-
-	DemuxerTask task(dmuxSetStream);
-	auto& info = task.stream;
-	info.addr = streamAddress;
-	info.size = streamSize;
-	info.discontinuity = discontinuity;
-	info.userdata = userData;
-
-	dmux->job.push(task, &dmux->is_closed);
-	return CELL_OK;
-}
-
-error_code cellDmuxResetStream(u32 handle)
-{
-	cellDmux.warning("cellDmuxResetStream(handle=0x%x)", handle);
-
-	const auto dmux = idm::get_unlocked<Demuxer>(handle);
-
-	if (!dmux)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	dmux->job.push(DemuxerTask(dmuxResetStream), &dmux->is_closed);
-	return CELL_OK;
-}
-
-error_code cellDmuxResetStreamAndWaitDone(u32 handle)
-{
-	cellDmux.warning("cellDmuxResetStreamAndWaitDone(handle=0x%x)", handle);
-
-	const auto dmux = idm::get_unlocked<Demuxer>(handle);
-
-	if (!dmux)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	if (!dmux->is_running)
+	// This is frequently checked in here because the elementary stream could get disabled at any time by a different thread via cellDmuxDisableEs() or cellDmuxClose().
+	if (!es_handle->is_enabled)
 	{
 		return CELL_OK;
 	}
 
-	dmux->is_working = true;
-
-	dmux->job.push(DemuxerTask(dmuxResetStreamAndWaitDone), &dmux->is_closed);
-
-	while (dmux->is_running && dmux->is_working && !dmux->is_closed) // TODO: ensure that it is safe
+	if (const error_code ret = sys_mutex_lock(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
 	{
-		if (Emu.IsStopped())
+		fatal_err(es_handle->is_enabled, ret);
+		return 1;
+	}
+
+	// Check if the access unit queue is full. One slot is reserved for the access unit produced by flushing the stream, so that flushing always succeeds.
+	if (!es_handle->is_enabled || es_handle->au_queue.allocated_size >= es_handle->au_queue.max_size - !es_handle->flush_started)
+	{
+		if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
 		{
-			cellDmux.warning("cellDmuxResetStreamAndWaitDone(%d) aborted", handle);
-			return CELL_OK;
+			fatal_err(es_handle->is_enabled, ret);
+			return 1;
 		}
-		std::this_thread::sleep_for(1ms); // hack
+
+		return !es_handle->is_enabled ? CELL_OK : not_an_error(1); // Disable error reporting if the queue is full. This is expected to happen frequently.
 	}
 
+	DmuxAuInfo& _au_info = get_au_queue_elements(es_handle)[es_handle->au_queue.back].au_info;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+	{
+		fatal_err(es_handle->is_enabled, ret);
+		return 1;
+	}
+
+	_au_info.info = au_info->info;
+	std::memcpy(_au_info.specific_info.get_ptr(), au_info->specific_info.get_ptr(), au_info->specific_info_size);
+
+	if (!es_handle->is_enabled)
+	{
+		return CELL_OK;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
+	{
+		fatal_err(es_handle->is_enabled, ret);
+		return CELL_OK; // LLE returns CELL_OK
+	}
+
+	if (!es_handle->is_enabled)
+	{
+		if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+		{
+			fatal_err(es_handle->is_enabled, ret);
+		}
+
+		return CELL_OK;
+	}
+
+	es_handle->au_queue.back = (es_handle->au_queue.back + 1) % es_handle->au_queue.max_size;
+	es_handle->au_queue.allocated_size++;
+	es_handle->au_queue.size++;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+	{
+		fatal_err(es_handle->is_enabled, ret);
+		return CELL_OK; // LLE returns CELL_OK
+	}
+
+	if (!es_handle->is_enabled)
+	{
+		return CELL_OK;
+	}
+
+	const vm::var<CellDmuxEsMsg> es_msg{{ .msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND, .supplementalInfo = es_handle->dmux_handle->user_data }};
+	es_handle->es_cb.cbFunc(ppu, es_handle->dmux_handle, es_handle, es_msg, es_handle->es_cb.cbArg);
+
 	return CELL_OK;
 }
 
-error_code cellDmuxQueryEsAttr(vm::cptr<CellDmuxType> type, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
+static error_code notify_es_flush_done(ppu_thread& ppu, vm::ptr<void> core_es_handle, vm::ptr<DmuxEsContext> es_handle)
 {
-	cellDmux.warning("cellDmuxQueryEsAttr(demuxerType=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type, esFilterId, esSpecificInfo, esAttr);
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
 
-	if (type->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	if (!savestate_lock)
 	{
-		return CELL_DMUX_ERROR_ARG;
+		ppu.state += cpu_flag::again;
+		return {};
 	}
 
-	// TODO: check esFilterId and esSpecificInfo correctly
-	dmuxQueryEsAttr(0, esFilterId, esSpecificInfo, esAttr);
+	cellDmux.notice("dmuxEsNotifyFlushDone(unk=*0x%x, es_handle=*0x%x)", core_es_handle, es_handle);
+
+	ensure(!!es_handle); // Not checked on LLE
+
+	if (!es_handle->dmux_handle->_this || !es_handle->is_enabled)
+	{
+		return CELL_OK;
+	}
+
+	es_handle->flush_started = false;
+
+	const vm::var<CellDmuxEsMsg> es_msg{{ .msgType = CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE, .supplementalInfo = es_handle->dmux_handle->user_data }};
+	es_handle->es_cb.cbFunc(ppu, es_handle->dmux_handle, es_handle, es_msg, es_handle->es_cb.cbArg);
+
 	return CELL_OK;
 }
 
-error_code cellDmuxQueryEsAttr2(vm::cptr<CellDmuxType2> type2, vm::cptr<CellCodecEsFilterId> esFilterId, u32 esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
-{
-	cellDmux.warning("cellDmuxQueryEsAttr2(type2=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", type2, esFilterId, esSpecificInfo, esAttr);
 
-	if (type2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+static error_code query_attr(ppu_thread& ppu, vm::ptr<CellDmuxAttr> demuxerAttr, vm::cptr<void> streamSpecificInfo)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
 	{
-		return CELL_DMUX_ERROR_ARG;
+		ppu.state += cpu_flag::again;
+		return {};
 	}
 
-	// TODO: check demuxerType2, esFilterId and esSpecificInfo correctly
-	dmuxQueryEsAttr(type2->streamSpecificInfo, esFilterId, esSpecificInfo, esAttr);
+	const vm::var<CellDmuxPamfAttr> pamf_attr;
+
+	if (const error_code ret = get_error(get_core_ops()->queryAttr(ppu, streamSpecificInfo, pamf_attr)); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	demuxerAttr->memSize = utils::align<u32, u32>(sizeof(DmuxContext) + (pamf_attr->maxEnabledEsNum * sizeof(vm::addr_t)) + sizeof(DmuxEsContext), alignof(DmuxContext))
+		+ pamf_attr->memSize + 0xf;
+	demuxerAttr->demuxerVerUpper = 0x260000;
+	demuxerAttr->demuxerVerLower = pamf_attr->version;
+
 	return CELL_OK;
 }
 
-error_code cellDmuxEnableEs(u32 handle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::cptr<CellDmuxEsResource> esResourceInfo, vm::cptr<CellDmuxEsCb> esCb, u32 esSpecificInfo, vm::ptr<u32> esHandle)
+error_code cellDmuxQueryAttr(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::ptr<CellDmuxAttr> demuxerAttr)
 {
-	cellDmux.warning("cellDmuxEnableEs(handle=0x%x, esFilterId=*0x%x, esResourceInfo=*0x%x, esCb=*0x%x, esSpecificInfo=*0x%x, esHandle=*0x%x)", handle, esFilterId, esResourceInfo, esCb, esSpecificInfo, esHandle);
+	cellDmux.notice("cellDmuxQueryAttr(demuxerType=*0x%x, demuxerAttr=*0x%x)", demuxerType, demuxerAttr);
 
-	const auto dmux = idm::get_unlocked<Demuxer>(handle);
-
-	if (!dmux)
+	if (!demuxerType || !demuxerAttr || demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	// TODO: check esFilterId, esResourceInfo, esCb and esSpecificInfo correctly
+	return query_attr(ppu, demuxerAttr, vm::null);
+}
 
-	const auto es = idm::make_ptr<ElementaryStream>(dmux.get(), esResourceInfo->memAddr, esResourceInfo->memSize,
-		esFilterId->filterIdMajor, esFilterId->filterIdMinor, esFilterId->supplementalInfo1, esFilterId->supplementalInfo2,
-		esCb->cbFunc, esCb->cbArg, esSpecificInfo);
+error_code cellDmuxQueryAttr2(ppu_thread& ppu, vm::cptr<CellDmuxType2> demuxerType2, vm::ptr<CellDmuxAttr> demuxerAttr)
+{
+	cellDmux.notice("cellDmuxQueryAttr2(demuxerType2=*0x%x, demuxerAttr=*0x%x)", demuxerType2, demuxerAttr);
 
-	*esHandle = es->id;
+	if (!demuxerType2 || !demuxerAttr || demuxerType2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
 
-	cellDmux.warning("*** New ES(dmux=0x%x, addr=0x%x, size=0x%x, filter={0x%x, 0x%x, 0x%x, 0x%x}, cb=0x%x, arg=0x%x, spec=0x%x): id = 0x%x",
-		handle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, es->cbFunc, es->cbArg, es->spec, es->id);
+	return query_attr(ppu, demuxerAttr, demuxerType2->streamSpecificInfo);
+}
 
-	DemuxerTask task(dmuxEnableEs);
-	task.es.es = es->id;
-	task.es.es_ptr = es.get();
+static error_code open(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::cptr<CellDmuxResource> demuxerResource, vm::cptr<CellDmuxResourceEx> demuxerResourceEx,
+	vm::cptr<CellDmuxCb> demuxerCb, vm::cptr<void> streamSpecificInfo, vm::pptr<DmuxContext> demuxerHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	const vm::var<CellDmuxType2> type{{ .streamType = demuxerType->streamType, .streamSpecificInfo = streamSpecificInfo }};
+	const vm::var<CellDmuxAttr> attr;
+
+	if (const error_code ret = cellDmuxQueryAttr2(ppu, type, attr); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (attr->memSize > demuxerResource->memSize)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	const vm::var<CellDmuxPamfAttr> core_attr;
+
+	if (const error_code ret = get_error(get_core_ops()->queryAttr(ppu, streamSpecificInfo, core_attr)); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	const auto handle = vm::ptr<DmuxContext>::make(utils::align<u32, u32>(demuxerResource->memAddr.addr(), alignof(DmuxContext)));
+	const u32 es_handles_size = core_attr->maxEnabledEsNum * sizeof(vm::addr_t);
+	const auto core_mem_addr = vm::ptr<void>::make(utils::align<u32>(handle.addr() + sizeof(DmuxContext) + es_handles_size, 0x10));
+
+	const vm::var<CellDmuxResource> core_resource =
+	{{
+		.memAddr = core_mem_addr,
+		.memSize = demuxerResource->memSize - (core_mem_addr.addr() - demuxerResource->memAddr.addr()),
+		.ppuThreadPriority = demuxerResource->ppuThreadPriority,
+		.ppuThreadStackSize = demuxerResource->ppuThreadStackSize,
+		.spuThreadPriority = demuxerResource->spuThreadPriority,
+		.numOfSpus = demuxerResource->numOfSpus
+	}};
+
+	const vm::var<CellDmuxResourceSpurs> res_spurs;
+
+	if (demuxerResourceEx)
+	{
+		res_spurs->spurs = demuxerResourceEx->spurs;
+		res_spurs->priority = demuxerResourceEx->priority;
+		res_spurs->maxContention = demuxerResourceEx->maxContention;
+	}
+
+	const auto demux_done_func = vm::bptr<DmuxNotifyDemuxDone>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(notify_demux_done)));
+	const auto prog_end_code_func = vm::bptr<DmuxNotifyProgEndCode>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(notify_prog_end_code)));
+	const auto fatal_err_func = vm::bptr<DmuxNotifyFatalErr>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(notify_fatal_err)));
+	const vm::var<DmuxCb<DmuxNotifyDemuxDone>> cb_demux_done{{ .cbFunc = demux_done_func, .cbArg = handle }};
+	const vm::var<DmuxCb<DmuxNotifyProgEndCode>> cb_prog_end_code{{ .cbFunc = prog_end_code_func, .cbArg = handle }};
+	const vm::var<DmuxCb<DmuxNotifyFatalErr>> cb_fatal_err{{ .cbFunc = fatal_err_func, .cbArg = handle }};
+
+	const vm::var<vm::bptr<void>> core_handle;
+
+	if (const error_code ret = get_error(get_core_ops()->open(ppu, streamSpecificInfo, core_resource, demuxerResourceEx ? +res_spurs : vm::null,
+		cb_demux_done, cb_prog_end_code, cb_fatal_err, core_handle));
+		ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	handle->_this = handle;
+	handle->_this_size = sizeof(DmuxContext) + es_handles_size;
+	handle->version = core_attr->version;
+	handle->dmux_state = DMUX_STOPPED;
+	handle->dmux_type = *demuxerType;
+	handle->dmux_cb = *demuxerCb;
+	handle->stream_is_set = false;
+	handle->core_handle = *core_handle;
+	handle->version_ = core_attr->version;
+	handle->user_data = 0;
+	handle->max_enabled_es_num = core_attr->maxEnabledEsNum;
+	handle->enabled_es_num = 0;
+
+	const vm::var<sys_mutex_attribute_t> mutex_attr =
+	{{
+		.protocol = SYS_SYNC_PRIORITY,
+		.recursive = SYS_SYNC_NOT_RECURSIVE,
+		.pshared = SYS_SYNC_NOT_PROCESS_SHARED,
+		.adaptive = SYS_SYNC_NOT_ADAPTIVE,
+		.name_u64 = "_dx_mhd"_u64
+	}};
+
+	if (const error_code ret = sys_mutex_create(ppu, handle.ptr(&DmuxContext::_dx_mhd), mutex_attr); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	*demuxerHandle = handle;
 
-	dmux->job.push(task, &dmux->is_closed);
 	return CELL_OK;
 }
 
-error_code cellDmuxDisableEs(u32 esHandle)
+error_code cellDmuxOpen(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::cptr<CellDmuxResource> demuxerResource, vm::cptr<CellDmuxCb> demuxerCb, vm::pptr<DmuxContext> demuxerHandle)
 {
-	cellDmux.warning("cellDmuxDisableEs(esHandle=0x%x)", esHandle);
+	cellDmux.notice("cellDmuxOpen(demuxerType=*0x%x, demuxerResource=*0x%x, demuxerCb=*0x%x, handle=*0x%x)", demuxerType, demuxerResource, demuxerCb, demuxerHandle);
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
-
-	if (!es)
+	if (!demuxerType || demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF
+		|| !demuxerResource || !demuxerResource->memAddr || demuxerResource->memSize == umax || demuxerResource->ppuThreadStackSize == umax
+		|| !demuxerCb || !demuxerCb->cbFunc
+		|| !demuxerHandle)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	DemuxerTask task(dmuxDisableEs);
-	task.es.es = esHandle;
-	task.es.es_ptr = es.get();
-
-	es->dmux->job.push(task, &es->dmux->is_closed);
-	return CELL_OK;
+	return open(ppu, demuxerType, demuxerResource, vm::null, demuxerCb, vm::null, demuxerHandle);
 }
 
-error_code cellDmuxResetEs(u32 esHandle)
+error_code cellDmuxOpenEx(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::cptr<CellDmuxResourceEx> demuxerResourceEx, vm::cptr<CellDmuxCb> demuxerCb, vm::pptr<DmuxContext> demuxerHandle)
 {
-	cellDmux.trace("cellDmuxResetEs(esHandle=0x%x)", esHandle);
+	cellDmux.notice("cellDmuxOpenEx(demuxerType=*0x%x, demuxerResourceEx=*0x%x, demuxerCb=*0x%x, demuxerHandle=*0x%x)", demuxerType, demuxerResourceEx, demuxerCb, demuxerHandle);
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
-
-	if (!es)
+	if (!demuxerType || demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF
+		|| !demuxerResourceEx || !demuxerResourceEx->memAddr || demuxerResourceEx->memSize == umax || demuxerResourceEx->ppuThreadStackSize == umax
+		|| !demuxerResourceEx->spurs || demuxerResourceEx->maxContention == 0u
+		|| (demuxerResourceEx->priority & 0xf0f0f0f0f0f0f0f0ull) != 0u // Each byte in priority must be less than 0x10
+		|| !demuxerCb
+		|| !demuxerHandle)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	DemuxerTask task(dmuxResetEs);
-	task.es.es = esHandle;
-	task.es.es_ptr = es.get();
+	const vm::var<CellDmuxResource> resource
+	{{
+		.memAddr = demuxerResourceEx->memAddr,
+		.memSize = demuxerResourceEx->memSize,
+		.ppuThreadPriority = demuxerResourceEx->ppuThreadPriority,
+		.ppuThreadStackSize = demuxerResourceEx->ppuThreadStackSize,
+		.spuThreadPriority = 0xfa,
+		.numOfSpus =  1
+	}};
 
-	es->dmux->job.push(task, &es->dmux->is_closed);
-	return CELL_OK;
+	return open(ppu, demuxerType, resource, demuxerResourceEx, demuxerCb, vm::null, demuxerHandle);
 }
 
-error_code cellDmuxGetAu(u32 esHandle, vm::ptr<u32> auInfo, vm::ptr<u32> auSpecificInfo)
+error_code cellDmuxOpenExt(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::cptr<CellDmuxResourceEx> demuxerResourceEx, vm::cptr<CellDmuxCb> demuxerCb, vm::pptr<DmuxContext> demuxerHandle)
 {
-	cellDmux.trace("cellDmuxGetAu(esHandle=0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
+	cellDmux.notice("cellDmuxOpenExt(demuxerType=*0x%x, demuxerResourceEx=*0x%x, demuxerCb=*0x%x, demuxerHandle=*0x%x)", demuxerType, demuxerResourceEx, demuxerCb, demuxerHandle);
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
-
-	if (!es)
-	{
-		return CELL_DMUX_ERROR_ARG;
-	}
-
-	u32 info;
-	u32 spec;
-	if (!es->peek(info, true, spec, true))
-	{
-		return CELL_DMUX_ERROR_EMPTY;
-	}
-
-	*auInfo = info;
-	*auSpecificInfo = spec;
-	return CELL_OK;
+	return cellDmuxOpenEx(ppu, demuxerType, demuxerResourceEx, demuxerCb, demuxerHandle);
 }
 
-error_code cellDmuxPeekAu(u32 esHandle, vm::ptr<u32> auInfo, vm::ptr<u32> auSpecificInfo)
+error_code cellDmuxOpen2(ppu_thread& ppu, vm::cptr<CellDmuxType2> demuxerType2, vm::cptr<CellDmuxResource2> demuxerResource2, vm::cptr<CellDmuxCb> demuxerCb, vm::pptr<DmuxContext> demuxerHandle)
 {
-	cellDmux.trace("cellDmuxPeekAu(esHandle=0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
+	cellDmux.notice("cellDmuxOpen2(demuxerType2=*0x%x, demuxerResource2=*0x%x, demuxerCb=*0x%x, demuxerHandle=*0x%x)", demuxerType2, demuxerResource2, demuxerCb, demuxerHandle);
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
-
-	if (!es)
+	if (!demuxerType2 || demuxerType2->streamType != CELL_DMUX_STREAM_TYPE_PAMF
+		|| !demuxerResource2
+		|| !demuxerCb || !demuxerCb->cbFunc
+		|| !demuxerHandle)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	u32 info;
-	u32 spec;
-	if (!es->peek(info, true, spec, false))
+	const vm::var<CellDmuxType> type{{ .streamType = CELL_DMUX_STREAM_TYPE_PAMF }};
+
+	if (demuxerResource2->isResourceEx)
 	{
-		return CELL_DMUX_ERROR_EMPTY;
+		if (!demuxerResource2->resourceEx.memAddr || demuxerResource2->resourceEx.memSize == umax || demuxerResource2->resourceEx.ppuThreadStackSize == umax
+			|| !demuxerResource2->resourceEx.spurs || demuxerResource2->resourceEx.maxContention == 0u
+			|| (demuxerResource2->resourceEx.priority & 0xf0f0f0f0f0f0f0f0ull) != 0u) // Each byte in priority must be less than 0x10
+		{
+			return CELL_DMUX_ERROR_ARG;
+		}
+
+		const vm::var<CellDmuxResource> resource
+		{{
+			.memAddr = demuxerResource2->resourceEx.memAddr,
+			.memSize = demuxerResource2->resourceEx.memSize,
+			.ppuThreadPriority = demuxerResource2->resourceEx.ppuThreadPriority,
+			.ppuThreadStackSize = demuxerResource2->resourceEx.ppuThreadStackSize,
+			.spuThreadPriority = 0xfa,
+			.numOfSpus = 1
+		}};
+
+		return open(ppu, type, resource, demuxerResource2.ptr(&CellDmuxResource2::resourceEx), demuxerCb, demuxerType2->streamSpecificInfo, demuxerHandle);
 	}
 
-	*auInfo = info;
-	*auSpecificInfo = spec;
-	return CELL_OK;
+	if (!demuxerResource2->resource.memAddr || demuxerResource2->resource.memSize == umax || demuxerResource2->resource.ppuThreadStackSize == umax)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	return open(ppu, type, demuxerResource2.ptr(&CellDmuxResource2::resource), vm::null, demuxerCb, demuxerType2->streamSpecificInfo, demuxerHandle);
 }
 
-error_code cellDmuxGetAuEx(u32 esHandle, vm::ptr<u32> auInfoEx, vm::ptr<u32> auSpecificInfo)
+static error_code disable_es(ppu_thread& ppu, DmuxEsContext& esHandle)
 {
-	cellDmux.trace("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
-
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
-
-	if (!es)
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle._dx_mes, 0); ret != CELL_OK)
 	{
-		return CELL_DMUX_ERROR_ARG;
+		return ret;
 	}
 
-	u32 info;
-	u32 spec;
-	if (!es->peek(info, false, spec, true))
+	const error_code core_ret = get_core_ops()->disableEs(ppu, esHandle.core_es_handle);
+
+	esHandle.is_enabled = false;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, esHandle._dx_mes); ret != CELL_OK)
 	{
-		return CELL_DMUX_ERROR_EMPTY;
+		return ret;
 	}
 
-	*auInfoEx = info;
-	*auSpecificInfo = spec;
-	return CELL_OK;
+	error_code ret;
+	while ((ret = sys_mutex_destroy(ppu, esHandle._dx_mes)) == static_cast<s32>(CELL_EBUSY))
+	{
+		sys_timer_usleep(ppu, 200);
+	}
+
+	if (ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	esHandle._this = vm::null;
+
+	return get_error(core_ret);
 }
 
-error_code cellDmuxPeekAuEx(u32 esHandle, vm::ptr<u32> auInfoEx, vm::ptr<u32> auSpecificInfo)
+error_code cellDmuxClose(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
 {
-	cellDmux.trace("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
 
-	if (!es)
+	cellDmux.notice("cellDmuxClose(demuxerHandle=*0x%x)", demuxerHandle);
+
+	if (!demuxerHandle || !demuxerHandle->_this || demuxerHandle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	u32 info;
-	u32 spec;
-	if (!es->peek(info, false, spec, false))
+	demuxerHandle->_this = vm::null;
+
+	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
 	{
-		return CELL_DMUX_ERROR_EMPTY;
+		demuxerHandle->_this = demuxerHandle;
+		return ret;
 	}
 
-	*auInfoEx = info;
-	*auSpecificInfo = spec;
-	return CELL_OK;
+	for (const vm::ptr<DmuxEsContext> es_handle : get_es_handles(demuxerHandle))
+	{
+		if (const error_code ret = disable_es(ppu, *es_handle); ret != CELL_OK)
+		{
+			ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+			demuxerHandle->_this = demuxerHandle;
+			return ret;
+		}
+
+		es_handle->dmux_handle = vm::null;
+		demuxerHandle->enabled_es_num--;
+	}
+
+	error_code ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+	ret = ret ? ret : get_error(get_core_ops()->close(ppu, demuxerHandle->core_handle));
+	ret = ret ? ret : sys_mutex_destroy(ppu, demuxerHandle->_dx_mhd);
+
+	if (ret != CELL_OK)
+	{
+		demuxerHandle->_this = demuxerHandle;
+	}
+
+	return ret;
 }
 
-error_code cellDmuxReleaseAu(u32 esHandle)
+error_code cellDmuxSetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle, vm::cptr<void> streamAddress, u32 streamSize, b8 discontinuity, u64 userData)
 {
-	cellDmux.trace("cellDmuxReleaseAu(esHandle=0x%x)", esHandle);
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
 
-	if (!es)
+	cellDmux.trace("cellDmuxSetStream(demuxerHandle=*0x%x, streamAddress=*0x%x, streamSize=0x%x, discontinuity=%d, userData=0x%llx)",
+		demuxerHandle, streamAddress, streamSize, +discontinuity, userData);
+
+	if (!demuxerHandle || !demuxerHandle->_this || streamSize == 0 || streamSize == umax || demuxerHandle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (!es->release())
+	if (!(demuxerHandle->dmux_state & DMUX_STOPPED))
+	{
+		return CELL_DMUX_ERROR_BUSY;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (const error_code ret = get_error(get_core_ops()->setStream(ppu, demuxerHandle->core_handle, streamAddress, streamSize, discontinuity, userData));
+		ret != CELL_OK)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		return mutex_unlock_ret ? mutex_unlock_ret : ret;
+	}
+
+	demuxerHandle->stream_is_set = true;
+	demuxerHandle->dmux_state = DMUX_RUNNING;
+	demuxerHandle->user_data = userData;
+
+	return sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+}
+
+error_code cellDmuxResetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("cellDmuxResetStream(demuxerHandle=*0x%x)", demuxerHandle);
+
+	if (!demuxerHandle || !demuxerHandle->_this || demuxerHandle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	const u32 dmux_status = demuxerHandle->dmux_state;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (!(dmux_status & DMUX_RUNNING) || !demuxerHandle->stream_is_set)
 	{
 		return CELL_DMUX_ERROR_SEQ;
 	}
+
+	if (const error_code ret = get_error(get_core_ops()->resetStream(ppu, demuxerHandle->core_handle)); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	demuxerHandle->stream_is_set = false;
+
 	return CELL_OK;
 }
 
-error_code cellDmuxFlushEs(u32 esHandle)
+error_code cellDmuxResetStreamAndWaitDone(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
 {
-	cellDmux.warning("cellDmuxFlushEs(esHandle=0x%x)", esHandle);
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
 
-	const auto es = idm::get_unlocked<ElementaryStream>(esHandle);
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
 
-	if (!es)
+	cellDmux.notice("cellDmuxResetStreamAndWaitDone(demuxerHandle=*0x%x)", demuxerHandle);
+
+	if (!demuxerHandle || !demuxerHandle->_this || demuxerHandle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	DemuxerTask task(dmuxFlushEs);
-	task.es.es = esHandle;
-	task.es.es_ptr = es.get();
+	if (const error_code ret = get_error(get_core_ops()->resetStreamAndWaitDone(ppu, demuxerHandle->core_handle)); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	// LLE doesn't set DmuxContext::stream_is_set to false
+
+	return CELL_OK;
+}
+
+error_code cellDmuxQueryEsAttr(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::cptr<CellCodecEsFilterId> esFilterId, vm::cptr<void> esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("cellDmuxQueryEsAttr(demuxerType=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", demuxerType, esFilterId, esSpecificInfo, esAttr);
+
+	if (!demuxerType || demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF || !esFilterId || !esAttr)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	const vm::var<CellDmuxPamfEsAttr> core_es_attr;
+
+	if (const error_code ret = get_error(get_core_ops()->queryEsAttr(ppu, vm::make_var<CellCodecEsFilterId>(*esFilterId), esSpecificInfo, core_es_attr));
+		ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	esAttr->memSize = utils::align<u32, u32>(sizeof(DmuxEsContext) + ((core_es_attr->auQueueMaxSize + 1) * (core_es_attr->specificInfoSize + sizeof(DmuxAuQueueElement))), alignof(DmuxEsContext))
+		+ core_es_attr->memSize + 0xf;
+
+	return CELL_OK;
+}
+
+error_code cellDmuxQueryEsAttr2(ppu_thread& ppu, vm::cptr<CellDmuxType2> demuxerType2, vm::cptr<CellCodecEsFilterId> esFilterId, vm::cptr<void> esSpecificInfo, vm::ptr<CellDmuxEsAttr> esAttr)
+{
+	cellDmux.notice("cellDmuxQueryEsAttr2(demuxerType2=*0x%x, esFilterId=*0x%x, esSpecificInfo=*0x%x, esAttr=*0x%x)", demuxerType2, esFilterId, esSpecificInfo, esAttr);
+
+	ensure(!!demuxerType2); // Not checked on LLE
+
+	const vm::var<CellDmuxType> demuxerType{{ .streamType = demuxerType2->streamType }};
+
+	return cellDmuxQueryEsAttr(ppu, demuxerType, esFilterId, esSpecificInfo, esAttr);
+}
+
+error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle, vm::cptr<CellCodecEsFilterId> esFilterId, vm::cptr<CellDmuxEsResource> esResourceInfo,
+	vm::cptr<CellDmuxEsCb> esCb, vm::cptr<void> esSpecificInfo, vm::pptr<DmuxEsContext> esHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("cellDmuxEnableEs(demuxerHandle=*0x%x, esFilterId=*0x%x, esResourceInfo=*0x%x, esCb=*0x%x, esSpecificInfo=*0x%x, esHandle=**0x%x)",
+		demuxerHandle, esFilterId, esResourceInfo, esCb, esSpecificInfo, esHandle);
+
+	if (!demuxerHandle || !demuxerHandle->_this || demuxerHandle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF
+		|| !esFilterId
+		|| !esResourceInfo || !esResourceInfo->memAddr || esResourceInfo->memSize == umax
+		|| !esCb || !esCb->cbFunc
+		|| !esHandle)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (demuxerHandle->enabled_es_num >= demuxerHandle->max_enabled_es_num)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_ARG;
+	}
+
+	const vm::var<CellDmuxEsAttr> es_attr;
+
+	if (const error_code ret = cellDmuxQueryEsAttr(ppu, demuxerHandle.ptr(&DmuxContext::dmux_type), esFilterId, esSpecificInfo, es_attr); ret != CELL_OK)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		return mutex_unlock_ret ? mutex_unlock_ret : ret;
+	}
+
+	if (es_attr->memSize > esResourceInfo->memSize)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_ARG;
+	}
+
+	const vm::var<CellCodecEsFilterId> es_filter_id{ *esFilterId };
+	const vm::var<CellDmuxPamfEsAttr> core_es_attr;
+
+	if (const error_code ret = get_error(get_core_ops()->queryEsAttr(ppu, es_filter_id, esSpecificInfo, core_es_attr)); ret != CELL_OK)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		return mutex_unlock_ret ? mutex_unlock_ret : ret;
+	}
+
+	core_es_attr->auQueueMaxSize++; // One extra slot for the access unit produced by flushing the stream, so that flushing always succeeds
+
+	const auto es_handle = vm::ptr<DmuxEsContext>::make(utils::align<u32, u32>(esResourceInfo->memAddr.addr(), alignof(DmuxEsContext)));
+	const u32 au_queue_elements_size = core_es_attr->auQueueMaxSize * (core_es_attr->specificInfoSize + sizeof(DmuxAuQueueElement));
+	const auto core_mem_addr = vm::bptr<void>::make(utils::align<u32>(es_handle.addr() + sizeof(DmuxEsContext) + au_queue_elements_size, 0x10));
+
+	const vm::var<CellDmuxEsResource> core_es_resource
+	{{
+		.memAddr = core_mem_addr,
+		.memSize = esResourceInfo->memSize - (core_mem_addr.addr() - esResourceInfo->memAddr.addr())
+	}};
+
+	const vm::var<sys_mutex_attribute_t> mutex_attr =
+	{{
+		.protocol = SYS_SYNC_PRIORITY,
+		.recursive = SYS_SYNC_NOT_RECURSIVE,
+		.pshared = SYS_SYNC_NOT_PROCESS_SHARED,
+		.adaptive = SYS_SYNC_NOT_ADAPTIVE,
+		.name_u64 = "_dx_mes"_u64
+	}};
+
+	if (const error_code ret = sys_mutex_create(ppu, es_handle.ptr(&DmuxEsContext::_dx_mes), mutex_attr); ret != CELL_OK)
+	{
+		ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		return ret;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
+	{
+		ensure(sys_mutex_destroy(ppu, es_handle->_dx_mes) == CELL_OK);    // Not checked on LLE
+		ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		return ret;
+	}
+
+	const auto au_found_func = vm::bptr<DmuxEsNotifyAuFound>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(notify_es_au_found)));
+	const auto flush_done_func = vm::bptr<DmuxEsNotifyFlushDone>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(notify_es_flush_done)));
+	const vm::var<DmuxCb<DmuxEsNotifyAuFound>> cb_au_found{{ .cbFunc = au_found_func, .cbArg = es_handle }};
+	const vm::var<DmuxCb<DmuxEsNotifyFlushDone>> cb_flush_done{{ .cbFunc = flush_done_func, .cbArg = es_handle }};
+
+	const vm::var<vm::bptr<void>> core_es_handle;
+
+	if (const error_code ret = get_error(get_core_ops()->enableEs(ppu, demuxerHandle->core_handle, es_filter_id, core_es_resource, cb_au_found, cb_flush_done,
+		esSpecificInfo, core_es_handle));
+		ret != CELL_OK)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, es_handle->_dx_mes);
+		const error_code mutex_destroy_ret = sys_mutex_destroy(ppu, es_handle->_dx_mes);
+
+		if (mutex_unlock_ret != CELL_OK)
+		{
+			ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+			return mutex_unlock_ret;
+		}
+
+		if (mutex_destroy_ret != CELL_OK)
+		{
+			ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+			return mutex_destroy_ret;
+		}
+
+		const error_code mutex_unlock_ret2 = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		return mutex_unlock_ret2 ? mutex_unlock_ret2 : ret;
+	}
+
+	es_handle->is_enabled = true;
+	es_handle->error_mem_size = 0;
+	es_handle->error_count = 0;
+	// es_handle->error_mem_addr is not initialized on LLE
+	es_handle->_this = es_handle;
+	es_handle->_this_size = sizeof(DmuxEsContext) + au_queue_elements_size;
+	es_handle->_this_index = demuxerHandle->enabled_es_num;
+	es_handle->dmux_handle = demuxerHandle;
+	es_handle->es_cb = *esCb;
+	es_handle->core_es_handle = *core_es_handle;
+	es_handle->flush_started = bf_t<be_t<s32>, 0, 1>{};
+	es_handle->au_queue.max_size = core_es_attr->auQueueMaxSize;
+	es_handle->au_queue.allocated_size = 0;
+	es_handle->au_queue.size = 0;
+	es_handle->au_queue.front = 0;
+	es_handle->au_queue.back = 0;
+	es_handle->au_queue.allocated_back = 0;
+
+	const vm::ptr<DmuxAuQueueElement> au_queue_elements = get_au_queue_elements(es_handle);
+
+	for (u32 i = 0; i < core_es_attr->auQueueMaxSize; i++)
+	{
+		au_queue_elements[i].index = i;
+		au_queue_elements[i].unk = 0;
+		au_queue_elements[i].au_info.info.auAddr = vm::null;
+		au_queue_elements[i].au_info.info.auMaxSize = 0;
+		au_queue_elements[i].au_info.specific_info.set(au_queue_elements.addr() + (core_es_attr->auQueueMaxSize * static_cast<u32>(sizeof(DmuxAuQueueElement))) + (i * core_es_attr->specificInfoSize));
+		au_queue_elements[i].au_info.specific_info_size = core_es_attr->specificInfoSize;
+	}
+
+	demuxerHandle->enabled_es_num++;
+	*get_es_handles(demuxerHandle).rbegin() = es_handle;
+	*esHandle = es_handle;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+	{
+		ensure(sys_mutex_destroy(ppu, es_handle->_dx_mes) == CELL_OK);    // Not checked on LLE
+		ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		return ret;
+	}
+
+	return sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+}
+
+error_code cellDmuxDisableEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("cellDmuxDisableEs(esHandle=*0x%x)", esHandle);
+
+	if (!esHandle || !esHandle->_this || !esHandle->dmux_handle || esHandle->dmux_handle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (const error_code ret = disable_es(ppu, *esHandle); ret != CELL_OK)
+	{
+		ensure(sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		return ret;
+	}
+
+	const std::span<vm::bptr<DmuxEsContext>> es_handles = get_es_handles(esHandle->dmux_handle);
+
+	std::shift_left(std::ranges::find(es_handles, static_cast<vm::bptr<DmuxEsContext>>(esHandle)), es_handles.end(), 1);
+
+	esHandle->dmux_handle->enabled_es_num--;
+	*es_handles.rbegin() = vm::null;
+
+	return sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd);
+}
+
+error_code cellDmuxResetEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("cellDmuxResetEs(esHandle=*0x%x)", esHandle);
+
+	if (!esHandle || !esHandle->_this || !esHandle->dmux_handle || esHandle->dmux_handle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	const u32 dmux_status = esHandle->dmux_handle->dmux_state;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (dmux_status & DMUX_STOPPED)
+	{
+		return CELL_DMUX_ERROR_SEQ;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (const error_code ret = get_error(get_core_ops()->resetEs(ppu, esHandle->core_es_handle)); ret != CELL_OK)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+		return mutex_unlock_ret ? mutex_unlock_ret : ret;
+	}
+
+	const auto au_queue_elements = get_au_queue_elements(esHandle);
+
+	for (s32 i = 0; i < esHandle->au_queue.max_size; i++)
+	{
+		au_queue_elements[i].index = i;
+		au_queue_elements[i].unk = 0;
+		au_queue_elements[i].au_info.info.auAddr = vm::null;
+		au_queue_elements[i].au_info.info.auMaxSize = 0;
+	}
+
+	esHandle->error_mem_size = 0;
+	esHandle->error_count = 0;
+	esHandle->au_queue.allocated_size = 0;
+	esHandle->au_queue.size = 0;
+	esHandle->au_queue.front = 0;
+	esHandle->au_queue.back = 0;
+	esHandle->au_queue.allocated_back = 0;
+
+	return sys_mutex_unlock(ppu, esHandle->_dx_mes);
+}
+
+template <bool is_peek>
+static error_code pop_au(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::cpptr<CellDmuxAuInfo> auInfo, vm::cpptr<void> auSpecificInfo)
+{
+	if (!esHandle || !esHandle->_this || !esHandle->dmux_handle || esHandle->dmux_handle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (ppu.state & cpu_flag::again)
+	{
+		return {};
+	}
+
+	if (esHandle->au_queue.size <= 0)
+	{
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+		return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_EMPTY;
+	}
+
+	const vm::ptr<DmuxAuInfo> au_info = (get_au_queue_elements(esHandle) + esHandle->au_queue.front).ptr(&DmuxAuQueueElement::au_info);
+
+	if (auInfo)
+	{
+		*auInfo = au_info.ptr(&DmuxAuInfo::info);
+	}
+
+	if (auSpecificInfo)
+	{
+		*auSpecificInfo = au_info->specific_info;
+	}
+
+	if constexpr (!is_peek)
+	{
+		esHandle->au_queue.front = (esHandle->au_queue.front + 1) % esHandle->au_queue.max_size;
+		esHandle->au_queue.size--;
+	}
+
+	return sys_mutex_unlock(ppu, esHandle->_dx_mes);
+}
+
+error_code cellDmuxGetAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::cpptr<CellDmuxAuInfo> auInfo, vm::cpptr<void> auSpecificInfo)
+{
+	cellDmux.trace("cellDmuxGetAu(esHandle=*0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
+
+	return pop_au<false>(ppu, esHandle, auInfo, auSpecificInfo);
+}
+
+error_code cellDmuxPeekAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::cpptr<CellDmuxAuInfo> auInfo, vm::cpptr<void> auSpecificInfo)
+{
+	cellDmux.trace("cellDmuxPeekAu(esHandle=*0x%x, auInfo=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfo, auSpecificInfo);
+
+	return pop_au<true>(ppu, esHandle, auInfo, auSpecificInfo);
+}
+
+error_code cellDmuxGetAuEx(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::cpptr<CellDmuxAuInfoEx> auInfoEx, vm::cpptr<void> auSpecificInfo)
+{
+	cellDmux.trace("cellDmuxGetAuEx(esHandle=*0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
+
+	return pop_au<false>(ppu, esHandle, auInfoEx, auSpecificInfo);
+}
+
+error_code cellDmuxPeekAuEx(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::cpptr<CellDmuxAuInfoEx> auInfoEx, vm::cpptr<void> auSpecificInfo)
+{
+	cellDmux.trace("cellDmuxPeekAuEx(esHandle=*0x%x, auInfoEx=**0x%x, auSpecificInfo=**0x%x)", esHandle, auInfoEx, auSpecificInfo);
+
+	return pop_au<true>(ppu, esHandle, auInfoEx, auSpecificInfo);
+}
+
+error_code cellDmuxReleaseAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.trace("cellDmuxReleaseAu(esHandle=*0x%x)", esHandle);
+
+	if (!esHandle || !esHandle->_this || !esHandle->dmux_handle || esHandle->dmux_handle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	vm::bptr<void> mem_addr;
+	u32 mem_size;
+
+	if (esHandle->au_queue.allocated_size < 1)
+	{
+		if (esHandle->error_count == 0u)
+		{
+			const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+			return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_SEQ;
+		}
+
+		mem_addr = esHandle->error_mem_addr;
+		mem_size = esHandle->error_mem_size;
+	}
+	else
+	{
+		const DmuxAuInfo& au_info = get_au_queue_elements(esHandle)[esHandle->au_queue.allocated_back].au_info;
+
+		mem_size =
+		esHandle->error_mem_size += au_info.info.auSize;
+
+		if (esHandle->error_count == 0u)
+		{
+			mem_addr = au_info.info.auAddr;
+		}
+		else
+		{
+			mem_addr = esHandle->error_mem_addr;
+		}
+
+		esHandle->au_queue.allocated_back = (esHandle->au_queue.allocated_back + 1) % esHandle->au_queue.max_size;
+		esHandle->au_queue.allocated_size--;
+
+		if (esHandle->au_queue.allocated_size < esHandle->au_queue.size)
+		{
+			esHandle->au_queue.front = (esHandle->au_queue.front + 1) % esHandle->au_queue.max_size;
+			esHandle->au_queue.size--;
+		}
+	}
+
+	if (const error_code ret = get_error(get_core_ops()->releaseAu(ppu, esHandle->core_es_handle, mem_addr, mem_size)); ret != CELL_OK)
+	{
+		if (esHandle->error_count == 0u)
+		{
+			esHandle->error_mem_addr = mem_addr;
+		}
+
+		esHandle->error_count++;
+
+		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+		return mutex_unlock_ret ? mutex_unlock_ret : ret;
+	}
+
+	esHandle->error_count = 0;
+	esHandle->error_mem_size = 0;
+
+	return sys_mutex_unlock(ppu, esHandle->_dx_mes);
+}
+
+error_code cellDmuxFlushEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
+{
+	// Blocking savestate creation due to ppu_thread::fast_call()
+	const std::unique_lock savestate_lock{ g_fxo->get<hle_locks_t>(), std::try_to_lock };
+
+	if (!savestate_lock)
+	{
+		ppu.state += cpu_flag::again;
+		return {};
+	}
+
+	cellDmux.notice("cellDmuxFlushEs(esHandle=*0x%x)", esHandle);
+
+	if (!esHandle || !esHandle->_this || !esHandle->dmux_handle || esHandle->dmux_handle->dmux_type.streamType != CELL_DMUX_STREAM_TYPE_PAMF)
+	{
+		return CELL_DMUX_ERROR_ARG;
+	}
+
+	if (const error_code ret = sys_mutex_lock(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	const u32 dmux_state = esHandle->dmux_handle->dmux_state;
+
+	if (const error_code ret = sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd); ret != CELL_OK)
+	{
+		return ret;
+	}
+
+	if (!(dmux_state & DMUX_STOPPED))
+	{
+		return CELL_DMUX_ERROR_SEQ;
+	}
+
+	esHandle->flush_started = true;
+
+	if (const error_code ret = get_error(get_core_ops()->flushEs(ppu, esHandle->core_es_handle)); ret != CELL_OK)
+	{
+		esHandle->flush_started = false;
+		return ret;
+	}
 
-	es->dmux->job.push(task, &es->dmux->is_closed);
 	return CELL_OK;
 }
 
@@ -1382,4 +1246,11 @@ DECLARE(ppu_module_manager::cellDmux)("cellDmux", []()
 	REG_FUNC(cellDmux, cellDmuxPeekAuEx);
 	REG_FUNC(cellDmux, cellDmuxReleaseAu);
 	REG_FUNC(cellDmux, cellDmuxFlushEs);
+
+	REG_HIDDEN_FUNC(notify_demux_done);
+	REG_HIDDEN_FUNC(notify_fatal_err);
+	REG_HIDDEN_FUNC(notify_prog_end_code);
+
+	REG_HIDDEN_FUNC(notify_es_au_found);
+	REG_HIDDEN_FUNC(notify_es_flush_done);
 });
diff --git a/rpcs3/Emu/Cell/Modules/cellDmux.h b/rpcs3/Emu/Cell/Modules/cellDmux.h
index dc17cb3314..3db8c63bee 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmux.h
+++ b/rpcs3/Emu/Cell/Modules/cellDmux.h
@@ -1,7 +1,8 @@
 #pragma once
 
 #include "Emu/Memory/vm_ptr.h"
-#include "cellPamf.h"
+#include "Emu/Cell/ErrorCodes.h"
+#include "Utilities/BitField.h"
 
 // Error Codes
 enum CellDmuxError :u32
@@ -18,6 +19,10 @@ enum CellDmuxStreamType : s32
 	CELL_DMUX_STREAM_TYPE_UNDEF = 0,
 	CELL_DMUX_STREAM_TYPE_PAMF = 1,
 	CELL_DMUX_STREAM_TYPE_TERMINATOR = 2,
+
+	// Only used in cellSail
+	CELL_DMUX_STREAM_TYPE_MP4 = 0x81,
+	CELL_DMUX_STREAM_TYPE_AVI = 0x82
 };
 
 enum CellDmuxMsgType : s32
@@ -48,13 +53,14 @@ struct CellDmuxEsMsg
 struct CellDmuxType
 {
 	be_t<s32> streamType; // CellDmuxStreamType
-	be_t<u32> reserved[2];
+	be_t<s32> reserved1;
+	be_t<s32> reserved2;
 };
 
 struct CellDmuxType2
 {
-	be_t<s32> streamType; // CellDmuxStreamType
-	be_t<u32> streamSpecificInfo;
+	be_t<s32> streamType;
+	vm::bcptr<void> streamSpecificInfo;
 };
 
 struct CellDmuxResource
@@ -73,8 +79,8 @@ struct CellDmuxResourceEx
 	be_t<u32> memSize;
 	be_t<u32> ppuThreadPriority;
 	be_t<u32> ppuThreadStackSize;
-	be_t<u32> spurs_addr;
-	u8 priority[8];
+	vm::bptr<void> spurs; // CellSpurs*
+	be_t<u64, 1> priority;
 	be_t<u32> maxContention;
 };
 
@@ -85,33 +91,23 @@ struct CellDmuxResourceSpurs
 	be_t<u32> maxContention;
 };
 
-/*
-struct CellDmuxResource2Ex
-{
-	b8 isResourceEx; //true
-	CellDmuxResourceEx resourceEx;
-};
-
-struct CellDmuxResource2NoEx
-{
-	b8 isResourceEx; //false
-	CellDmuxResource resource;
-};
-*/
-
 struct CellDmuxResource2
 {
 	b8 isResourceEx;
-	be_t<u32> memAddr;
-	be_t<u32> memSize;
-	be_t<u32> ppuThreadPriority;
-	be_t<u32> ppuThreadStackSize;
-	be_t<u32> shit[4];
+
+	union
+	{
+		CellDmuxResource resource;
+		CellDmuxResourceEx resourceEx;
+	};
 };
 
-using CellDmuxCbMsg = u32(u32 demuxerHandle, vm::cptr<CellDmuxMsg> demuxerMsg, vm::ptr<void> cbArg);
+struct DmuxContext;
+struct DmuxEsContext;
 
-using CellDmuxCbEsMsg = u32(u32 demuxerHandle, u32 esHandle, vm::cptr<CellDmuxEsMsg> esMsg, vm::ptr<void> cbArg);
+using CellDmuxCbMsg = u32(vm::ptr<DmuxContext> demuxerHandle, vm::cptr<CellDmuxMsg> demuxerMsg, vm::ptr<void> cbArg);
+
+using CellDmuxCbEsMsg = u32(vm::ptr<DmuxContext> demuxerHandle, vm::ptr<DmuxEsContext> esHandle, vm::cptr<CellDmuxEsMsg> esMsg, vm::ptr<void> cbArg);
 
 // Used for internal callbacks as well
 template <typename F>
@@ -177,6 +173,70 @@ struct DmuxAuInfo
 	be_t<u32> specific_info_size;
 };
 
+struct DmuxAuQueueElement
+{
+	be_t<u32> index;
+	u8 unk; // unused
+	DmuxAuInfo au_info;
+};
+
+CHECK_SIZE(DmuxAuQueueElement, 0x38);
+
+enum DmuxState : u32
+{
+	DMUX_STOPPED = 1 << 0,
+	DMUX_RUNNING = 1 << 1,
+};
+
+struct alignas(0x10) DmuxContext // CellDmuxHandle = DmuxContext*
+{
+	vm::bptr<DmuxContext> _this;
+	be_t<u32> _this_size;
+	be_t<u32> version;
+	be_t<u32> dmux_state;
+	CellDmuxType dmux_type;
+	CellDmuxCb dmux_cb;
+	b8 stream_is_set;
+	vm::bptr<void> core_handle;
+	be_t<u32> version_; // Same value as 'version'
+	be_t<u64> user_data;
+	be_t<s32> max_enabled_es_num;
+	be_t<s32> enabled_es_num;
+	be_t<u32> _dx_mhd; // sys_mutex_t
+	u8 reserved[0x7c];
+};
+
+CHECK_SIZE_ALIGN(DmuxContext, 0xc0, 0x10);
+
+struct alignas(0x10) DmuxEsContext // CellDmuxEsHandle = DmuxEsContext*
+{
+	be_t<u32> _dx_mes; // sys_mutex_t
+	be_t<u32> is_enabled;
+	be_t<u32> error_mem_size;
+	be_t<u32> error_count;
+	vm::bptr<void> error_mem_addr;
+	vm::bptr<DmuxEsContext> _this;
+	be_t<u32> _this_size;
+	be_t<s32> _this_index;
+	vm::bptr<DmuxContext> dmux_handle;
+	CellDmuxEsCb es_cb;
+	vm::bptr<void> core_es_handle;
+	bf_t<be_t<u32>, 0, 1> flush_started;
+
+	struct
+	{
+		be_t<s32> max_size;
+		be_t<s32> allocated_size;
+		be_t<s32> size;
+		be_t<s32> front;
+		be_t<s32> back;
+		be_t<s32> allocated_back;
+	}
+	au_queue;
+};
+
+CHECK_SIZE_ALIGN(DmuxEsContext, 0x50, 0x10);
+
 using DmuxNotifyDemuxDone = error_code(vm::ptr<void>, u32, vm::ptr<void>);
 using DmuxNotifyFatalErr = error_code(vm::ptr<void>, u32, vm::ptr<void>);
 using DmuxNotifyProgEndCode = error_code(vm::ptr<void>, vm::ptr<void>);
@@ -194,10 +254,10 @@ using CellDmuxCoreOpSetStream = error_code(vm::ptr<void>, vm::cptr<void>, u32, b
 using CellDmuxCoreOpReleaseAu = error_code(vm::ptr<void>, vm::ptr<void>, u32);
 using CellDmuxCoreOpQueryEsAttr = error_code(vm::cptr<void>, vm::cptr<void>, vm::ptr<CellDmuxPamfEsAttr>);
 using CellDmuxCoreOpEnableEs = error_code(vm::ptr<void>, vm::cptr<void>, vm::cptr<CellDmuxEsResource>, vm::cptr<DmuxCb<DmuxEsNotifyAuFound>>, vm::cptr<DmuxCb<DmuxEsNotifyFlushDone>>, vm::cptr<void>, vm::pptr<void>);
-using CellDmuxCoreOpDisableEs = u32(vm::ptr<void>);
-using CellDmuxCoreOpFlushEs = u32(vm::ptr<void>);
-using CellDmuxCoreOpResetEs = u32(vm::ptr<void>);
-using CellDmuxCoreOpResetStreamAndWaitDone = u32(vm::ptr<void>);
+using CellDmuxCoreOpDisableEs = error_code(vm::ptr<void>);
+using CellDmuxCoreOpFlushEs = error_code(vm::ptr<void>);
+using CellDmuxCoreOpResetEs = error_code(vm::ptr<void>);
+using CellDmuxCoreOpResetStreamAndWaitDone = error_code(vm::ptr<void>);
 
 struct CellDmuxCoreOps
 {
diff --git a/rpcs3/Emu/Cell/lv2/sys_prx.cpp b/rpcs3/Emu/Cell/lv2/sys_prx.cpp
index f46f3bdafa..6f930e79dd 100644
--- a/rpcs3/Emu/Cell/lv2/sys_prx.cpp
+++ b/rpcs3/Emu/Cell/lv2/sys_prx.cpp
@@ -63,7 +63,7 @@ extern const std::map<std::string_view, int> g_prx_list
 	{ "libcelpenc.sprx", 0 },
 	{ "libddpdec.sprx", 0 },
 	{ "libdivxdec.sprx", 0 },
-	{ "libdmux.sprx", 0 },
+	{ "libdmux.sprx", 1 },
 	{ "libdmuxpamf.sprx", 1 },
 	{ "libdtslbrdec.sprx", 0 },
 	{ "libfiber.sprx", 0 },

From 93a2f1edc8aa1503f140557be9ced248b69c1bf0 Mon Sep 17 00:00:00 2001
From: capriots <29807355+capriots@users.noreply.github.com>
Date: Sun, 8 Mar 2026 11:04:40 +0100
Subject: [PATCH 96/98] cellPamf: remove unused code

---
 rpcs3/Emu/Cell/Modules/cellPamf.cpp |   8 -
 rpcs3/Emu/Cell/Modules/cellPamf.h   | 342 ----------------------------
 2 files changed, 350 deletions(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellPamf.cpp b/rpcs3/Emu/Cell/Modules/cellPamf.cpp
index d63e7bb3e2..4bb383c2d2 100644
--- a/rpcs3/Emu/Cell/Modules/cellPamf.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellPamf.cpp
@@ -5,14 +5,6 @@
 #include <bitset>
 #include "cellPamf.h"
 
-const std::function<bool()> SQUEUE_ALWAYS_EXIT = []() { return true; };
-const std::function<bool()> SQUEUE_NEVER_EXIT = []() { return false; };
-
-bool squeue_test_exit()
-{
-	return Emu.IsStopped();
-}
-
 LOG_CHANNEL(cellPamf);
 
 template<>
diff --git a/rpcs3/Emu/Cell/Modules/cellPamf.h b/rpcs3/Emu/Cell/Modules/cellPamf.h
index abd89f8852..14608f9100 100644
--- a/rpcs3/Emu/Cell/Modules/cellPamf.h
+++ b/rpcs3/Emu/Cell/Modules/cellPamf.h
@@ -595,345 +595,3 @@ struct CellPamfReader
 CHECK_SIZE(CellPamfReader, 128);
 
 error_code cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::cptr<PamfHeader> pAddr, u64 fileSize, u32 attribute);
-
-#include <mutex>
-#include <condition_variable>
-
-extern const std::function<bool()> SQUEUE_ALWAYS_EXIT;
-extern const std::function<bool()> SQUEUE_NEVER_EXIT;
-
-bool squeue_test_exit();
-
-// TODO: eliminate this boolshit
-template<typename T, u32 sq_size = 256>
-class squeue_t
-{
-	struct squeue_sync_var_t
-	{
-		struct
-		{
-			u32 position : 31;
-			u32 pop_lock : 1;
-		};
-		struct
-		{
-			u32 count : 31;
-			u32 push_lock : 1;
-		};
-	};
-
-	atomic_t<squeue_sync_var_t> m_sync;
-
-	mutable std::mutex m_rcv_mutex;
-	mutable std::mutex m_wcv_mutex;
-	mutable std::condition_variable m_rcv;
-	mutable std::condition_variable m_wcv;
-
-	T m_data[sq_size];
-
-	enum squeue_sync_var_result : u32
-	{
-		SQSVR_OK = 0,
-		SQSVR_LOCKED = 1,
-		SQSVR_FAILED = 2,
-	};
-
-public:
-	squeue_t()
-		: m_sync(squeue_sync_var_t{})
-	{
-	}
-
-	static u32 get_max_size()
-	{
-		return sq_size;
-	}
-
-	bool is_full() const
-	{
-		return m_sync.load().count == sq_size;
-	}
-
-	bool push(const T& data, const std::function<bool()>& test_exit)
-	{
-		u32 pos = 0;
-
-		while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-
-			if (sync.push_lock)
-			{
-				return SQSVR_LOCKED;
-			}
-			if (sync.count == sq_size)
-			{
-				return SQSVR_FAILED;
-			}
-
-			sync.push_lock = 1;
-			pos = sync.position + sync.count;
-			return SQSVR_OK;
-		}))
-		{
-			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
-			{
-				return false;
-			}
-
-			std::unique_lock<std::mutex> wcv_lock(m_wcv_mutex);
-			m_wcv.wait_for(wcv_lock, std::chrono::milliseconds(1));
-		}
-
-		m_data[pos >= sq_size ? pos - sq_size : pos] = data;
-
-		m_sync.atomic_op([](squeue_sync_var_t& sync)
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-			ensure(!!sync.push_lock);
-			sync.push_lock = 0;
-			sync.count++;
-		});
-
-		m_rcv.notify_one();
-		m_wcv.notify_one();
-		return true;
-	}
-
-	bool push(const T& data, const volatile bool* do_exit)
-	{
-		return push(data, [do_exit]() { return do_exit && *do_exit; });
-	}
-
-	bool push(const T& data)
-	{
-		return push(data, SQUEUE_NEVER_EXIT);
-	}
-
-	bool try_push(const T& data)
-	{
-		return push(data, SQUEUE_ALWAYS_EXIT);
-	}
-
-	bool pop(T& data, const std::function<bool()>& test_exit)
-	{
-		u32 pos = 0;
-
-		while (u32 res = m_sync.atomic_op([&pos](squeue_sync_var_t& sync) -> u32
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-
-			if (!sync.count)
-			{
-				return SQSVR_FAILED;
-			}
-			if (sync.pop_lock)
-			{
-				return SQSVR_LOCKED;
-			}
-
-			sync.pop_lock = 1;
-			pos = sync.position;
-			return SQSVR_OK;
-		}))
-		{
-			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
-			{
-				return false;
-			}
-
-			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
-			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
-		}
-
-		data = m_data[pos];
-
-		m_sync.atomic_op([](squeue_sync_var_t& sync)
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-			ensure(!!sync.pop_lock);
-			sync.pop_lock = 0;
-			sync.position++;
-			sync.count--;
-			if (sync.position == sq_size)
-			{
-				sync.position = 0;
-			}
-		});
-
-		m_rcv.notify_one();
-		m_wcv.notify_one();
-		return true;
-	}
-
-	bool pop(T& data, const volatile bool* do_exit)
-	{
-		return pop(data, [do_exit]() { return do_exit && *do_exit; });
-	}
-
-	bool pop(T& data)
-	{
-		return pop(data, SQUEUE_NEVER_EXIT);
-	}
-
-	bool try_pop(T& data)
-	{
-		return pop(data, SQUEUE_ALWAYS_EXIT);
-	}
-
-	bool peek(T& data, u32 start_pos, const std::function<bool()>& test_exit)
-	{
-		ensure(start_pos < sq_size);
-		u32 pos = 0;
-
-		while (u32 res = m_sync.atomic_op([&pos, start_pos](squeue_sync_var_t& sync) -> u32
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-
-			if (sync.count <= start_pos)
-			{
-				return SQSVR_FAILED;
-			}
-			if (sync.pop_lock)
-			{
-				return SQSVR_LOCKED;
-			}
-
-			sync.pop_lock = 1;
-			pos = sync.position + start_pos;
-			return SQSVR_OK;
-		}))
-		{
-			if (res == SQSVR_FAILED && (test_exit() || squeue_test_exit()))
-			{
-				return false;
-			}
-
-			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
-			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
-		}
-
-		data = m_data[pos >= sq_size ? pos - sq_size : pos];
-
-		m_sync.atomic_op([](squeue_sync_var_t& sync)
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-			ensure(!!sync.pop_lock);
-			sync.pop_lock = 0;
-		});
-
-		m_rcv.notify_one();
-		return true;
-	}
-
-	bool peek(T& data, u32 start_pos, const volatile bool* do_exit)
-	{
-		return peek(data, start_pos, [do_exit]() { return do_exit && *do_exit; });
-	}
-
-	bool peek(T& data, u32 start_pos = 0)
-	{
-		return peek(data, start_pos, SQUEUE_NEVER_EXIT);
-	}
-
-	bool try_peek(T& data, u32 start_pos = 0)
-	{
-		return peek(data, start_pos, SQUEUE_ALWAYS_EXIT);
-	}
-
-	class squeue_data_t
-	{
-		T* const m_data;
-		const u32 m_pos;
-		const u32 m_count;
-
-		squeue_data_t(T* data, u32 pos, u32 count)
-			: m_data(data)
-			, m_pos(pos)
-			, m_count(count)
-		{
-		}
-
-	public:
-		T& operator [] (u32 index)
-		{
-			ensure(index < m_count);
-			index += m_pos;
-			index = index < sq_size ? index : index - sq_size;
-			return m_data[index];
-		}
-	};
-
-	void process(void(*proc)(squeue_data_t data))
-	{
-		u32 pos, count;
-
-		while (m_sync.atomic_op([&pos, &count](squeue_sync_var_t& sync) -> u32
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-
-			if (sync.pop_lock || sync.push_lock)
-			{
-				return SQSVR_LOCKED;
-			}
-
-			pos = sync.position;
-			count = sync.count;
-			sync.pop_lock = 1;
-			sync.push_lock = 1;
-			return SQSVR_OK;
-		}))
-		{
-			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
-			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
-		}
-
-		proc(squeue_data_t(m_data, pos, count));
-
-		m_sync.atomic_op([](squeue_sync_var_t& sync)
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-			ensure(!!sync.pop_lock);
-			ensure(!!sync.push_lock);
-			sync.pop_lock = 0;
-			sync.push_lock = 0;
-		});
-
-		m_wcv.notify_one();
-		m_rcv.notify_one();
-	}
-
-	void clear()
-	{
-		while (m_sync.atomic_op([](squeue_sync_var_t& sync) -> u32
-		{
-			ensure(sync.count <= sq_size);
-			ensure(sync.position < sq_size);
-
-			if (sync.pop_lock || sync.push_lock)
-			{
-				return SQSVR_LOCKED;
-			}
-
-			sync.pop_lock = 1;
-			sync.push_lock = 1;
-			return SQSVR_OK;
-		}))
-		{
-			std::unique_lock<std::mutex> rcv_lock(m_rcv_mutex);
-			m_rcv.wait_for(rcv_lock, std::chrono::milliseconds(1));
-		}
-
-		m_sync.exchange({});
-		m_wcv.notify_one();
-		m_rcv.notify_one();
-	}
-};

From 87fc45d66163987a0ff5201ab04fd27f74652e0c Mon Sep 17 00:00:00 2001
From: capriots <29807355+capriots@users.noreply.github.com>
Date: Sun, 8 Mar 2026 13:48:09 +0100
Subject: [PATCH 97/98] cellDmuxPamf: logging fix

---
 rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
index 9332fc5f1e..ecf59db508 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmuxPamf.cpp
@@ -2591,7 +2591,7 @@ template <bool raw_es>
 error_code _CellDmuxCoreOpEnableEs(ppu_thread& ppu, vm::ptr<CellDmuxPamfHandle> handle, vm::cptr<void> esFilterId, vm::cptr<CellDmuxEsResource> esResource, vm::cptr<DmuxCb<DmuxEsNotifyAuFound>> notifyAuFound,
 	vm::cptr<DmuxCb<DmuxEsNotifyFlushDone>> notifyFlushDone, vm::cptr<void> esSpecificInfo, vm::pptr<CellDmuxPamfEsHandle> esHandle)
 {
-	cellDmuxPamf.notice("_CellDmuxCoreOpEnableEs<raw_es=%d>(handle=*0x%x, esFilterId=*0x%x, esResource=*0x%x, notifyAuFound=*0x%x, notifyFlushDone=*0x%x, esSpecificInfo=*0x%x, esHandle)",
+	cellDmuxPamf.notice("_CellDmuxCoreOpEnableEs<raw_es=%d>(handle=*0x%x, esFilterId=*0x%x, esResource=*0x%x, notifyAuFound=*0x%x, notifyFlushDone=*0x%x, esSpecificInfo=*0x%x, esHandle=**0x%x)",
 		raw_es, handle, esFilterId, esResource, notifyAuFound, notifyFlushDone, esSpecificInfo, esHandle);
 
 	if (!handle || !esFilterId || !esResource || !esResource->memAddr || esResource->memSize == 0u || !notifyAuFound || !notifyAuFound->cbFunc || !notifyAuFound->cbArg || !notifyFlushDone || !notifyFlushDone->cbFunc || !notifyFlushDone->cbArg)

From e95a9806514f0086ccddb676e3a22a0d1f18de6e Mon Sep 17 00:00:00 2001
From: capriots <29807355+capriots@users.noreply.github.com>
Date: Fri, 27 Mar 2026 21:54:05 +0100
Subject: [PATCH 98/98] cellDmux: process PPU state after lv2 syscalls

---
 rpcs3/Emu/Cell/Modules/cellDmux.cpp | 128 +++++++++++++++-------------
 1 file changed, 70 insertions(+), 58 deletions(-)

diff --git a/rpcs3/Emu/Cell/Modules/cellDmux.cpp b/rpcs3/Emu/Cell/Modules/cellDmux.cpp
index 4f51539e8e..7c2fe6f1a9 100644
--- a/rpcs3/Emu/Cell/Modules/cellDmux.cpp
+++ b/rpcs3/Emu/Cell/Modules/cellDmux.cpp
@@ -58,6 +58,18 @@ static inline vm::cptr<CellDmuxCoreOps> get_core_ops()
 	return vm::cptr<CellDmuxCoreOps>::make(*ppu_module_manager::cellDmuxPamf.variables.find(0x28b2b7b2)->second.export_addr);
 }
 
+template <auto Syscall>
+static auto lv2_syscall(ppu_thread& ppu, auto&&... args)
+{
+	const auto ret = Syscall(ppu, std::forward<decltype(args)>(args)...);
+
+	if (ppu.test_stopped())
+	{
+		ppu.state += cpu_flag::again;
+	}
+
+	return ret;
+}
 
 // Callbacks for cellDmuxPamf
 
@@ -76,9 +88,9 @@ static error_code notify_demux_done(ppu_thread& ppu, vm::ptr<void> core_handle,
 
 	ensure(!!handle); // Not checked on LLE
 
-	ensure(sys_mutex_lock(ppu, handle->_dx_mhd, 0) == CELL_OK); // Failing this check on LLE would result in it dereferencing an invalid pointer.
+	ensure(lv2_syscall<sys_mutex_lock>(ppu, handle->_dx_mhd, 0) == CELL_OK); // Failing this check on LLE would result in it dereferencing an invalid pointer.
 	handle->dmux_state = DMUX_STOPPED;
-	ensure(sys_mutex_unlock(ppu, handle->_dx_mhd) == CELL_OK); // Failing this check on LLE would result in it dereferencing an invalid pointer.
+	ensure(lv2_syscall<sys_mutex_unlock>(ppu, handle->_dx_mhd) == CELL_OK); // Failing this check on LLE would result in it dereferencing an invalid pointer.
 
 	if (handle->_this)
 	{
@@ -162,7 +174,7 @@ static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_hand
 		return CELL_OK;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
 	{
 		fatal_err(es_handle->is_enabled, ret);
 		return 1;
@@ -171,7 +183,7 @@ static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_hand
 	// Check if the access unit queue is full. One slot is reserved for the access unit produced by flushing the stream, so that flushing always succeeds.
 	if (!es_handle->is_enabled || es_handle->au_queue.allocated_size >= es_handle->au_queue.max_size - !es_handle->flush_started)
 	{
-		if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+		if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, es_handle->_dx_mes); ret != CELL_OK)
 		{
 			fatal_err(es_handle->is_enabled, ret);
 			return 1;
@@ -182,7 +194,7 @@ static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_hand
 
 	DmuxAuInfo& _au_info = get_au_queue_elements(es_handle)[es_handle->au_queue.back].au_info;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, es_handle->_dx_mes); ret != CELL_OK)
 	{
 		fatal_err(es_handle->is_enabled, ret);
 		return 1;
@@ -196,7 +208,7 @@ static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_hand
 		return CELL_OK;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
 	{
 		fatal_err(es_handle->is_enabled, ret);
 		return CELL_OK; // LLE returns CELL_OK
@@ -204,7 +216,7 @@ static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_hand
 
 	if (!es_handle->is_enabled)
 	{
-		if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+		if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, es_handle->_dx_mes); ret != CELL_OK)
 		{
 			fatal_err(es_handle->is_enabled, ret);
 		}
@@ -216,7 +228,7 @@ static error_code notify_es_au_found(ppu_thread& ppu, vm::ptr<void> core_es_hand
 	es_handle->au_queue.allocated_size++;
 	es_handle->au_queue.size++;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, es_handle->_dx_mes); ret != CELL_OK)
 	{
 		fatal_err(es_handle->is_enabled, ret);
 		return CELL_OK; // LLE returns CELL_OK
@@ -405,7 +417,7 @@ static error_code open(ppu_thread& ppu, vm::cptr<CellDmuxType> demuxerType, vm::
 		.name_u64 = "_dx_mhd"_u64
 	}};
 
-	if (const error_code ret = sys_mutex_create(ppu, handle.ptr(&DmuxContext::_dx_mhd), mutex_attr); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_create>(ppu, handle.ptr(&DmuxContext::_dx_mhd), mutex_attr); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -510,7 +522,7 @@ error_code cellDmuxOpen2(ppu_thread& ppu, vm::cptr<CellDmuxType2> demuxerType2,
 
 static error_code disable_es(ppu_thread& ppu, DmuxEsContext& esHandle)
 {
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle._dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle._dx_mes, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -519,15 +531,15 @@ static error_code disable_es(ppu_thread& ppu, DmuxEsContext& esHandle)
 
 	esHandle.is_enabled = false;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, esHandle._dx_mes); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle._dx_mes); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	error_code ret;
-	while ((ret = sys_mutex_destroy(ppu, esHandle._dx_mes)) == static_cast<s32>(CELL_EBUSY))
+	while ((ret = lv2_syscall<sys_mutex_destroy>(ppu, esHandle._dx_mes)) == static_cast<s32>(CELL_EBUSY))
 	{
-		sys_timer_usleep(ppu, 200);
+		lv2_syscall<sys_timer_usleep>(ppu, 200);
 	}
 
 	if (ret != CELL_OK)
@@ -560,7 +572,7 @@ error_code cellDmuxClose(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
 
 	demuxerHandle->_this = vm::null;
 
-	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		demuxerHandle->_this = demuxerHandle;
 		return ret;
@@ -570,7 +582,7 @@ error_code cellDmuxClose(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
 	{
 		if (const error_code ret = disable_es(ppu, *es_handle); ret != CELL_OK)
 		{
-			ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
 			demuxerHandle->_this = demuxerHandle;
 			return ret;
 		}
@@ -579,9 +591,9 @@ error_code cellDmuxClose(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
 		demuxerHandle->enabled_es_num--;
 	}
 
-	error_code ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+	error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 	ret = ret ? ret : get_error(get_core_ops()->close(ppu, demuxerHandle->core_handle));
-	ret = ret ? ret : sys_mutex_destroy(ppu, demuxerHandle->_dx_mhd);
+	ret = ret ? ret : lv2_syscall<sys_mutex_destroy>(ppu, demuxerHandle->_dx_mhd);
 
 	if (ret != CELL_OK)
 	{
@@ -615,7 +627,7 @@ error_code cellDmuxSetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle
 		return CELL_DMUX_ERROR_BUSY;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -623,7 +635,7 @@ error_code cellDmuxSetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle
 	if (const error_code ret = get_error(get_core_ops()->setStream(ppu, demuxerHandle->core_handle, streamAddress, streamSize, discontinuity, userData));
 		ret != CELL_OK)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 		return mutex_unlock_ret ? mutex_unlock_ret : ret;
 	}
 
@@ -631,7 +643,7 @@ error_code cellDmuxSetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle
 	demuxerHandle->dmux_state = DMUX_RUNNING;
 	demuxerHandle->user_data = userData;
 
-	return sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+	return lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 }
 
 error_code cellDmuxResetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle)
@@ -652,14 +664,14 @@ error_code cellDmuxResetStream(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHand
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	const u32 dmux_status = demuxerHandle->dmux_state;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -774,14 +786,14 @@ error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle,
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, demuxerHandle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	if (demuxerHandle->enabled_es_num >= demuxerHandle->max_enabled_es_num)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 		return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_ARG;
 	}
 
@@ -789,13 +801,13 @@ error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle,
 
 	if (const error_code ret = cellDmuxQueryEsAttr(ppu, demuxerHandle.ptr(&DmuxContext::dmux_type), esFilterId, esSpecificInfo, es_attr); ret != CELL_OK)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 		return mutex_unlock_ret ? mutex_unlock_ret : ret;
 	}
 
 	if (es_attr->memSize > esResourceInfo->memSize)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 		return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_ARG;
 	}
 
@@ -804,7 +816,7 @@ error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle,
 
 	if (const error_code ret = get_error(get_core_ops()->queryEsAttr(ppu, es_filter_id, esSpecificInfo, core_es_attr)); ret != CELL_OK)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 		return mutex_unlock_ret ? mutex_unlock_ret : ret;
 	}
 
@@ -829,16 +841,16 @@ error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle,
 		.name_u64 = "_dx_mes"_u64
 	}};
 
-	if (const error_code ret = sys_mutex_create(ppu, es_handle.ptr(&DmuxEsContext::_dx_mes), mutex_attr); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_create>(ppu, es_handle.ptr(&DmuxEsContext::_dx_mes), mutex_attr); ret != CELL_OK)
 	{
-		ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
 		return ret;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, es_handle->_dx_mes, 0); ret != CELL_OK)
 	{
-		ensure(sys_mutex_destroy(ppu, es_handle->_dx_mes) == CELL_OK);    // Not checked on LLE
-		ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		ensure(lv2_syscall<sys_mutex_destroy>(ppu, es_handle->_dx_mes) == CELL_OK);    // Not checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
 		return ret;
 	}
 
@@ -853,22 +865,22 @@ error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle,
 		esSpecificInfo, core_es_handle));
 		ret != CELL_OK)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, es_handle->_dx_mes);
-		const error_code mutex_destroy_ret = sys_mutex_destroy(ppu, es_handle->_dx_mes);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, es_handle->_dx_mes);
+		const error_code mutex_destroy_ret = lv2_syscall<sys_mutex_destroy>(ppu, es_handle->_dx_mes);
 
 		if (mutex_unlock_ret != CELL_OK)
 		{
-			ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
 			return mutex_unlock_ret;
 		}
 
 		if (mutex_destroy_ret != CELL_OK)
 		{
-			ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+			ensure(lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
 			return mutex_destroy_ret;
 		}
 
-		const error_code mutex_unlock_ret2 = sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+		const error_code mutex_unlock_ret2 = lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 		return mutex_unlock_ret2 ? mutex_unlock_ret2 : ret;
 	}
 
@@ -906,14 +918,14 @@ error_code cellDmuxEnableEs(ppu_thread& ppu, vm::ptr<DmuxContext> demuxerHandle,
 	*get_es_handles(demuxerHandle).rbegin() = es_handle;
 	*esHandle = es_handle;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, es_handle->_dx_mes); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, es_handle->_dx_mes); ret != CELL_OK)
 	{
-		ensure(sys_mutex_destroy(ppu, es_handle->_dx_mes) == CELL_OK);    // Not checked on LLE
-		ensure(sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		ensure(lv2_syscall<sys_mutex_destroy>(ppu, es_handle->_dx_mes) == CELL_OK);    // Not checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd) == CELL_OK); // Not checked on LLE
 		return ret;
 	}
 
-	return sys_mutex_unlock(ppu, demuxerHandle->_dx_mhd);
+	return lv2_syscall<sys_mutex_unlock>(ppu, demuxerHandle->_dx_mhd);
 }
 
 error_code cellDmuxDisableEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
@@ -934,14 +946,14 @@ error_code cellDmuxDisableEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	if (const error_code ret = disable_es(ppu, *esHandle); ret != CELL_OK)
 	{
-		ensure(sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd) == CELL_OK); // Not checked on LLE
+		ensure(lv2_syscall<sys_mutex_unlock>(ppu, esHandle->dmux_handle->_dx_mhd) == CELL_OK); // Not checked on LLE
 		return ret;
 	}
 
@@ -952,7 +964,7 @@ error_code cellDmuxDisableEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 	esHandle->dmux_handle->enabled_es_num--;
 	*es_handles.rbegin() = vm::null;
 
-	return sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd);
+	return lv2_syscall<sys_mutex_unlock>(ppu, esHandle->dmux_handle->_dx_mhd);
 }
 
 error_code cellDmuxResetEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
@@ -973,14 +985,14 @@ error_code cellDmuxResetEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	const u32 dmux_status = esHandle->dmux_handle->dmux_state;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle->dmux_handle->_dx_mhd); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -990,14 +1002,14 @@ error_code cellDmuxResetEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 		return CELL_DMUX_ERROR_SEQ;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	if (const error_code ret = get_error(get_core_ops()->resetEs(ppu, esHandle->core_es_handle)); ret != CELL_OK)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 		return mutex_unlock_ret ? mutex_unlock_ret : ret;
 	}
 
@@ -1019,7 +1031,7 @@ error_code cellDmuxResetEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 	esHandle->au_queue.back = 0;
 	esHandle->au_queue.allocated_back = 0;
 
-	return sys_mutex_unlock(ppu, esHandle->_dx_mes);
+	return lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 }
 
 template <bool is_peek>
@@ -1030,7 +1042,7 @@ static error_code pop_au(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::c
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -1042,7 +1054,7 @@ static error_code pop_au(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::c
 
 	if (esHandle->au_queue.size <= 0)
 	{
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 		return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_EMPTY;
 	}
 
@@ -1064,7 +1076,7 @@ static error_code pop_au(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::c
 		esHandle->au_queue.size--;
 	}
 
-	return sys_mutex_unlock(ppu, esHandle->_dx_mes);
+	return lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 }
 
 error_code cellDmuxGetAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle, vm::cpptr<CellDmuxAuInfo> auInfo, vm::cpptr<void> auSpecificInfo)
@@ -1113,7 +1125,7 @@ error_code cellDmuxReleaseAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle->_dx_mes, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
@@ -1125,7 +1137,7 @@ error_code cellDmuxReleaseAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 	{
 		if (esHandle->error_count == 0u)
 		{
-			const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+			const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 			return mutex_unlock_ret ? mutex_unlock_ret : CELL_DMUX_ERROR_SEQ;
 		}
 
@@ -1167,14 +1179,14 @@ error_code cellDmuxReleaseAu(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 
 		esHandle->error_count++;
 
-		const error_code mutex_unlock_ret = sys_mutex_unlock(ppu, esHandle->_dx_mes);
+		const error_code mutex_unlock_ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 		return mutex_unlock_ret ? mutex_unlock_ret : ret;
 	}
 
 	esHandle->error_count = 0;
 	esHandle->error_mem_size = 0;
 
-	return sys_mutex_unlock(ppu, esHandle->_dx_mes);
+	return lv2_syscall<sys_mutex_unlock>(ppu, esHandle->_dx_mes);
 }
 
 error_code cellDmuxFlushEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
@@ -1195,14 +1207,14 @@ error_code cellDmuxFlushEs(ppu_thread& ppu, vm::ptr<DmuxEsContext> esHandle)
 		return CELL_DMUX_ERROR_ARG;
 	}
 
-	if (const error_code ret = sys_mutex_lock(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_lock>(ppu, esHandle->dmux_handle->_dx_mhd, 0); ret != CELL_OK)
 	{
 		return ret;
 	}
 
 	const u32 dmux_state = esHandle->dmux_handle->dmux_state;
 
-	if (const error_code ret = sys_mutex_unlock(ppu, esHandle->dmux_handle->_dx_mhd); ret != CELL_OK)
+	if (const error_code ret = lv2_syscall<sys_mutex_unlock>(ppu, esHandle->dmux_handle->_dx_mhd); ret != CELL_OK)
 	{
 		return ret;
 	}