/* * uur-hook — input reroute for NetEase UU Remote under Wine. * * Loaded into GameViewerServer.exe through the wevtapi.dll preload chain * (see wevtapi.c). At PROCESS_ATTACH it rewrites the SendInput entries of * every loaded module's import table to point at hook_SendInput, which * forwards each input record over an authenticated loopback socket to the * uur host daemon. The daemon injects the record onto the real desktop * (XTest on X11, RemoteDesktop portal on Wayland). * * Failure policy: if the socket is unavailable, hook_SendInput falls back * to the original SendInput so the client keeps working with input * contained inside the managed Wine prefix. * * Wire format mirrors src/protocol.rs: 16-byte record * u32 kind (1 keyboard, 2 mouse) u16 code u16 state i32 a i32 b */ #define WIN32_LEAN_AND_MEAN #ifndef _WIN32_WINNT #define _WIN32_WINNT 0x0601 #endif #include #include #include #include #include #include #include #include #include #include "cursor-overlay.h" #include "frame-protocol.h" #define UUR_MAGIC 0x50495555u #define UUR_VERSION 1u #define UUR_RECORD_HELLO 1u #define UUR_RECORD_MOUSE 2u #define UUR_RECORD_KEYBOARD 3u static UINT(WINAPI *original_send_input)(UINT, LPINPUT, int); static HRESULT(WINAPI *original_create_dxgi_factory1)(REFIID, void **); static FARPROC(WINAPI *original_get_proc_address)(HMODULE, LPCSTR); static HMODULE hook_module; static int(WINAPI *original_get_system_metrics)(int); static BOOL(WINAPI *original_get_monitor_info_a)(HMONITOR, LPMONITORINFO); static BOOL(WINAPI *original_get_monitor_info_w)(HMONITOR, LPMONITORINFO); static BOOL(WINAPI *original_enum_display_settings_a)(LPCSTR, DWORD, LPDEVMODEA); static BOOL(WINAPI *original_enum_display_settings_w)(LPCWSTR, DWORD, LPDEVMODEW); static BOOL(WINAPI *original_enum_display_settings_ex_w)(LPCWSTR, DWORD, LPDEVMODEW, DWORD); static int(WINAPI *original_get_device_caps)(HDC, int); static LONG(WINAPI *original_query_display_config)(UINT, UINT *, DISPLAYCONFIG_PATH_INFO *, UINT *, DISPLAYCONFIG_MODE_INFO *, DISPLAYCONFIG_TOPOLOGY_ID *); UINT WINAPI hook_send_input(UINT count, LPINPUT inputs, int size); static int WINAPI hook_get_system_metrics(int); static BOOL WINAPI hook_get_monitor_info_a(HMONITOR, LPMONITORINFO); static BOOL WINAPI hook_get_monitor_info_w(HMONITOR, LPMONITORINFO); static BOOL WINAPI hook_enum_display_settings_a(LPCSTR, DWORD, LPDEVMODEA); static BOOL WINAPI hook_enum_display_settings_w(LPCWSTR, DWORD, LPDEVMODEW); static BOOL WINAPI hook_enum_display_settings_ex_w(LPCWSTR, DWORD, LPDEVMODEW, DWORD); static int WINAPI hook_get_device_caps(HDC, int); static LONG WINAPI hook_query_display_config(UINT, UINT *, DISPLAYCONFIG_PATH_INFO *, UINT *, DISPLAYCONFIG_MODE_INFO *, DISPLAYCONFIG_TOPOLOGY_ID *); static volatile LONG dxgi_factories_patched = 0; static volatile LONG dxgi_adapters_patched = 0; static volatile LONG dxgi_outputs_patched = 0; static volatile LONG dxgi_duplicate_calls = 0; static volatile LONG dxgi_dup_acquires = 0; static volatile LONG dxgi_dup_frames = 0; static volatile LONG frame_crop_debug_count = 0; static volatile LONG offorigin_crop_debug_count = 0; static void hook_log(const char *text); static HRESULT __attribute__((unused))(STDMETHODCALLTYPE *original_dxgi_acquire_next_frame)( void *duplication, UINT timeout, void *frame_info, void **resource) = NULL; /* referenced by patch_dxgi_duplication below */ /* ---- DXGI duplication disable ----------------------------------------- */ /* The client's primary capture is IDXGIOutput1::DuplicateOutput. Wine's * implementation succeeds but only delivers the empty XWayland desktop * (black video). Forcing DuplicateOutput to fail makes the client fall * back to its GDI capture path, which the frame feed below supplies. */ static const GUID uur_iid_idxgioutput1 = { 0x00cddea8, 0x939b, 0x4b83, {0xa3, 0x40, 0xa6, 0x85, 0x22, 0x66, 0x66, 0xcc} }; /* Minimal IDXGIOutput1 shape: mingw's C-mode dxgi.h lacks it. The * vtable is IUnknown(3) + IDXGIOutput(12) methods, then DuplicateOutput. */ typedef struct uur_idxgioutput1_vtbl { void *methods[15]; HRESULT(STDMETHODCALLTYPE *DuplicateOutput)(void *, IUnknown *); } uur_idxgioutput1_vtbl; typedef struct uur_idxgioutput1 { uur_idxgioutput1_vtbl *lpVtbl; } uur_idxgioutput1; #ifndef DXGI_ERROR_UNSUPPORTED #define DXGI_ERROR_UNSUPPORTED ((HRESULT)0x887A0004) #endif static HRESULT(STDMETHODCALLTYPE *original_dxgi_enum_adapters1)( IDXGIFactory1 *factory, UINT index, IDXGIAdapter1 **adapter) = NULL; static HRESULT(STDMETHODCALLTYPE *original_dxgi_enum_outputs)( IDXGIAdapter *adapter, UINT index, IDXGIOutput **output) = NULL; static HRESULT STDMETHODCALLTYPE hook_dxgi_enum_adapters1( IDXGIFactory1 *factory, UINT index, IDXGIAdapter1 **adapter); static HRESULT STDMETHODCALLTYPE hook_dxgi_enum_outputs( IDXGIAdapter *adapter, UINT index, IDXGIOutput **output); static HRESULT WINAPI hook_dxgi_duplicate_output(uur_idxgioutput1 *output, IUnknown *device); static int patch_vtable_slot(void **slot, void *hook, void **original) { DWORD old_protect = 0; if (*slot == hook) return 1; if (original != NULL) *original = *slot; if (!VirtualProtect(slot, sizeof(void *), PAGE_READWRITE, &old_protect)) return 0; *slot = hook; VirtualProtect(slot, sizeof(void *), old_protect, &old_protect); return 1; } static HRESULT(STDMETHODCALLTYPE *original_dxgi_enum_adapters)( IDXGIFactory *factory, UINT index, IDXGIAdapter **adapter) = NULL; static void patch_dxgi_adapter(IDXGIAdapter *adapter); static void patch_dxgi_output(IDXGIOutput *output) { uur_idxgioutput1 *output1 = NULL; if (output == NULL || output->lpVtbl == NULL) return; if (output->lpVtbl->QueryInterface( output, &uur_iid_idxgioutput1, (void **)&output1) != S_OK) return; if (output1 != NULL && output1->lpVtbl != NULL) { if (patch_vtable_slot((void **)&output1->lpVtbl->DuplicateOutput, (void *)hook_dxgi_duplicate_output, NULL)) { InterlockedIncrement(&dxgi_outputs_patched); } /* release through the known-good base interface */ output->lpVtbl->Release(output); } } static HRESULT STDMETHODCALLTYPE hook_dxgi_enum_adapters( IDXGIFactory *factory, UINT index, IDXGIAdapter **adapter) { HRESULT result = original_dxgi_enum_adapters ? original_dxgi_enum_adapters(factory, index, adapter) : DXGI_ERROR_INVALID_CALL; if (result == S_OK && adapter != NULL && *adapter != NULL) patch_dxgi_adapter(*adapter); return result; } static void patch_dxgi_adapter(IDXGIAdapter *adapter) { if (adapter == NULL || adapter->lpVtbl == NULL) return; if (patch_vtable_slot((void **)&adapter->lpVtbl->EnumOutputs, (void *)hook_dxgi_enum_outputs, (void **)&original_dxgi_enum_outputs)) { InterlockedIncrement(&dxgi_adapters_patched); } } static HRESULT STDMETHODCALLTYPE hook_dxgi_enum_adapters1( IDXGIFactory1 *factory, UINT index, IDXGIAdapter1 **adapter) { HRESULT result = original_dxgi_enum_adapters1 ? original_dxgi_enum_adapters1(factory, index, adapter) : DXGI_ERROR_INVALID_CALL; if (result == S_OK && adapter != NULL && *adapter != NULL) patch_dxgi_adapter((IDXGIAdapter *)*adapter); return result; } static HRESULT STDMETHODCALLTYPE hook_dxgi_enum_outputs( IDXGIAdapter *adapter, UINT index, IDXGIOutput **output) { HRESULT result = original_dxgi_enum_outputs ? original_dxgi_enum_outputs(adapter, index, output) : DXGI_ERROR_INVALID_CALL; if (result == S_OK && output != NULL && *output != NULL) patch_dxgi_output(*output); return result; } static HRESULT WINAPI hook_dxgi_duplicate_output(uur_idxgioutput1 *output, IUnknown *device) { (void)output; (void)device; InterlockedIncrement(&dxgi_duplicate_calls); /* Wine's duplication succeeds but delivers the empty XWayland desktop. * Failing it sends the client to its GDI capture path. */ return DXGI_ERROR_UNSUPPORTED; } static void patch_dxgi_factory(IDXGIFactory1 *factory) { if (factory == NULL || factory->lpVtbl == NULL) return; patch_vtable_slot((void **)&factory->lpVtbl->EnumAdapters1, (void *)hook_dxgi_enum_adapters1, (void **)&original_dxgi_enum_adapters1); patch_vtable_slot((void **)&factory->lpVtbl->EnumAdapters, (void *)hook_dxgi_enum_adapters, (void **)&original_dxgi_enum_adapters); } static HRESULT WINAPI hook_create_dxgi_factory1(REFIID interface_id, void **factory) { HRESULT result = original_create_dxgi_factory1 != NULL ? original_create_dxgi_factory1(interface_id, factory) : DXGI_ERROR_INVALID_CALL; if (result == S_OK && factory != NULL && *factory != NULL) { IDXGIFactory1 *f = (IDXGIFactory1 *)*factory; if (f->lpVtbl != NULL) { patch_dxgi_factory(f); InterlockedIncrement(&dxgi_factories_patched); } } return result; } static BOOL(WINAPI *original_bit_blt)(HDC, int, int, int, int, HDC, int, int, DWORD); static BOOL(WINAPI *original_stretch_blt)(HDC, int, int, int, int, HDC, int, int, int, int, DWORD); static volatile LONG capture_calls = 0; static volatile LONG capture_rendered = 0; static volatile LONG capture_fallbacks = 0; static volatile LONG iat_hooks_installed = 0; static SOCKET hook_socket = INVALID_SOCKET; static volatile LONG hook_busy = 0; /* ---- capture frame feed (docs/capture-protocol.md) -------------------- */ static void *frame_map = NULL; static HANDLE frame_map_handle = NULL; static uint32_t frame_width; static uint32_t frame_height; static uint32_t frame_stride; static uint32_t frame_flags; static uint32_t frame_monitor_count; static uint64_t frame_slot_bytes; static unsigned char *frame_snapshot; static size_t frame_snapshot_capacity; static size_t frame_map_size; static BY_HANDLE_FILE_INFORMATION frame_identity; static ULONGLONG frame_checked_at; static SRWLOCK frame_lock = SRWLOCK_INIT; static int capture_geometry_enabled; static char *read_ini_value(const char *path, const char *key); static int resolve_frame_path(WCHAR *path, int capacity) { DWORD count = GetEnvironmentVariableW(L"UUR_FRAME_PATH_WIN", path, (DWORD)capacity); if (count > 0 && count < (DWORD)capacity) return 1; char *utf8 = read_ini_value("C:\\uur-bridge.ini", "frame_path"); if (utf8 == NULL) return 0; int converted = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8, -1, path, capacity); free(utf8); return converted > 0; } static uint32_t load_u32(const unsigned char *p) { return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24); } static uint64_t load_u64(const unsigned char *p) { return load_u32(p) | ((uint64_t)load_u32(p + 4) << 32); } static void clear_frame_map(void) { if (frame_map != NULL) UnmapViewOfFile(frame_map); if (frame_map_handle != NULL) CloseHandle(frame_map_handle); frame_map = NULL; frame_map_handle = NULL; frame_map_size = 0; frame_flags = 0; frame_monitor_count = 0; } /* Producers publish immutable geometry via atomic replacement. Re-check the * file identity periodically, including after an ungraceful helper restart. */ static int ensure_frame_map(void) { HANDLE file; void *view; const unsigned char *header; LARGE_INTEGER size; BY_HANDLE_FILE_INFORMATION identity; WCHAR path[32768]; ULONGLONG now = GetTickCount64(); if (frame_map != NULL && now - frame_checked_at < 250 && load_u64((const unsigned char *)frame_map + 24) != 0) return 1; if (!resolve_frame_path(path, (int)(sizeof(path) / sizeof(path[0])))) return 0; file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL); if (file == INVALID_HANDLE_VALUE) { clear_frame_map(); return 0; } if (!GetFileInformationByHandle(file, &identity) || !GetFileSizeEx(file, &size) || size.QuadPart < UURF_HEADER_BYTES || (uint64_t)size.QuadPart > UURF_HEADER_BYTES + UURF_SLOT_COUNT * (8ull + 256ull * 1024 * 1024)) { CloseHandle(file); clear_frame_map(); return 0; } frame_checked_at = now; if (frame_map != NULL && identity.dwVolumeSerialNumber == frame_identity.dwVolumeSerialNumber && identity.nFileIndexHigh == frame_identity.nFileIndexHigh && identity.nFileIndexLow == frame_identity.nFileIndexLow && (uint64_t)size.QuadPart == frame_map_size) { CloseHandle(file); return 1; } clear_frame_map(); frame_map_handle = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL); CloseHandle(file); if (frame_map_handle == NULL) return 0; view = MapViewOfFile(frame_map_handle, FILE_MAP_READ, 0, 0, 0); if (view == NULL) { clear_frame_map(); return 0; } header = (const unsigned char *)view; if (load_u32(header) != UURF_MAGIC || load_u32(header + 4) != UURF_VERSION || load_u32(header + 20) != 1u) { UnmapViewOfFile(view); CloseHandle(frame_map_handle); frame_map_handle = NULL; return 0; } frame_width = load_u32(header + 8); frame_height = load_u32(header + 12); frame_stride = load_u32(header + 16); frame_flags = load_u32(header + 32); frame_monitor_count = load_u32(header + 36); frame_slot_bytes = 8ull + (uint64_t)frame_stride * frame_height; uint64_t expected = UURF_HEADER_BYTES + UURF_SLOT_COUNT * frame_slot_bytes; if (frame_width == 0 || frame_height == 0 || frame_width > 16384 || frame_height > 16384 || frame_monitor_count == 0 || frame_monitor_count > UURF_MAX_MONITORS || frame_stride != frame_width * 4 || (uint64_t)frame_stride * frame_height > 256ull * 1024 * 1024 || expected > (uint64_t)size.QuadPart) { UnmapViewOfFile(view); CloseHandle(frame_map_handle); frame_map_handle = NULL; return 0; } for (uint32_t i = 0; i < frame_monitor_count; ++i) { const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES; uint32_t x = load_u32(item + 16), y = load_u32(item + 20); uint32_t w = load_u32(item + 24), h = load_u32(item + 28); if (load_u32(item + 8) == 0 || load_u32(item + 12) == 0 || w == 0 || h == 0 || x >= frame_width || y >= frame_height || w > frame_width - x || h > frame_height - y) { UnmapViewOfFile(view); CloseHandle(frame_map_handle); frame_map_handle = NULL; return 0; } } frame_map_size = (size_t)size.QuadPart; frame_map = view; frame_identity = identity; return 1; } static int64_t abs_i64(int64_t value) { return value < 0 ? -value : value; } /* Compare relative extents, centers and aspect ratio, so a uniform XWayland * scale cannot make a larger adjacent monitor look like the smaller one. */ static const unsigned char *find_frame_monitor(const unsigned char *header, const RECT *target, int screen_left, int screen_top, int screen_width, int screen_height) { const unsigned char *best = NULL; int64_t min_x = INT64_MAX, min_y = INT64_MAX; int64_t max_x = INT64_MIN, max_y = INT64_MIN; int64_t target_width = (int64_t)target->right - target->left; int64_t target_height = (int64_t)target->bottom - target->top; int64_t target_center_x = (int64_t)target->left + target->right; int64_t target_center_y = (int64_t)target->top + target->bottom; int64_t best_score = INT64_MAX; if (screen_width <= 0 || screen_height <= 0 || target_width <= 0 || target_height <= 0 || frame_monitor_count == 0 || frame_monitor_count != (uint32_t)GetSystemMetrics(SM_CMONITORS)) return NULL; for (uint32_t i = 0; i < frame_monitor_count; ++i) { const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES; int64_t x = (int32_t)load_u32(item); int64_t y = (int32_t)load_u32(item + 4); int64_t width = load_u32(item + 8); int64_t height = load_u32(item + 12); if (x < min_x) min_x = x; if (y < min_y) min_y = y; if (x + width > max_x) max_x = x + width; if (y + height > max_y) max_y = y + height; } if (max_x <= min_x || max_y <= min_y) return NULL; int64_t target_x = ((target_center_x - 2ll * screen_left) * 1000000) / (2ll * screen_width); int64_t target_y = ((target_center_y - 2ll * screen_top) * 1000000) / (2ll * screen_height); for (uint32_t i = 0; i < frame_monitor_count; ++i) { const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES; int64_t x = (int32_t)load_u32(item); int64_t y = (int32_t)load_u32(item + 4); int64_t width = load_u32(item + 8); int64_t height = load_u32(item + 12); int64_t center_x = ((2 * x + width - 2 * min_x) * 1000000) / (2 * (max_x - min_x)); int64_t center_y = ((2 * y + height - 2 * min_y) * 1000000) / (2 * (max_y - min_y)); int64_t size_error = abs_i64(target_width * 1000000 / screen_width - width * 1000000 / (max_x - min_x)) + abs_i64(target_height * 1000000 / screen_height - height * 1000000 / (max_y - min_y)); int64_t aspect_left = target_width * height; int64_t aspect_right = target_height * width; int64_t aspect_error = abs_i64(aspect_left - aspect_right) * 1000000 / (aspect_left > aspect_right ? aspect_left : aspect_right); int64_t position_error = abs_i64(target_x - center_x) + abs_i64(target_y - center_y); int64_t score = size_error * 2 + position_error * 4 + aspect_error; if (score < best_score) { best_score = score; best = item; } } return best; } typedef struct uur_frame_monitor { int32_t logical_x; int32_t logical_y; uint32_t logical_width; uint32_t logical_height; uint32_t frame_x; uint32_t frame_y; uint32_t frame_width; uint32_t frame_height; uint32_t capture_width; uint32_t capture_height; } uur_frame_monitor; /* Copy monitor metadata while holding the same lock used to remap the shared * frame. The primary monitor remains at (0,0); other monitors use their * captured stream's real pixel dimensions rather than XWayland's scaled * monitor rectangles. */ static int copy_frame_monitors(const RECT *target, uur_frame_monitor *items, uint32_t *count, uint32_t *primary_index, uint32_t *target_index) { int result = 0; if (!capture_geometry_enabled) return 0; AcquireSRWLockExclusive(&frame_lock); if (!ensure_frame_map()) goto done; if ((frame_flags & UURF_FLAG_COMPOSITE) == 0) goto done; const unsigned char *header = (const unsigned char *)frame_map; int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN); int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN); int screen_width = GetSystemMetrics(SM_CXVIRTUALSCREEN); int screen_height = GetSystemMetrics(SM_CYVIRTUALSCREEN); if (screen_width < 1) screen_width = (int)frame_width; if (screen_height < 1) screen_height = (int)frame_height; POINT origin = {0, 0}; HMONITOR primary = MonitorFromPoint(origin, MONITOR_DEFAULTTOPRIMARY); MONITORINFO primary_info; ZeroMemory(&primary_info, sizeof(primary_info)); primary_info.cbSize = sizeof(primary_info); if (primary == NULL || !GetMonitorInfoA(primary, &primary_info)) goto done; const unsigned char *primary_layout = find_frame_monitor( header, &primary_info.rcMonitor, screen_left, screen_top, screen_width, screen_height); if (primary_layout == NULL) goto done; const unsigned char *selected_layout = target != NULL ? find_frame_monitor(header, target, screen_left, screen_top, screen_width, screen_height) : NULL; uint32_t total = frame_monitor_count; if (total == 0 || total > UURF_MAX_MONITORS) goto done; uint32_t primary_i = (uint32_t)(primary_layout - (header + UURF_BASE_HEADER_BYTES)) / UURF_MONITOR_BYTES; uint32_t target_i = selected_layout != NULL ? (uint32_t)(selected_layout - (header + UURF_BASE_HEADER_BYTES)) / UURF_MONITOR_BYTES : UINT32_MAX; for (uint32_t i = 0; i < total; ++i) { const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES; items[i].logical_x = (int32_t)load_u32(item); items[i].logical_y = (int32_t)load_u32(item + 4); items[i].logical_width = load_u32(item + 8); items[i].logical_height = load_u32(item + 12); items[i].frame_x = load_u32(item + 16); items[i].frame_y = load_u32(item + 20); items[i].frame_width = load_u32(item + 24); items[i].frame_height = load_u32(item + 28); items[i].capture_width = load_u32(item + 32); items[i].capture_height = load_u32(item + 36); if (items[i].capture_width == 0 || items[i].capture_height == 0) { items[i].capture_width = items[i].frame_width; items[i].capture_height = items[i].frame_height; } } if (primary_i >= total || (target_i != UINT32_MAX && target_i >= total)) goto done; *count = total; *primary_index = primary_i; if (target_index != NULL) *target_index = target_i; result = 1; done: ReleaseSRWLockExclusive(&frame_lock); return result; } static int frame_monitor_rect(const uur_frame_monitor *items, uint32_t primary_index, uint32_t index, RECT *rect) { if (items == NULL || rect == NULL || index >= UURF_MAX_MONITORS || primary_index >= UURF_MAX_MONITORS || items[index].frame_width == 0 || items[index].frame_height == 0) return 0; int64_t left = (int64_t)items[index].frame_x - items[primary_index].frame_x; int64_t top = (int64_t)items[index].frame_y - items[primary_index].frame_y; int64_t right = left + items[index].frame_width; int64_t bottom = top + items[index].frame_height; if (left < LONG_MIN || top < LONG_MIN || right > LONG_MAX || bottom > LONG_MAX) return 0; rect->left = (LONG)left; rect->top = (LONG)top; rect->right = (LONG)right; rect->bottom = (LONG)bottom; return 1; } static LONG scale_monitor_offset(LONG value, LONG old_size, LONG new_size) { if (old_size <= 0) return 0; return (LONG)((int64_t)value * new_size / old_size); } static void apply_monitor_layout(LPMONITORINFO info, const uur_frame_monitor *items, uint32_t primary_index, uint32_t index) { RECT adjusted; if (info == NULL || !frame_monitor_rect(items, primary_index, index, &adjusted)) return; RECT old_monitor = info->rcMonitor; RECT old_work = info->rcWork; LONG old_width = old_monitor.right - old_monitor.left; LONG old_height = old_monitor.bottom - old_monitor.top; LONG new_width = adjusted.right - adjusted.left; LONG new_height = adjusted.bottom - adjusted.top; info->rcMonitor = adjusted; info->rcWork.left = adjusted.left + scale_monitor_offset(old_work.left - old_monitor.left, old_width, new_width); info->rcWork.right = adjusted.left + scale_monitor_offset(old_work.right - old_monitor.left, old_width, new_width); info->rcWork.top = adjusted.top + scale_monitor_offset(old_work.top - old_monitor.top, old_height, new_height); info->rcWork.bottom = adjusted.top + scale_monitor_offset(old_work.bottom - old_monitor.top, old_height, new_height); } static int copy_layout_for_monitor_rect(const RECT *target, uur_frame_monitor *items, uint32_t *count, uint32_t *primary_index, uint32_t *target_index) { return copy_frame_monitors(target, items, count, primary_index, target_index); } static void remap_devmode(DEVMODEW *mode) { if (mode == NULL || (mode->dmFields & (DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT)) != (DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT) || mode->dmPelsWidth == 0 || mode->dmPelsHeight == 0) return; RECT old_rect = {mode->dmPosition.x, mode->dmPosition.y, mode->dmPosition.x + (LONG)mode->dmPelsWidth, mode->dmPosition.y + (LONG)mode->dmPelsHeight}; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX; if (!copy_layout_for_monitor_rect(&old_rect, items, &count, &primary_index, &target_index) || target_index >= count) return; RECT adjusted; if (!frame_monitor_rect(items, primary_index, target_index, &adjusted)) return; mode->dmPosition.x = adjusted.left; mode->dmPosition.y = adjusted.top; mode->dmPelsWidth = items[target_index].frame_width; mode->dmPelsHeight = items[target_index].frame_height; mode->dmFields |= DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT; } static int WINAPI hook_get_system_metrics(int index) { int fallback = original_get_system_metrics != NULL ? original_get_system_metrics(index) : GetSystemMetrics(index); if (index != SM_CXSCREEN && index != SM_CYSCREEN && index != SM_XVIRTUALSCREEN && index != SM_YVIRTUALSCREEN && index != SM_CXVIRTUALSCREEN && index != SM_CYVIRTUALSCREEN) return fallback; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0; if (!copy_frame_monitors(NULL, items, &count, &primary_index, NULL)) return fallback; if (index == SM_CXSCREEN) return (int)items[primary_index].frame_width; if (index == SM_CYSCREEN) return (int)items[primary_index].frame_height; int64_t min_x = INT64_MAX, min_y = INT64_MAX; int64_t max_x = INT64_MIN, max_y = INT64_MIN; for (uint32_t i = 0; i < count; ++i) { RECT rect; if (!frame_monitor_rect(items, primary_index, i, &rect)) continue; if (rect.left < min_x) min_x = rect.left; if (rect.top < min_y) min_y = rect.top; if (rect.right > max_x) max_x = rect.right; if (rect.bottom > max_y) max_y = rect.bottom; } if (min_x == INT64_MAX || min_y == INT64_MAX || max_x <= min_x || max_y <= min_y || max_x - min_x > INT_MAX || max_y - min_y > INT_MAX) return fallback; switch (index) { case SM_XVIRTUALSCREEN: return (int)min_x; case SM_YVIRTUALSCREEN: return (int)min_y; case SM_CXVIRTUALSCREEN: return (int)(max_x - min_x); case SM_CYVIRTUALSCREEN: return (int)(max_y - min_y); default: return fallback; } } static BOOL WINAPI hook_get_monitor_info_a(HMONITOR monitor, LPMONITORINFO info) { BOOL result = original_get_monitor_info_a != NULL ? original_get_monitor_info_a(monitor, info) : GetMonitorInfoA(monitor, info); if (!result || info == NULL || info->cbSize < sizeof(MONITORINFO)) return result; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX; if (copy_layout_for_monitor_rect(&info->rcMonitor, items, &count, &primary_index, &target_index) && target_index < count) apply_monitor_layout(info, items, primary_index, target_index); return result; } static BOOL WINAPI hook_get_monitor_info_w(HMONITOR monitor, LPMONITORINFO info) { BOOL result = original_get_monitor_info_w != NULL ? original_get_monitor_info_w(monitor, info) : GetMonitorInfoW(monitor, info); if (!result || info == NULL || info->cbSize < sizeof(MONITORINFO)) return result; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX; if (copy_layout_for_monitor_rect(&info->rcMonitor, items, &count, &primary_index, &target_index) && target_index < count) apply_monitor_layout(info, items, primary_index, target_index); return result; } static BOOL WINAPI hook_enum_display_settings_w(LPCWSTR device, DWORD mode_num, LPDEVMODEW mode) { BOOL result = original_enum_display_settings_w != NULL ? original_enum_display_settings_w(device, mode_num, mode) : FALSE; if (result && mode_num == ENUM_CURRENT_SETTINGS) remap_devmode(mode); return result; } static BOOL WINAPI hook_enum_display_settings_ex_w(LPCWSTR device, DWORD mode_num, LPDEVMODEW mode, DWORD flags) { BOOL result = original_enum_display_settings_ex_w != NULL ? original_enum_display_settings_ex_w(device, mode_num, mode, flags) : FALSE; if (result && mode_num == ENUM_CURRENT_SETTINGS) remap_devmode(mode); return result; } static BOOL WINAPI hook_enum_display_settings_a(LPCSTR device, DWORD mode_num, LPDEVMODEA mode) { BOOL result = original_enum_display_settings_a != NULL ? original_enum_display_settings_a(device, mode_num, mode) : FALSE; if (!result || mode_num != ENUM_CURRENT_SETTINGS || mode == NULL || (mode->dmFields & (DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT)) != (DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT) || mode->dmPelsWidth == 0 || mode->dmPelsHeight == 0) return result; RECT old_rect = {mode->dmPosition.x, mode->dmPosition.y, mode->dmPosition.x + (LONG)mode->dmPelsWidth, mode->dmPosition.y + (LONG)mode->dmPelsHeight}; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX; if (!copy_layout_for_monitor_rect(&old_rect, items, &count, &primary_index, &target_index) || target_index >= count) return result; RECT adjusted; if (!frame_monitor_rect(items, primary_index, target_index, &adjusted)) return result; mode->dmPosition.x = adjusted.left; mode->dmPosition.y = adjusted.top; mode->dmPelsWidth = items[target_index].frame_width; mode->dmPelsHeight = items[target_index].frame_height; mode->dmFields |= DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT; return result; } static int WINAPI hook_get_device_caps(HDC dc, int index) { int result = original_get_device_caps != NULL ? original_get_device_caps(dc, index) : GetDeviceCaps(dc, index); if ((index != HORZRES && index != VERTRES) || dc == NULL || original_get_device_caps == NULL || original_get_device_caps(dc, TECHNOLOGY) != DT_RASDISPLAY) return result; POINT origin; if (!GetDCOrgEx(dc, &origin)) return result; int width = original_get_device_caps(dc, HORZRES); int height = original_get_device_caps(dc, VERTRES); if (width <= 0 || height <= 0) return result; RECT old_rect = {origin.x, origin.y, origin.x + width, origin.y + height}; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX; if (!copy_layout_for_monitor_rect(&old_rect, items, &count, &primary_index, &target_index) || target_index >= count) return result; return index == HORZRES ? (int)items[target_index].frame_width : (int)items[target_index].frame_height; } static LONG WINAPI hook_query_display_config( UINT flags, UINT *path_count, DISPLAYCONFIG_PATH_INFO *paths, UINT *mode_count, DISPLAYCONFIG_MODE_INFO *modes, DISPLAYCONFIG_TOPOLOGY_ID *topology) { LONG result = original_query_display_config != NULL ? original_query_display_config(flags, path_count, paths, mode_count, modes, topology) : ERROR_NOT_SUPPORTED; if (result != ERROR_SUCCESS || path_count == NULL || mode_count == NULL || paths == NULL || modes == NULL) return result; for (UINT i = 0; i < *path_count; ++i) { UINT source_index = paths[i].sourceInfo.modeInfoIdx; if (source_index >= *mode_count || modes[source_index].infoType != DISPLAYCONFIG_MODE_INFO_TYPE_SOURCE) continue; DISPLAYCONFIG_SOURCE_MODE *source = &modes[source_index].sourceMode; RECT old_rect = {source->position.x, source->position.y, source->position.x + (LONG)source->width, source->position.y + (LONG)source->height}; uur_frame_monitor items[UURF_MAX_MONITORS]; uint32_t count = 0, primary_index = 0, target_index = UINT32_MAX; if (!copy_layout_for_monitor_rect(&old_rect, items, &count, &primary_index, &target_index) || target_index >= count) continue; RECT adjusted; if (!frame_monitor_rect(items, primary_index, target_index, &adjusted)) continue; source->position.x = adjusted.left; source->position.y = adjusted.top; source->width = items[target_index].frame_width; source->height = items[target_index].frame_height; /* Hardware target timings retain their actual clock and scanout. */ } return result; } static BOOL source_is_screen_dc(HDC source) { return GetObjectType(source) == OBJ_DC && GetDeviceCaps(source, TECHNOLOGY) == DT_RASDISPLAY; } /* GDI screen captures do not include the X11 hardware cursor. Keep the * cursor visible in the fallback path used on X11 by compositing Wine's * current cursor onto the capture destination after the desktop blit. */ static void draw_cursor_overlay(HDC hdc_dest, int x, int y, int width, int height, int source_x, int source_y, int source_width, int source_height) { CURSORINFO cursor; ICONINFO icon; BITMAP mask; POINT position; uur_cursor_rect source = {source_x, source_y, source_width, source_height}; uur_cursor_rect destination = {x, y, width, height}; uur_cursor_rect overlay; uur_cursor_shape shape; if (hdc_dest == NULL || width <= 0 || height <= 0 || source_width <= 0 || source_height <= 0 || source_is_screen_dc(hdc_dest)) return; ZeroMemory(&cursor, sizeof(cursor)); cursor.cbSize = sizeof(cursor); if (!GetCursorInfo(&cursor) || !(cursor.flags & CURSOR_SHOWING) || !GetCursorPos(&position)) return; /* Wine can report a visible cursor with a null handle until the first * real window has selected a class cursor. A generic arrow is preferable * to dropping the cursor from the remote frame altogether. */ if (cursor.hCursor == NULL) cursor.hCursor = LoadCursor(NULL, IDC_ARROW); if (cursor.hCursor == NULL) return; ZeroMemory(&icon, sizeof(icon)); if (!GetIconInfo(cursor.hCursor, &icon)) return; /* GetIconInfo's mask holds the cursor's actual bitmap dimensions. For a * monochrome cursor the AND/XOR masks are stacked vertically. */ if (icon.hbmMask != NULL && GetObjectW(icon.hbmMask, sizeof(mask), &mask) == sizeof(mask)) { shape.x = position.x; shape.y = position.y; shape.width = mask.bmWidth; shape.height = uur_cursor_bitmap_height(mask.bmHeight, icon.hbmColor != NULL); shape.hotspot_x = (int)icon.xHotspot; shape.hotspot_y = (int)icon.yHotspot; if (uur_map_cursor_overlay(&source, &destination, &shape, &overlay)) DrawIconEx(hdc_dest, overlay.x, overlay.y, cursor.hCursor, overlay.width, overlay.height, 0, NULL, DI_NORMAL); } if (icon.hbmColor != NULL) DeleteObject(icon.hbmColor); if (icon.hbmMask != NULL) DeleteObject(icon.hbmMask); } /* Feed the newest desktop frame into the capture destination by drawing * our shared-memory frame with StretchDIBits. Works regardless of the * destination bitmap type (DDB or DIB section). */ static BOOL feed_capture_frame_locked(HDC hdc_dest, int x, int y, int width, int height, int source_x, int source_y, int source_width, int source_height) { const unsigned char *header; uint32_t fw, fh, fstride; uint64_t total; int tries; int ok = 0; if (!ensure_frame_map()) return FALSE; header = (const unsigned char *)frame_map; fw = load_u32(header + 8); fh = load_u32(header + 12); fstride = load_u32(header + 16); size_t frame_bytes = (size_t)fstride * fh; total = load_u64(header + 24); if (fw != frame_width || fh != frame_height || fstride != frame_stride || fw == 0 || fh == 0 || fstride < fw * 4 || total == 0 || frame_bytes / fstride != fh || UURF_HEADER_BYTES + UURF_SLOT_COUNT * frame_slot_bytes > frame_map_size) return FALSE; if (frame_snapshot_capacity < frame_bytes) { unsigned char *fresh = HeapReAlloc(GetProcessHeap(), 0, frame_snapshot, frame_bytes); if (fresh == NULL && frame_snapshot == NULL) fresh = HeapAlloc(GetProcessHeap(), 0, frame_bytes); if (fresh == NULL) return FALSE; frame_snapshot = fresh; frame_snapshot_capacity = frame_bytes; } for (tries = 0; tries < 16 && !ok; ++tries) { const unsigned char *shm_slot = frame_map + uurf_slot_offset(total, (size_t)frame_slot_bytes); uint64_t before = load_u64(shm_slot); if ((before & 1) == 0 && before / 2 == total) { MemoryBarrier(); memcpy(frame_snapshot, shm_slot + 8, frame_bytes); MemoryBarrier(); uint64_t after = load_u64(shm_slot); if (before != after) continue; BITMAPINFOHEADER bmp_header; ZeroMemory(&bmp_header, sizeof(bmp_header)); bmp_header.biSize = sizeof(BITMAPINFOHEADER); bmp_header.biWidth = (LONG)fw; bmp_header.biHeight = -(LONG)fh; /* top-down */ bmp_header.biPlanes = 1; bmp_header.biBitCount = 32; bmp_header.biCompression = BI_RGB; bmp_header.biSizeImage = fstride * fh; int screen_width = GetSystemMetrics(SM_CXVIRTUALSCREEN); int screen_height = GetSystemMetrics(SM_CYVIRTUALSCREEN); if (screen_width < 1) screen_width = (int)fw; if (screen_height < 1) screen_height = (int)fh; /* A single-stream frame represents one selected monitor, so a * complete monitor request maps to the whole frame. Composite * frames already follow the virtual desktop layout and must be * cropped by the request's screen coordinates instead. */ int sx = 0; int sy = 0; int sw = 0; int sh = 0; RECT requested; requested.left = (LONG)source_x; requested.top = (LONG)source_y; requested.right = (LONG)source_x + (LONG)source_width; requested.bottom = (LONG)source_y + (LONG)source_height; HMONITOR monitor = (source_width > 0 && source_height > 0) ? MonitorFromRect(&requested, MONITOR_DEFAULTTONULL) : NULL; MONITORINFO info; ZeroMemory(&info, sizeof(info)); info.cbSize = sizeof(info); BOOL whole_monitor = FALSE; BOOL have_monitor_info = monitor != NULL && GetMonitorInfoA(monitor, &info); if ((frame_flags & UURF_FLAG_COMPOSITE) == 0 && have_monitor_info) { whole_monitor = info.rcMonitor.left == requested.left && info.rcMonitor.top == requested.top && info.rcMonitor.right == requested.right && info.rcMonitor.bottom == requested.bottom && (int64_t)(info.rcMonitor.right - info.rcMonitor.left) * fh == (int64_t)(info.rcMonitor.bottom - info.rcMonitor.top) * fw; } BOOL monitor_local_crop = FALSE; const unsigned char *selected_layout = NULL; const char *crop_mode = "screen"; if ((frame_flags & UURF_FLAG_COMPOSITE) != 0 && have_monitor_info && source_width > 0 && source_height > 0) { int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN); int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN); RECT crop_monitor = info.rcMonitor; const unsigned char *layout = NULL; /* Projected rectangles must be checked first: a projected * secondary monitor may lie inside Wine's old primary bounds. */ if (capture_geometry_enabled) { POINT origin = {0, 0}; HMONITOR primary = MonitorFromPoint(origin, MONITOR_DEFAULTTOPRIMARY); MONITORINFO primary_info = {0}; primary_info.cbSize = sizeof(primary_info); const unsigned char *primary_layout = NULL; if (primary != NULL && GetMonitorInfoA(primary, &primary_info)) primary_layout = find_frame_monitor(header, &primary_info.rcMonitor, screen_left, screen_top, screen_width, screen_height); for (uint32_t i = 0; primary_layout != NULL && i < frame_monitor_count; ++i) { const unsigned char *item = header + UURF_BASE_HEADER_BYTES + i * UURF_MONITOR_BYTES; LONG left = (LONG)load_u32(item + 16) - (LONG)load_u32(primary_layout + 16); LONG top = (LONG)load_u32(item + 20) - (LONG)load_u32(primary_layout + 20); RECT projected = {left, top, left + (LONG)load_u32(item + 24), top + (LONG)load_u32(item + 28)}; if (requested.left >= projected.left && requested.top >= projected.top && requested.right <= projected.right && requested.bottom <= projected.bottom) { layout = item; crop_monitor = projected; crop_mode = "stream-local"; break; } } } if (layout == NULL) layout = find_frame_monitor(header, &info.rcMonitor, screen_left, screen_top, screen_width, screen_height); if (layout != NULL) { selected_layout = layout; uint32_t frame_x = load_u32(layout + 16); uint32_t frame_y = load_u32(layout + 20); uint32_t frame_w = load_u32(layout + 24); uint32_t frame_h = load_u32(layout + 28); int64_t monitor_width = (int64_t)crop_monitor.right - crop_monitor.left; int64_t monitor_height = (int64_t)crop_monitor.bottom - crop_monitor.top; if (!monitor_local_crop && requested.left >= crop_monitor.left && requested.top >= crop_monitor.top && requested.right <= crop_monitor.right && requested.bottom <= crop_monitor.bottom && monitor_width > 0 && monitor_height > 0) { int64_t local_x0 = (int64_t)requested.left - crop_monitor.left; int64_t local_y0 = (int64_t)requested.top - crop_monitor.top; int64_t local_x1 = local_x0 + source_width; int64_t local_y1 = local_y0 + source_height; int64_t sx0 = frame_x + local_x0 * frame_w / monitor_width; int64_t sy0 = frame_y + local_y0 * frame_h / monitor_height; int64_t sx1 = frame_x + (local_x1 * frame_w + monitor_width - 1) / monitor_width; int64_t sy1 = frame_y + (local_y1 * frame_h + monitor_height - 1) / monitor_height; if (frame_w > 0 && frame_h > 0 && frame_x <= fw && frame_y <= fh && frame_w <= fw - frame_x && frame_h <= fh - frame_y) { if (sx0 < 0) sx0 = 0; if (sy0 < 0) sy0 = 0; if (sx1 > fw) sx1 = fw; if (sy1 > fh) sy1 = fh; if (sx1 > sx0 && sy1 > sy0) { sx = (int)sx0; sy = (int)sy0; sw = (int)(sx1 - sx0); sh = (int)(sy1 - sy0); monitor_local_crop = TRUE; if (crop_mode[0] == '\0' || strcmp(crop_mode, "screen") == 0) crop_mode = "monitor-local"; } } } } } if ((frame_flags & UURF_FLAG_COMPOSITE) != 0 && !monitor_local_crop) { crop_mode = "composite"; int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN); int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN); int64_t sx0 = ((int64_t)source_x - screen_left) * fw / screen_width; int64_t sy0 = ((int64_t)source_y - screen_top) * fh / screen_height; /* Keep a nonempty source rectangle nonempty after scaling. */ int64_t sx1 = (((int64_t)source_x + source_width - screen_left) * fw + screen_width - 1) / screen_width; int64_t sy1 = (((int64_t)source_y + source_height - screen_top) * fh + screen_height - 1) / screen_height; if (sx0 < 0) sx0 = 0; if (sy0 < 0) sy0 = 0; if (sx1 > fw) sx1 = fw; if (sy1 > fh) sy1 = fh; if (sx1 <= sx0 || sy1 <= sy0) return FALSE; sx = (int)sx0; sy = (int)sy0; sw = (int)(sx1 - sx0); sh = (int)(sy1 - sy0); } else if ((frame_flags & UURF_FLAG_COMPOSITE) == 0 && whole_monitor) { crop_mode = "whole-monitor"; sx = 0; sy = 0; sw = (int)fw; sh = (int)fh; } else if (!monitor_local_crop) { int screen_left = GetSystemMetrics(SM_XVIRTUALSCREEN); int screen_top = GetSystemMetrics(SM_YVIRTUALSCREEN); int64_t sx0 = ((int64_t)source_x - screen_left) * fw / screen_width; int64_t sy0 = ((int64_t)source_y - screen_top) * fh / screen_height; int64_t sx1 = ((int64_t)source_x + source_width - screen_left) * fw + screen_width - 1; int64_t sy1 = ((int64_t)source_y + source_height - screen_top) * fh + screen_height - 1; sx1 /= screen_width; sy1 /= screen_height; if (sx0 < 0) sx0 = 0; if (sy0 < 0) sy0 = 0; if (sx1 > fw) sx1 = fw; if (sy1 > fh) sy1 = fh; if (sx1 <= sx0 || sy1 <= sy0) return FALSE; sx = (int)sx0; sy = (int)sy0; sw = (int)(sx1 - sx0); sh = (int)(sy1 - sy0); } if (sw < 1) sw = (int)fw; if (sh < 1) sh = (int)fh; LONG debug_index = InterlockedIncrement(&frame_crop_debug_count); LONG offorigin_index = 0; if (have_monitor_info && (info.rcMonitor.left != 0 || info.rcMonitor.top != 0)) offorigin_index = InterlockedIncrement(&offorigin_crop_debug_count); if (debug_index <= 4 || (offorigin_index > 0 && offorigin_index <= 8)) { char debug[768]; LONG monitor_left = have_monitor_info ? info.rcMonitor.left : 0; LONG monitor_top = have_monitor_info ? info.rcMonitor.top : 0; LONG monitor_right = have_monitor_info ? info.rcMonitor.right : 0; LONG monitor_bottom = have_monitor_info ? info.rcMonitor.bottom : 0; LONG layout_x = selected_layout != NULL ? (LONG)(int32_t)load_u32(selected_layout) : 0; LONG layout_y = selected_layout != NULL ? (LONG)(int32_t)load_u32(selected_layout + 4) : 0; uint32_t layout_w = selected_layout != NULL ? load_u32(selected_layout + 8) : 0; uint32_t layout_h = selected_layout != NULL ? load_u32(selected_layout + 12) : 0; uint32_t layout_fx = selected_layout != NULL ? load_u32(selected_layout + 16) : 0; uint32_t layout_fy = selected_layout != NULL ? load_u32(selected_layout + 20) : 0; uint32_t layout_fw = selected_layout != NULL ? load_u32(selected_layout + 24) : 0; uint32_t layout_fh = selected_layout != NULL ? load_u32(selected_layout + 28) : 0; uint32_t capture_w = selected_layout != NULL ? load_u32(selected_layout + 32) : 0; uint32_t capture_h = selected_layout != NULL ? load_u32(selected_layout + 36) : 0; sprintf(debug, "crop #%ld offorigin-sample=%ld mode=%s flags=%lu frame=%lux%lu " "src=%d,%d %dx%d dest=%d,%d %dx%d virtual=%ld,%ld %dx%d " "monitor=%ld,%ld-%ld,%ld whole=%d layout=%ld,%ld " "%lux%lu frame-at=%lu,%lu %lux%lu capture=%lux%lu " "crop=%d,%d %dx%d", debug_index, offorigin_index, crop_mode, (unsigned long)frame_flags, (unsigned long)fw, (unsigned long)fh, source_x, source_y, source_width, source_height, x, y, width, height, (LONG)GetSystemMetrics(SM_XVIRTUALSCREEN), (LONG)GetSystemMetrics(SM_YVIRTUALSCREEN), screen_width, screen_height, monitor_left, monitor_top, monitor_right, monitor_bottom, whole_monitor, layout_x, layout_y, (unsigned long)layout_w, (unsigned long)layout_h, (unsigned long)layout_fx, (unsigned long)layout_fy, (unsigned long)layout_fw, (unsigned long)layout_fh, (unsigned long)capture_w, (unsigned long)capture_h, sx, sy, sw, sh); hook_log(debug); } /* Wine's top-down DIB subrectangle path can offset a short * monitor crop from the bottom of the composite. Compact the * chosen rows in-place and draw a whole DIB at source (0,0). * Destination rows precede source rows, so memmove also covers * overlapping crops without another frame-sized allocation. */ for (int row = 0; row < sh; ++row) memmove(frame_snapshot + (size_t)row * sw * 4, frame_snapshot + (size_t)(sy + row) * fstride + (size_t)sx * 4, (size_t)sw * 4); bmp_header.biWidth = sw; bmp_header.biHeight = -sh; bmp_header.biSizeImage = (DWORD)((size_t)sw * sh * 4); int result = StretchDIBits( hdc_dest, x, y, width, height, 0, 0, sw, sh, (const void *)frame_snapshot, (const BITMAPINFO *)&bmp_header, DIB_RGB_COLORS, SRCCOPY); ok = result != 0 && (DWORD)result != GDI_ERROR; } else { uint64_t now = load_u64(header + 24); total = (now < total) ? now : total - 1; if (total == 0) return FALSE; } } return ok; } static BOOL feed_capture_frame(HDC hdc_dest, int x, int y, int width, int height, int source_x, int source_y, int source_width, int source_height) { AcquireSRWLockExclusive(&frame_lock); BOOL result = feed_capture_frame_locked(hdc_dest, x, y, width, height, source_x, source_y, source_width, source_height); ReleaseSRWLockExclusive(&frame_lock); return result; } static BOOL try_capture_feed(HDC hdc_dest, int x, int y, DWORD rop, HDC hdc_src, int width, int height, int source_x, int source_y, int source_width, int source_height) { InterlockedIncrement(&capture_calls); /* The client's desktop capture is an SRCCOPY blit whose source is the * screen DC; anything else falls through untouched. */ if ((rop & 0x00ffffffu) == SRCCOPY && hdc_src != NULL && source_is_screen_dc(hdc_src)) { if (feed_capture_frame(hdc_dest, x, y, width, height, source_x, source_y, source_width, source_height)) { InterlockedIncrement(&capture_rendered); return TRUE; } } InterlockedIncrement(&capture_fallbacks); return FALSE; } BOOL WINAPI hook_bit_blt(HDC hdc_dest, int x, int y, int width, int height, HDC hdc_src, int x_src, int y_src, DWORD rop) { BOOL result; if (try_capture_feed(hdc_dest, x, y, rop, hdc_src, width, height, x_src, y_src, width, height)) return TRUE; result = original_bit_blt(hdc_dest, x, y, width, height, hdc_src, x_src, y_src, rop); if (result && (rop & 0x00ffffffu) == SRCCOPY && hdc_src != NULL && source_is_screen_dc(hdc_src)) draw_cursor_overlay(hdc_dest, x, y, width, height, x_src, y_src, width, height); return result; } BOOL WINAPI hook_stretch_blt(HDC hdc_dest, int x, int y, int w, int h, HDC hdc_src, int xs, int ys, int sw, int sh, DWORD rop) { BOOL result; if (try_capture_feed(hdc_dest, x, y, rop, hdc_src, w, h, xs, ys, sw, sh)) return TRUE; result = original_stretch_blt(hdc_dest, x, y, w, h, hdc_src, xs, ys, sw, sh, rop); if (result && (rop & 0x00ffffffu) == SRCCOPY && hdc_src != NULL && source_is_screen_dc(hdc_src)) draw_cursor_overlay(hdc_dest, x, y, w, h, xs, ys, sw, sh); return result; } /* ---- diagnostics ------------------------------------------------------ */ static void hook_log(const char *text) { char path[MAX_PATH]; if (GetEnvironmentVariableA("UUR_HOOK_LOG", path, sizeof(path)) == 0 || path[0] == '\0') lstrcpynA(path, "C:\\uur-bridge.log", sizeof(path)); FILE *f = fopen(path, "a"); if (f == NULL) return; fprintf(f, "%s\n", text); fclose(f); } /* ---- wire helpers ---------------------------------------------------- */ static void put_u32(unsigned char *p, uint32_t v) { p[0] = (unsigned char)(v); p[1] = (unsigned char)(v >> 8); p[2] = (unsigned char)(v >> 16); p[3] = (unsigned char)(v >> 24); } static void put_u16(unsigned char *p, uint16_t v) { p[0] = (unsigned char)(v); p[1] = (unsigned char)(v >> 8); } static void put_i32(unsigned char *p, int32_t v) { put_u32(p, (uint32_t)v); } static void send_record(uint32_t kind, uint16_t code, uint16_t state, int32_t a, int32_t b) { unsigned char frame[16 + 16]; put_u32(frame + 0, UUR_MAGIC); put_u32(frame + 4, UUR_VERSION); put_u32(frame + 8, kind); put_u32(frame + 12, 16); put_u32(frame + 16, kind); put_u16(frame + 20, code); put_u16(frame + 22, state); put_i32(frame + 24, a); put_i32(frame + 28, b); int total = 0; while (total < (int)sizeof(frame)) { int sent = send(hook_socket, (const char *)frame + total, (int)sizeof(frame) - total, 0); if (sent <= 0) { closesocket(hook_socket); hook_socket = INVALID_SOCKET; return; } total += sent; } } static FARPROC WINAPI hook_get_proc_address(HMODULE module, LPCSTR name) { union { FARPROC generic; UINT(WINAPI *send_input)(UINT, LPINPUT, int); BOOL(WINAPI *bit_blt)(HDC, int, int, int, int, HDC, int, int, DWORD); BOOL(WINAPI *stretch_blt)(HDC, int, int, int, int, HDC, int, int, int, int, DWORD); HRESULT(WINAPI *create_dxgi_factory1)(REFIID, void **); int(WINAPI *get_system_metrics)(int); int(WINAPI *get_device_caps)(HDC, int); BOOL(WINAPI *get_monitor_info)(HMONITOR, LPMONITORINFO); BOOL(WINAPI *enum_display_settings_a)(LPCSTR, DWORD, LPDEVMODEA); BOOL(WINAPI *enum_display_settings_w)(LPCWSTR, DWORD, LPDEVMODEW); BOOL(WINAPI *enum_display_settings_ex_w)(LPCWSTR, DWORD, LPDEVMODEW, DWORD); LONG(WINAPI *query_display_config)(UINT, UINT *, DISPLAYCONFIG_PATH_INFO *, UINT *, DISPLAYCONFIG_MODE_INFO *, DISPLAYCONFIG_TOPOLOGY_ID *); } replacement; FARPROC resolved = original_get_proc_address(module, name); if (name == NULL || ((uintptr_t)name >> 16) == 0) return resolved; if (lstrcmpiA(name, "SendInput") == 0) { replacement.send_input = hook_send_input; return replacement.generic; } if (lstrcmpiA(name, "BitBlt") == 0) { replacement.bit_blt = hook_bit_blt; return replacement.generic; } if (lstrcmpiA(name, "StretchBlt") == 0) { replacement.stretch_blt = hook_stretch_blt; return replacement.generic; } if (lstrcmpiA(name, "CreateDXGIFactory1") == 0) { replacement.create_dxgi_factory1 = hook_create_dxgi_factory1; return replacement.generic; } if (lstrcmpiA(name, "GetSystemMetrics") == 0) { replacement.get_system_metrics = hook_get_system_metrics; return replacement.generic; } if (lstrcmpiA(name, "GetDeviceCaps") == 0) { replacement.get_device_caps = hook_get_device_caps; return replacement.generic; } if (lstrcmpiA(name, "GetMonitorInfoA") == 0) { replacement.get_monitor_info = hook_get_monitor_info_a; return replacement.generic; } if (lstrcmpiA(name, "GetMonitorInfoW") == 0) { replacement.get_monitor_info = hook_get_monitor_info_w; return replacement.generic; } if (lstrcmpiA(name, "EnumDisplaySettingsA") == 0) { replacement.enum_display_settings_a = hook_enum_display_settings_a; return replacement.generic; } if (lstrcmpiA(name, "EnumDisplaySettingsW") == 0) { replacement.enum_display_settings_w = hook_enum_display_settings_w; return replacement.generic; } if (lstrcmpiA(name, "EnumDisplaySettingsExW") == 0) { replacement.enum_display_settings_ex_w = hook_enum_display_settings_ex_w; return replacement.generic; } if (lstrcmpiA(name, "QueryDisplayConfig") == 0) { replacement.query_display_config = hook_query_display_config; return replacement.generic; } return resolved; } /* Minimal ini reader: returns a malloc'd value for `key` or NULL. */ static char *read_ini_value(const char *path, const char *key) { FILE *f = fopen(path, "r"); char line[512]; size_t key_len; if (f == NULL) return NULL; key_len = strlen(key); while (fgets(line, sizeof(line), f) != NULL) { if (strncmp(line, key, key_len) == 0 && line[key_len] == '=') { char *end = line + strlen(line); char *value = line + key_len + 1; char *out; size_t len; while (end > value && (end[-1] == '\n' || end[-1] == '\r' || end[-1] == ' ')) *--end = '\0'; fclose(f); len = (size_t)(end - value); out = malloc(len + 1); if (out != NULL) { memcpy(out, value, len); out[len] = '\0'; } return out; } } fclose(f); return NULL; } static int connect_bridge(void) { char port_text[16] = "47010"; char token_hex[80] = ""; char *value; /* Config: environment first (fast path for uur-spawned processes), * then C:\uur-bridge.ini — the file form survives any spawn path, * including the Wine service manager restarting the service without * uur's environment. */ if ((value = getenv("UUR_BRIDGE_PORT")) != NULL && *value) lstrcpynA(port_text, value, sizeof(port_text)); else { char *v = read_ini_value("C:\\uur-bridge.ini", "port"); if (v != NULL) { lstrcpynA(port_text, v, sizeof(port_text)); free(v); } } if ((value = getenv("UUR_BRIDGE_TOKEN")) != NULL && *value) lstrcpynA(token_hex, value, sizeof(token_hex)); else { char *v = read_ini_value("C:\\uur-bridge.ini", "token"); if (v != NULL) { lstrcpynA(token_hex, v, sizeof(token_hex)); free(v); } } WSADATA wsa; if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) { hook_log("connect: WSAStartup failed"); return 0; } struct addrinfo hints; struct addrinfo *result = NULL; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; if (getaddrinfo("127.0.0.1", port_text, &hints, &result) != 0 || result == NULL) { char buf[96]; sprintf(buf, "connect: getaddrinfo failed (port=%s)", port_text); hook_log(buf); WSACleanup(); return 0; } SOCKET sock = socket(result->ai_family, result->ai_socktype, result->ai_protocol); if (sock == INVALID_SOCKET) { freeaddrinfo(result); WSACleanup(); return 0; } if (connect(sock, result->ai_addr, (int)result->ai_addrlen) != 0) { char buf[96]; sprintf(buf, "connect: failed wsae=%lu port=%s", (unsigned long)WSAGetLastError(), port_text); hook_log(buf); closesocket(sock); freeaddrinfo(result); WSACleanup(); return 0; } freeaddrinfo(result); /* HELLO: header only; the daemon then reads 32 raw token bytes. */ unsigned char hello[16]; put_u32(hello + 0, UUR_MAGIC); put_u32(hello + 4, UUR_VERSION); put_u32(hello + 8, UUR_RECORD_HELLO); put_u32(hello + 12, 32); if (send(sock, (const char *)hello, sizeof(hello), 0) != sizeof(hello)) { closesocket(sock); WSACleanup(); return 0; } unsigned char token[32]; ZeroMemory(token, sizeof(token)); for (int i = 0; i < 32; ++i) { unsigned byte = 0; char hex[3] = {token_hex[2 * i], token_hex[2 * i + 1], 0}; if (hex[0] && hex[1]) { byte = (unsigned)strtoul(hex, NULL, 16); } token[i] = (unsigned char)byte; } if (send(sock, (const char *)token, sizeof(token), 0) != sizeof(token)) { closesocket(sock); WSACleanup(); return 0; } /* Nothing to read until the daemon closes; the connection is * fire-and-forget from here on. */ hook_socket = sock; return 1; } /* ---- SendInput interception ------------------------------------------ */ UINT WINAPI hook_send_input(UINT count, LPINPUT inputs, int size) { if (inputs == NULL || size < (int)sizeof(INPUT)) return original_send_input(count, inputs, size); LONG busy = InterlockedCompareExchange(&hook_busy, 1, 0); if (busy == 0) { for (UINT i = 0; i < count; ++i) { LPINPUT input = &inputs[i]; if (input->type == INPUT_KEYBOARD) { uint16_t code = input->ki.wVk; if (input->ki.dwFlags & KEYEVENTF_EXTENDEDKEY) code |= 0x100; send_record(UUR_RECORD_KEYBOARD, code, (input->ki.dwFlags & KEYEVENTF_KEYUP) ? 0 : 1, 0, 0); } else if (input->type == INPUT_MOUSE) { DWORD flags = input->mi.dwFlags; if (flags & MOUSEEVENTF_WHEEL) { /* wheel delta rides in the low word of mouseData */ send_record(UUR_RECORD_MOUSE, 0xfffe /*wheel*/, 0, 0, (int16_t)(input->mi.mouseData & 0xffff)); } else if (flags & (MOUSEEVENTF_XDOWN | MOUSEEVENTF_XUP)) { /* XBUTTON1/2 map to X11 buttons 8/9 */ uint16_t button = (input->mi.mouseData & 0xffff) == XBUTTON1 ? 8 : 9; send_record(UUR_RECORD_MOUSE, button, (flags & MOUSEEVENTF_XDOWN) ? 1 : 0, 0, 0); } else if (flags & (MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP | MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP | MOUSEEVENTF_MIDDLEDOWN | MOUSEEVENTF_MIDDLEUP)) { uint16_t button = 0; if (flags & (MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP)) button = 1; else if (flags & (MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP)) button = 2; else button = 3; int down = (flags & (MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_MIDDLEDOWN)) ? 1 : 0; send_record(UUR_RECORD_MOUSE, button, (uint16_t)down, 0, 0); } if (flags & MOUSEEVENTF_MOVE) { if (flags & MOUSEEVENTF_ABSOLUTE) { /* Preserve Windows' normalized coordinate space. The * selected Linux backend performs the final mapping. */ send_record(UUR_RECORD_MOUSE, 0xffff /*motion*/, 1, input->mi.dx, input->mi.dy); } else { send_record(UUR_RECORD_MOUSE, 0xffff /*motion*/, 0, input->mi.dx, input->mi.dy); } } } } InterlockedExchange(&hook_busy, 0); } /* Keep the in-client behaviour identical: UU verifies its calls. */ return original_send_input(count, inputs, size); } /* ---- IAT rewrite ------------------------------------------------------ */ static int patch_module_iat(HMODULE base) { if (base == NULL || base == hook_module) return 0; IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER *)base; if (dos->e_magic != IMAGE_DOS_SIGNATURE) return 0; IMAGE_NT_HEADERS *nt = (IMAGE_NT_HEADERS *)((char *)base + dos->e_lfanew); if (nt->Signature != IMAGE_NT_SIGNATURE) return 0; IMAGE_DATA_DIRECTORY *dir = &nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]; if (dir->VirtualAddress == 0) return 0; int patched = 0; IMAGE_IMPORT_DESCRIPTOR *descriptor = (IMAGE_IMPORT_DESCRIPTOR *) ((char *)base + dir->VirtualAddress); for (; descriptor->Name != 0; ++descriptor) { const char *module_name = (const char *)base + descriptor->Name; if (_stricmp(module_name, "USER32.dll") != 0 && _stricmp(module_name, "GDI32.dll") != 0 && _stricmp(module_name, "dxgi.dll") != 0 && _stricmp(module_name, "KERNEL32.dll") != 0 && _stricmp(module_name, "KERNELBASE.dll") != 0) continue; IMAGE_THUNK_DATA *thunk = (IMAGE_THUNK_DATA *) ((char *)base + descriptor->FirstThunk); IMAGE_THUNK_DATA *original = thunk; if (descriptor->OriginalFirstThunk != 0) original = (IMAGE_THUNK_DATA *) ((char *)base + descriptor->OriginalFirstThunk); for (; original->u1.AddressOfData != 0; ++thunk, ++original) { if (original->u1.Ordinal & IMAGE_ORDINAL_FLAG) continue; IMAGE_IMPORT_BY_NAME *name = (IMAGE_IMPORT_BY_NAME *) ((char *)base + original->u1.AddressOfData); void *hook_fn = NULL; void **original_slot = NULL; if (lstrcmpiA(name->Name, "SendInput") == 0) { hook_fn = (void *)hook_send_input; original_slot = (void **)&original_send_input; } else if (lstrcmpiA(name->Name, "BitBlt") == 0) { hook_fn = (void *)hook_bit_blt; original_slot = (void **)&original_bit_blt; } else if (lstrcmpiA(name->Name, "StretchBlt") == 0) { hook_fn = (void *)hook_stretch_blt; original_slot = (void **)&original_stretch_blt; } else if (lstrcmpiA(name->Name, "CreateDXGIFactory1") == 0) { hook_fn = (void *)hook_create_dxgi_factory1; original_slot = (void **)&original_create_dxgi_factory1; } else if (lstrcmpiA(name->Name, "GetProcAddress") == 0) { hook_fn = (void *)hook_get_proc_address; original_slot = (void **)&original_get_proc_address; } else if (lstrcmpiA(name->Name, "GetSystemMetrics") == 0) { hook_fn = (void *)hook_get_system_metrics; original_slot = (void **)&original_get_system_metrics; } else if (lstrcmpiA(name->Name, "GetDeviceCaps") == 0) { hook_fn = (void *)hook_get_device_caps; original_slot = (void **)&original_get_device_caps; } else if (lstrcmpiA(name->Name, "GetMonitorInfoA") == 0) { hook_fn = (void *)hook_get_monitor_info_a; original_slot = (void **)&original_get_monitor_info_a; } else if (lstrcmpiA(name->Name, "GetMonitorInfoW") == 0) { hook_fn = (void *)hook_get_monitor_info_w; original_slot = (void **)&original_get_monitor_info_w; } else if (lstrcmpiA(name->Name, "EnumDisplaySettingsA") == 0) { hook_fn = (void *)hook_enum_display_settings_a; original_slot = (void **)&original_enum_display_settings_a; } else if (lstrcmpiA(name->Name, "EnumDisplaySettingsW") == 0) { hook_fn = (void *)hook_enum_display_settings_w; original_slot = (void **)&original_enum_display_settings_w; } else if (lstrcmpiA(name->Name, "EnumDisplaySettingsExW") == 0) { hook_fn = (void *)hook_enum_display_settings_ex_w; original_slot = (void **)&original_enum_display_settings_ex_w; } else if (lstrcmpiA(name->Name, "QueryDisplayConfig") == 0) { hook_fn = (void *)hook_query_display_config; original_slot = (void **)&original_query_display_config; } if (hook_fn == NULL) continue; if (thunk->u1.Function == (uintptr_t)hook_fn) continue; *original_slot = (void *)thunk->u1.Function; DWORD old_protect = 0; if (!VirtualProtect(&thunk->u1.Function, sizeof(thunk->u1.Function), PAGE_READWRITE, &old_protect)) continue; thunk->u1.Function = (uintptr_t)hook_fn; VirtualProtect(&thunk->u1.Function, sizeof(thunk->u1.Function), old_protect, &old_protect); ++patched; InterlockedIncrement(&iat_hooks_installed); } } return patched; } static int patch_loaded_modules(void) { int patched = 0; HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId()); if (snapshot == INVALID_HANDLE_VALUE) return 0; MODULEENTRY32W entry; entry.dwSize = sizeof(entry); if (Module32FirstW(snapshot, &entry)) { do { patched += patch_module_iat(entry.hModule); } while (Module32NextW(snapshot, &entry)); } CloseHandle(snapshot); return patched; } /* ---- late-module watchdog --------------------------------------------- */ static DWORD WINAPI patch_watchdog(LPVOID parameter) { (void)parameter; for (;;) { Sleep(2000); patch_loaded_modules(); char status_path[MAX_PATH]; sprintf(status_path, "C:\\uur-capture-status-%lu.txt", (unsigned long)GetCurrentProcessId()); FILE *f = fopen(status_path, "w"); if (f != NULL) { fprintf(f, "pid=%lu iat=%ld dxgi_f=%ld dxgi_a=%ld dxgi_o=%ld dup=%ld\n\ calls=%ld rendered=%ld fallbacks=%ld\n", GetCurrentProcessId(), iat_hooks_installed, dxgi_factories_patched, dxgi_adapters_patched, dxgi_outputs_patched, dxgi_duplicate_calls, capture_calls, capture_rendered, capture_fallbacks); fclose(f); } } return 0; } static DWORD WINAPI bridge_retry_thread(LPVOID parameter) { (void)parameter; for (int attempt = 0; attempt < 120; ++attempt) { Sleep(2000); if (hook_socket != INVALID_SOCKET) return 0; if (connect_bridge()) { hook_log("retry: bridge connected"); return 0; } char buf[96]; sprintf(buf, "retry %d failed wsae=%lu", attempt, (unsigned long)WSAGetLastError()); hook_log(buf); } return 0; } /* ---- entry ------------------------------------------------------------ */ /* Marker export: the wevtapi shim references this symbol purely so the * linker emits the uur-hook.dll dependency that carries the preload chain. */ void uur_hook_version(void) {} BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) { (void)reserved; if (reason != DLL_PROCESS_ATTACH) return TRUE; hook_module = instance; WCHAR executable[MAX_PATH]; if (GetModuleFileNameW(NULL, executable, MAX_PATH) > 0) { const WCHAR *name = wcsrchr(executable, L'\\'); name = name != NULL ? name + 1 : executable; capture_geometry_enabled = lstrcmpiW(name, L"GameViewerServer.exe") == 0 || lstrcmpiW(name, L"GameViewerService.exe") == 0; } WCHAR geometry_option[2]; if (GetEnvironmentVariableW(L"UUR_CAPTURE_GEOMETRY", geometry_option, 2) == 1) capture_geometry_enabled = geometry_option[0] == L'1'; DisableThreadLibraryCalls(instance); if (connect_bridge()) { hook_log("attach: bridge connected"); } else { /* The daemon may simply not be bound yet: the service spawns the * server seconds before uur binds the bridge. Retry in the * background instead of staying idle forever. */ hook_log("attach: bridge unavailable, retrying"); CreateThread(NULL, 0, bridge_retry_thread, NULL, 0, NULL); } if (patch_loaded_modules() > 0) { hook_log("attach: SendInput/BitBlt imports rewritten"); } else { hook_log("attach: no SendInput import found"); } /* streamer.dll and friends can load after us; keep scanning so late * modules get their capture imports rewritten too. */ HANDLE watchdog = CreateThread(NULL, 0, patch_watchdog, NULL, 0, NULL); if (watchdog != NULL) CloseHandle(watchdog); return TRUE; }