Release v4.9: raw mouse HWND registration fix, Wine-only raw input hint

Author: d3nd3

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v4.9
+
+- Raw mouse: register raw input only with HWNDs owned by the game process (`GetWindowThreadProcessId` vs `GetCurrentProcessId`). Resolve the window via `GetGUIThreadInfo`, then `GetActiveWindow` / `GetForegroundWindow` only when they are local, plus `EnumThreadWindows` fallback—fixes `RegisterRawInputDevices` failing with error 87 (`ERROR_INVALID_PARAMETER`) when foreground belonged to another app or at startup. Cvar enable uses the same `raw_mouse_ensure_registered` path as the message pump; clearer log lines for invalid HWND and for error 87.
+- Raw mouse: the “Wine/X11 raw input” hint is shown only when actually running under Wine/Proton (`is_running_under_wine()`), not on native Windows failures.
+- Core: `is_running_under_wine()` implementation moved to `src/utils/util.cpp` with declaration in `hdr/util.h` (shared helper for updater and raw mouse).
+
 ## v4.8
 
 - Updater: refactored zip selection to strict priority order (`preferred_release_zip_names`, `pick_best_zip_url`) instead of scoring; native Windows prefers `release_windows.zip` then `release_windows_xp.zip` when the main zip is missing (fixes Windows 7 receiving wine_linux build). Wine detection hardened (validate `wine_get_version` return).

VERSION

@@ -1 +1 @@
-4.8
+4.9

hdr/util.h

@@ -136,4 +136,7 @@ size_t strlen_custom(const char *str);
 
 const char* get_nth_entry(const char* str, int n);
 
+/** True when running under Wine/Proton (ntdll wine_get_version). */
+bool is_running_under_wine();
+
 #endif // SOF_BUDDY_UTIL_H

hdr/version.h

@@ -7,4 +7,4 @@
     Increment version using: ./increment_version.sh
 */
 
-#define SOFBUDDY_VERSION "4.8"
+#define SOFBUDDY_VERSION "4.9"

src/core/update_command.cpp

@@ -81,19 +81,6 @@ bool is_regular_file(const char* path) {
     return attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY) == 0;
 }
 
-bool is_running_under_wine() {
-    HMODULE ntdll = GetModuleHandleA("ntdll.dll");
-    if (!ntdll) return false;
-    typedef const char* (*wine_get_version_fn)(void);
-    auto fn = reinterpret_cast<wine_get_version_fn>(GetProcAddress(ntdll, "wine_get_version"));
-    if (!fn) return false;
-    const char* ver = fn();
-    if (!ver || !ver[0]) return false;
-    for (const char* p = ver; *p; ++p)
-        if (std::isdigit(static_cast<unsigned char>(*p))) return true;
-    return false;
-}
-
 bool prefer_linux_wine_release_zip() {
 #if defined(SOFBUDDY_XP_BUILD)
     return false;

src/features/raw_mouse/raw_cvars.cpp

@@ -22,12 +22,12 @@ void raw_mouse_on_change(cvar_t *cvar)
             PrintOut(PRINT_BAD, "raw_mouse: Raw Input API not available; keeping legacy cursor mode\n");
             return;
         }
-        HWND hwnd = GetActiveWindow();
-        if (!hwnd) hwnd = GetForegroundWindow();
-        if (raw_mouse_register_input(hwnd, true)) {
+        raw_mouse_ensure_registered(nullptr, true);
+        if (raw_mouse_registered) {
             PrintOut(PRINT_DEV, "raw_mouse: Raw input is now ENABLED\n");
         } else {
-            PrintOut(PRINT_BAD, "raw_mouse: Raw input was requested but registration failed\n");
+            PrintOut(PRINT_BAD,
+                     "raw_mouse: Raw input was requested but registration failed\n");
         }
     } else {
         raw_mouse_unregister_input(true);

src/features/raw_mouse/raw_shared.cpp

@@ -70,7 +70,7 @@ void raw_mouse_accumulate_delta(LONG dx, LONG dy) {
 }
 
 static bool RawMouseHasForeground(HWND hwnd);
-void raw_mouse_ensure_registered(HWND hwnd_hint);
+void raw_mouse_ensure_registered(HWND hwnd_hint, bool log_register_attempts);
 
 void raw_mouse_process_raw_mouse() {
 #if !SOFBUDDY_RAWINPUT_API_AVAILABLE
@@ -80,7 +80,7 @@ void raw_mouse_process_raw_mouse() {
   if (raw_processed_this_frame) return;
   raw_processed_this_frame = true;
 
-  if (!raw_mouse_registered) raw_mouse_ensure_registered(nullptr);
+  if (!raw_mouse_registered) raw_mouse_ensure_registered(nullptr, false);
   if (raw_mouse_hwnd_target && !RawMouseHasForeground(raw_mouse_hwnd_target)) return;
 
   UINT size = 0;
@@ -141,20 +141,61 @@ void raw_mouse_process_raw_mouse() {
 #endif
 }
 
-static HWND RawMouseResolveTargetHwnd(HWND hwnd_hint) {
-  if (raw_mouse_hwnd_target && IsWindow(raw_mouse_hwnd_target)) {
+static bool RawMouseHwndIsOurProcess(HWND hwnd) {
+  if (!hwnd || !IsWindow(hwnd)) return false;
+  DWORD pid = 0;
+  GetWindowThreadProcessId(hwnd, &pid);
+  return pid == GetCurrentProcessId();
+}
+
+static BOOL CALLBACK RawMouseEnumThreadTopLevelProc(HWND hwnd, LPARAM lp) {
+  auto* out = reinterpret_cast<HWND*>(lp);
+  if (!IsWindowVisible(hwnd)) return TRUE;
+  if (GetParent(hwnd) != nullptr) return TRUE;
+  *out = hwnd;
+  return FALSE;
+}
+
+static HWND RawMouseFirstVisibleTopLevelOnCurrentThread() {
+  HWND found = nullptr;
+  EnumThreadWindows(GetCurrentThreadId(), RawMouseEnumThreadTopLevelProc,
+                    reinterpret_cast<LPARAM>(&found));
+  return found;
+}
+
+static HWND RawMouseResolveLocalWindow(HWND hwnd_hint) {
+  if (raw_mouse_hwnd_target && IsWindow(raw_mouse_hwnd_target) &&
+      RawMouseHwndIsOurProcess(raw_mouse_hwnd_target)) {
     return raw_mouse_hwnd_target;
   }
-
-  if (hwnd_hint && IsWindow(hwnd_hint)) {
+  if (hwnd_hint && IsWindow(hwnd_hint) && RawMouseHwndIsOurProcess(hwnd_hint)) {
     return hwnd_hint;
   }
 
-  HWND hwnd = GetActiveWindow();
-  if (!hwnd) {
-    hwnd = GetForegroundWindow();
+  GUITHREADINFO gti = {};
+  gti.cbSize = sizeof(GUITHREADINFO);
+  if (GetGUIThreadInfo(GetCurrentThreadId(), &gti)) {
+    HWND h = gti.hwndActive;
+    if (!h) h = gti.hwndFocus;
+    if (h && IsWindow(h) && RawMouseHwndIsOurProcess(h)) {
+      return h;
+    }
   }
-  return hwnd;
+
+  HWND aw = GetActiveWindow();
+  if (aw && RawMouseHwndIsOurProcess(aw)) return aw;
+
+  HWND fg = GetForegroundWindow();
+  if (fg && RawMouseHwndIsOurProcess(fg)) return fg;
+
+  HWND eth = RawMouseFirstVisibleTopLevelOnCurrentThread();
+  if (eth && RawMouseHwndIsOurProcess(eth)) return eth;
+
+  return nullptr;
+}
+
+static HWND RawMouseResolveTargetHwnd(HWND hwnd_hint) {
+  return RawMouseResolveLocalWindow(hwnd_hint);
 }
 
 static bool RawMouseHasForeground(HWND hwnd) {
@@ -189,20 +230,25 @@ static HWND RawMouseGetRoot(HWND hwnd) {
 #endif
 }
 
-void raw_mouse_ensure_registered(HWND hwnd_hint) {
+void raw_mouse_ensure_registered(HWND hwnd_hint, bool log_register_attempts) {
   if (!raw_mouse_is_enabled() || !raw_mouse_api_supported()) return;
   if (raw_mouse_hwnd_target && !IsWindow(raw_mouse_hwnd_target)) {
     raw_mouse_registered = false;
     raw_mouse_hwnd_target = nullptr;
   }
-  HWND hwnd = (hwnd_hint && IsWindow(hwnd_hint)) ? hwnd_hint : nullptr;
-  if (!hwnd && raw_mouse_hwnd_target) hwnd = raw_mouse_hwnd_target;
-  if (!hwnd) hwnd = GetActiveWindow();
-  if (!hwnd) hwnd = GetForegroundWindow();
-  if (!hwnd) return;
+  HWND hwnd = RawMouseResolveLocalWindow(
+      (hwnd_hint && IsWindow(hwnd_hint)) ? hwnd_hint : nullptr);
+  if (!hwnd) {
+    if (log_register_attempts) {
+      PrintOut(PRINT_BAD,
+               "raw_mouse: No game window for raw input (focus the game window "
+               "and try again)\n");
+    }
+    return;
+  }
   HWND root = RawMouseGetRoot(hwnd);
   if (raw_mouse_registered && raw_mouse_hwnd_target && IsWindow(raw_mouse_hwnd_target) && RawMouseGetRoot(raw_mouse_hwnd_target) == root) return;
-  raw_mouse_register_input(root, false);
+  raw_mouse_register_input(root, log_register_attempts);
 }
 
 void raw_mouse_release_cursor_clip() {
@@ -285,6 +331,17 @@ bool raw_mouse_register_input(HWND hwnd, bool log_result) {
     raw_mouse_release_cursor_clip();
     return false;
   }
+  if (!RawMouseHwndIsOurProcess(hwnd)) {
+    if (log_result) {
+      PrintOut(PRINT_BAD,
+               "raw_mouse: Window is not owned by this process (cannot "
+               "register raw input)\n");
+    }
+    raw_mouse_registered = false;
+    raw_mouse_hwnd_target = nullptr;
+    raw_mouse_release_cursor_clip();
+    return false;
+  }
 
   RAWINPUTDEVICE rid;
   rid.usUsagePage = 0x01;
@@ -297,20 +354,22 @@ bool raw_mouse_register_input(HWND hwnd, bool log_result) {
       DWORD error = GetLastError();
       PrintOut(PRINT_BAD,
                "raw_mouse: Failed to register raw input (error %d)\n", error);
-      PrintOut(PRINT_BAD,
-               "raw_mouse: On X11/Wine, raw input may not be supported\n");
+      if (error == ERROR_INVALID_PARAMETER) {
+        PrintOut(PRINT_BAD,
+                 "raw_mouse: Usually an invalid HWND or wrong thread vs window "
+                 "owner; focus the game and retry\n");
+      } else if (is_running_under_wine()) {
+        PrintOut(PRINT_BAD,
+                 "raw_mouse: Under Wine/X11, raw input may be limited; try a "
+                 "newer Proton or native Windows if problems persist\n");
+      }
     }
     raw_mouse_registered = false;
     raw_mouse_hwnd_target = nullptr;
     raw_mouse_release_cursor_clip();
     return false;
   }
 
-  if (log_result) {
-    PrintOut(PRINT_DEV,
-             "raw_mouse: Successfully registered raw input device\n");
-  }
-
   raw_mouse_registered = true;
   raw_mouse_hwnd_target = hwnd;
   raw_mouse_refresh_cursor_clip(hwnd);

src/features/raw_mouse/shared.h

@@ -47,7 +47,8 @@ void raw_mouse_reset_deltas();
 void raw_mouse_consume_deltas();
 void raw_mouse_update_center(int x, int y);
 void raw_mouse_accumulate_delta(LONG dx, LONG dy);
-void raw_mouse_ensure_registered(HWND hwnd_hint);
+void raw_mouse_ensure_registered(HWND hwnd_hint,
+                                 bool log_register_attempts = false);
 void raw_mouse_refresh_cursor_clip(HWND hwnd_hint);
 void raw_mouse_release_cursor_clip();
 bool raw_mouse_register_input(HWND hwnd, bool log_result);

src/utils/util.cpp

@@ -4,6 +4,7 @@
 #include <stdarg.h>
 #include <string.h>
 #include <stdlib.h>
+#include <cctype>
 
 #include "sof_compat.h"
 #include "util.h"
@@ -426,4 +427,22 @@ void* rvaToAbsSoFPlus(void* rva) {
 #else
     return nullptr;
 #endif
+}
+
+bool is_running_under_wine() {
+#ifdef _WIN32
+  HMODULE ntdll = GetModuleHandleA("ntdll.dll");
+  if (!ntdll) return false;
+  typedef const char* (*wine_get_version_fn)(void);
+  auto fn = reinterpret_cast<wine_get_version_fn>(
+      GetProcAddress(ntdll, "wine_get_version"));
+  if (!fn) return false;
+  const char* ver = fn();
+  if (!ver || !ver[0]) return false;
+  for (const char* p = ver; *p; ++p)
+    if (std::isdigit(static_cast<unsigned char>(*p))) return true;
+  return false;
+#else
+  return false;
+#endif
 }