- wine-devel - winehq.org

[PATCH 1/2] ntdll: Add test for environment variables in PEB block
by Fabian Maurer 07 May '19

07 May '19

Note that the test is interactive since it requires a reboot (on windows) and a rerun on wine. AFAIK there's no way around those limitations, so this is the test I came up with. Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/ntdll/tests/env.c | 57 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/dlls/ntdll/tests/env.c b/dlls/ntdll/tests/env.c index 4e2ef8222d..41cb44ecd2 100644 --- a/dlls/ntdll/tests/env.c +++ b/dlls/ntdll/tests/env.c @@ -515,6 +515,59 @@ static void test_process_params(void) } } +static BOOL setup_environment(void) +{ + HKEY key; + LSTATUS status; + LPCSTR value1 = "%WINETESTVAR2%"; + LPCSTR value2 = "test ok"; + BOOL is_ready; + const char *path = "System\\CurrentControlSet\\Control\\Session Manager\\Environment"; + status = RegOpenKeyExA(HKEY_LOCAL_MACHINE, path, 0, KEY_ALL_ACCESS, &key); + ok(status == ERROR_SUCCESS, "RegOpenKeyExA failed with %d\n", status); + + status = RegQueryValueExA(key, "WINETESTVAR1", NULL, NULL, NULL, NULL); + ok(status == ERROR_SUCCESS || status == ERROR_FILE_NOT_FOUND, "RegQueryValueExA failed with %d\n", status); + is_ready = (status == ERROR_SUCCESS); + if (!is_ready) + { + status = RegSetValueExA(key, "WINETESTVAR1", 0, REG_EXPAND_SZ,(LPBYTE)value1, strlen(value1) + 1); + ok(status == ERROR_SUCCESS, "RegSetValueExA failed with %d\n", status); + status = RegSetValueExA(key, "WINETESTVAR2", 0, REG_EXPAND_SZ,(LPBYTE)value2, strlen(value2) + 1); + ok(status == ERROR_SUCCESS, "RegSetValueExA failed with %d\n", status); + } + RegCloseKey(key); + + return is_ready; +} + +static void test_peb_environment(void) +{ + static const WCHAR result1[] = {'W','I','N','E','T','E','S','T','V','A','R','1','=','t','e','s','t',' ','o','k',0}; + static const WCHAR result2[] = {'W','I','N','E','T','E','S','T','V','A','R','2','=','t','e','s','t',' ','o','k',0}; + BOOL found1 = FALSE; + BOOL found2 = FALSE; + BOOL is_ready = setup_environment(); + if (is_ready) + { + WCHAR *env = NtCurrentTeb()->Peb->ProcessParameters->Environment; + for (; *env; env += lstrlenW(env) + 1) + { + if (lstrcmpW(env, result1) == 0) + found1 = TRUE; + if (lstrcmpW(env, result2) == 0) + found2 = TRUE; + } + todo_wine + ok(found1, "Didn't find %s in the PEB environment variables\n", wine_dbgstr_w(result1)); + ok(found2, "Didn't find %s in the PEB environment variables\n", wine_dbgstr_w(result2)); + } + else + { + skip("Preparation finished. Restart when running windows, then rerun the test for the results.\n"); + } +} + START_TEST(env) { HMODULE mod = GetModuleHandleA("ntdll.dll"); @@ -535,4 +588,8 @@ START_TEST(env) testSet(); testExpand(); test_process_params(); + if (winetest_interactive) + { + test_peb_environment(); + } } -- 2.21.0

1 1

[PATCH 6/6] advapi32: Return required buffer size in RegLoadMUIString.
by Akihiro Sagawa 07 May '19

07 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 10 ++++++++-- dlls/advapi32/tests/registry.c | 14 ++++++-------- 2 files changed, 14 insertions(+), 10 deletions(-)

2 1

[PATCH 5/6] advapi32: Remove useless RegLoadMUIStringA implementation.
by Akihiro Sagawa 07 May '19

07 May '19

This commit avoids brokeness in advance. Otherwise, it will be broken when we support ERROR_MORE_DATA in RegLoadMUIStringW. Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 32 ++------------------------------ dlls/advapi32/tests/registry.c | 6 +++--- 2 files changed, 5 insertions(+), 33 deletions(-)

2 1

[PATCH 4/6] advapi32: Improve load_string to return error code.
by Akihiro Sagawa 07 May '19

07 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 19 +++++++++++-------- dlls/advapi32/tests/registry.c | 2 +- 2 files changed, 12 insertions(+), 9 deletions(-)

2 1

[PATCH 3/6] advapi32: Improve parameter sanity checks in RegLoadMUIString.
by Akihiro Sagawa 07 May '19

07 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 2 +- dlls/advapi32/tests/registry.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-)

2 1

[PATCH 2/6] advapi32: Support the base directory parameter in RegLoadMUIString.
by Akihiro Sagawa 07 May '19

07 May '19

Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/registry.c | 36 +++++++++++++++++++++++++----------- dlls/advapi32/tests/registry.c | 2 +- dlls/kernel32/time.c | 2 +- 3 files changed, 27 insertions(+), 13 deletions(-)

2 1

[PATCH 1/6] advapi32/tests: Add basic RegLoadMUIString tests.
by Akihiro Sagawa 07 May '19

07 May '19

Motivation: Before adding cache mechanism in RegLoadMUIString, I'll add some conformance tests for the function and fix its implementation. Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/advapi32/tests/registry.c | 115 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+)

1 0

[PATCH] ntoskrnl.exe/tests: Add more overlapped tests.
by Jacek Caban 07 May '19

07 May '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/ntoskrnl.exe/tests/ntoskrnl.c | 45 ++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 6 deletions(-)

2 1

[PATCH] dinput: Use heuristics to guess if a device is a gamepad or a joystick
by Andrew Eikum 07 May '19

07 May '19

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47123 Signed-off-by: Andrew Eikum <aeikum(a)codeweavers.com> --- Applies on top of Alistair's series. dlls/dinput/dinput_private.h | 2 +- dlls/dinput/joystick.c | 6 +++- dlls/dinput/joystick_linux.c | 46 +++++++++++++++++++++++++++++-- dlls/dinput/joystick_linuxinput.c | 27 ++++++++++++++++-- dlls/dinput/joystick_osx.c | 20 ++++++++++++-- 5 files changed, 91 insertions(+), 10 deletions(-) diff --git a/dlls/dinput/dinput_private.h b/dlls/dinput/dinput_private.h index c97a49334ad..289b2f1f63d 100644 --- a/dlls/dinput/dinput_private.h +++ b/dlls/dinput/dinput_private.h @@ -81,7 +81,7 @@ extern void _copy_diactionformatWtoA(LPDIACTIONFORMATA, LPDIACTIONFORMATW) DECLS extern HRESULT _configure_devices(IDirectInput8W *iface, LPDICONFIGUREDEVICESCALLBACK lpdiCallback, LPDICONFIGUREDEVICESPARAMSW lpdiCDParams, DWORD dwFlags, LPVOID pvRefData) DECLSPEC_HIDDEN; extern WCHAR* get_mapping_path(const WCHAR *device, const WCHAR *username) DECLSPEC_HIDDEN; -extern DWORD get_device_type(DWORD version) DECLSPEC_HIDDEN; +extern DWORD get_device_type(DWORD version, BOOL is_joystick) DECLSPEC_HIDDEN; #define IS_DIPROP(x) (((ULONG_PTR)(x) >> 16) == 0) diff --git a/dlls/dinput/joystick.c b/dlls/dinput/joystick.c index 5129bb85457..8b3edb2c540 100644 --- a/dlls/dinput/joystick.c +++ b/dlls/dinput/joystick.c @@ -76,8 +76,12 @@ DWORD typeFromGUID(REFGUID guid) } } -DWORD get_device_type(DWORD version) +DWORD get_device_type(DWORD version, BOOL is_joystick) { + if (is_joystick) + return version >= 0x0800 ? DI8DEVTYPE_JOYSTICK | (DI8DEVTYPEJOYSTICK_STANDARD << 8) : + DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_TRADITIONAL << 8); + return version >= 0x0800 ? DI8DEVTYPE_GAMEPAD | (DI8DEVTYPEJOYSTICK_STANDARD << 8) : DIDEVTYPE_JOYSTICK | (DIDEVTYPEJOYSTICK_GAMEPAD << 8); } diff --git a/dlls/dinput/joystick_linux.c b/dlls/dinput/joystick_linux.c index 2644ed66a4e..b708db3e81c 100644 --- a/dlls/dinput/joystick_linux.c +++ b/dlls/dinput/joystick_linux.c @@ -84,6 +84,8 @@ struct JoyDev int *dev_axes_map; WORD vendor_id, product_id, bus_type; + + BOOL is_joystick; }; typedef struct JoystickImpl JoystickImpl; @@ -177,6 +179,7 @@ static INT find_joystick_devices(void) int fd; struct JoyDev joydev, *new_joydevs; BYTE axes_map[ABS_MAX + 1]; + SHORT btn_map[KEY_MAX - BTN_MISC + 1]; snprintf(joydev.device, sizeof(joydev.device), "%s%d", JOYDEV_NEW, i); if ((fd = open(joydev.device, O_RDONLY)) == -1) @@ -220,6 +223,42 @@ static INT find_joystick_devices(void) joydev.button_count = 2; #endif + joydev.is_joystick = FALSE; + if (ioctl(fd, JSIOCGBTNMAP, btn_map) < 0) + { + WARN("ioctl(%s,JSIOCGBTNMAP) failed: %s\n", joydev.device, strerror(errno)); + } + else + { + INT j; + /* in lieu of properly reporting HID usage, detect presence of + * "joystick buttons" and report those devices as joysticks instead of + * gamepads */ + for (j = 0; !joydev.is_joystick && j < joydev.button_count; j++) + { + switch (btn_map[j]) + { + case BTN_TRIGGER: + case BTN_THUMB: + case BTN_THUMB2: + case BTN_TOP: + case BTN_TOP2: + case BTN_PINKIE: + case BTN_BASE: + case BTN_BASE2: + case BTN_BASE3: + case BTN_BASE4: + case BTN_BASE5: + case BTN_BASE6: + case BTN_DEAD: + joydev.is_joystick = TRUE; + break; + default: + break; + } + } + } + if (ioctl(fd, JSIOCGAXMAP, axes_map) < 0) { WARN("ioctl(%s,JSIOCGAXMAP) failed: %s\n", joydev.device, strerror(errno)); @@ -322,7 +361,7 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver lpddi->guidInstance = DInput_Wine_Joystick_GUID; lpddi->guidInstance.Data3 = id; lpddi->guidProduct = joystick_devices[id].guid_product; - lpddi->dwDevType = get_device_type(version); + lpddi->dwDevType = get_device_type(version, joystick_devices[id].is_joystick); /* Assume the joystick as HID if it is attached to USB bus and has a valid VID/PID */ if (joystick_devices[id].bus_type == BUS_USB && @@ -330,7 +369,10 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver { lpddi->dwDevType |= DIDEVTYPE_HID; lpddi->wUsagePage = 0x01; /* Desktop */ - lpddi->wUsage = 0x05; /* Game Pad */ + if (joystick_devices[id].is_joystick) + lpddi->wUsage = 0x04; /* Joystick */ + else + lpddi->wUsage = 0x05; /* Game Pad */ } MultiByteToWideChar(CP_ACP, 0, joystick_devices[id].name, -1, lpddi->tszInstanceName, MAX_PATH); diff --git a/dlls/dinput/joystick_linuxinput.c b/dlls/dinput/joystick_linuxinput.c index c742c151c7a..d4512dc5ec1 100644 --- a/dlls/dinput/joystick_linuxinput.c +++ b/dlls/dinput/joystick_linuxinput.c @@ -100,7 +100,7 @@ struct JoyDev { GUID guid; GUID guid_product; - BOOL has_ff; + BOOL has_ff, is_joystick; int num_effects; /* data returned by EVIOCGBIT for caps, EV_ABS, EV_KEY, and EV_FF */ @@ -243,6 +243,24 @@ static void find_joydevs(void) continue; } + /* in lieu of properly reporting HID usage, detect presence of + * "joystick buttons" and report those devices as joysticks instead of + * gamepads */ + joydev.is_joystick = + test_bit(joydev.keybits, BTN_TRIGGER) || + test_bit(joydev.keybits, BTN_THUMB) || + test_bit(joydev.keybits, BTN_THUMB2) || + test_bit(joydev.keybits, BTN_TOP) || + test_bit(joydev.keybits, BTN_TOP2) || + test_bit(joydev.keybits, BTN_PINKIE) || + test_bit(joydev.keybits, BTN_BASE) || + test_bit(joydev.keybits, BTN_BASE2) || + test_bit(joydev.keybits, BTN_BASE3) || + test_bit(joydev.keybits, BTN_BASE4) || + test_bit(joydev.keybits, BTN_BASE5) || + test_bit(joydev.keybits, BTN_BASE6) || + test_bit(joydev.keybits, BTN_DEAD); + if (!(joydev.device = HeapAlloc(GetProcessHeap(), 0, strlen(buf) + 1))) { close(fd); @@ -350,7 +368,7 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver lpddi->guidInstance = joydevs[id].guid; lpddi->guidProduct = joydevs[id].guid_product; lpddi->guidFFDriver = GUID_NULL; - lpddi->dwDevType = get_device_type(version); + lpddi->dwDevType = get_device_type(version, joydevs[id].is_joystick); /* Assume the joystick as HID if it is attached to USB bus and has a valid VID/PID */ if (joydevs[id].bus_type == BUS_USB && @@ -358,7 +376,10 @@ static void fill_joystick_dideviceinstanceW(LPDIDEVICEINSTANCEW lpddi, DWORD ver { lpddi->dwDevType |= DIDEVTYPE_HID; lpddi->wUsagePage = 0x01; /* Desktop */ - lpddi->wUsage = 0x05; /* Game Pad */ + if (joydevs[id].is_joystick) + lpddi->wUsage = 0x04; /* Joystick */ + else + lpddi->wUsage = 0x05; /* Game Pad */ } MultiByteToWideChar(CP_ACP, 0, joydevs[id].name, -1, lpddi->tszInstanceName, MAX_PATH); diff --git a/dlls/dinput/joystick_osx.c b/dlls/dinput/joystick_osx.c index aad60765cfb..a448818bb9c 100644 --- a/dlls/dinput/joystick_osx.c +++ b/dlls/dinput/joystick_osx.c @@ -945,6 +945,7 @@ static DWORD make_vid_pid(IOHIDDeviceRef device) static HRESULT joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINSTANCEA lpddi, DWORD version, int id) { IOHIDDeviceRef device; + BOOL is_joystick; TRACE("dwDevType %u dwFlags 0x%08x version 0x%04x id %d\n", dwDevType, dwFlags, version, id); @@ -962,15 +963,19 @@ static HRESULT joydev_enum_deviceA(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINS if(get_ff(device, NULL) != S_OK) return S_FALSE; } + is_joystick = get_device_property_long(device, CFSTR(kIOHIDDeviceUsageKey)) == kHIDUsage_GD_Joystick; /* Return joystick */ lpddi->guidInstance = DInput_Wine_OsX_Joystick_GUID; lpddi->guidInstance.Data3 = id; lpddi->guidProduct = DInput_Wine_OsX_Joystick_GUID; lpddi->guidProduct.Data1 = make_vid_pid(device); - lpddi->dwDevType = get_device_type(version); + lpddi->dwDevType = get_device_type(version, is_joystick); lpddi->dwDevType |= DIDEVTYPE_HID; lpddi->wUsagePage = 0x01; /* Desktop */ - lpddi->wUsage = 0x05; /* Game Pad */ + if (is_joystick) + lpddi->wUsage = 0x04; /* Joystick */ + else + lpddi->wUsage = 0x05; /* Game Pad */ sprintf(lpddi->tszInstanceName, "Joystick %d", id); /* get the device name */ @@ -988,6 +993,7 @@ static HRESULT joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINS char name[MAX_PATH]; char friendly[32]; IOHIDDeviceRef device; + BOOL is_joystick; TRACE("dwDevType %u dwFlags 0x%08x version 0x%04x id %d\n", dwDevType, dwFlags, version, id); @@ -1005,14 +1011,22 @@ static HRESULT joydev_enum_deviceW(DWORD dwDevType, DWORD dwFlags, LPDIDEVICEINS if(get_ff(device, NULL) != S_OK) return S_FALSE; } + is_joystick = get_device_property_long(device, CFSTR(kIOHIDDeviceUsageKey)) == kHIDUsage_GD_Joystick; /* Return joystick */ lpddi->guidInstance = DInput_Wine_OsX_Joystick_GUID; lpddi->guidInstance.Data3 = id; lpddi->guidProduct = DInput_Wine_OsX_Joystick_GUID; lpddi->guidProduct.Data1 = make_vid_pid(device); - lpddi->dwDevType = get_device_type(version); + lpddi->dwDevType = get_device_type(version, is_joystick); + lpddi->dwDevType |= DIDEVTYPE_HID; + lpddi->wUsagePage = 0x01; /* Desktop */ + if (is_joystick) + lpddi->wUsage = 0x04; /* Joystick */ + else + lpddi->wUsage = 0x05; /* Game Pad */ sprintf(friendly, "Joystick %d", id); MultiByteToWideChar(CP_ACP, 0, friendly, -1, lpddi->tszInstanceName, MAX_PATH); + /* get the device name */ get_osx_device_name(id, name, MAX_PATH); -- 2.21.0

1 0

[PATCH vkd3d 5/6] vkd3d: Try to guess application name.
by Józef Kucia 07 May '19

07 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 7 +++++-- libs/vkd3d/utils.c | 31 +++++++++++++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 2 ++ 3 files changed, 38 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 3476fdead708..4b5e4492ac3f 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -527,8 +527,6 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; application_info.pNext = NULL; - application_info.pApplicationName = NULL; - application_info.applicationVersion = 0; application_info.pEngineName = PACKAGE_NAME; application_info.engineVersion = vkd3d_get_vk_version(); application_info.apiVersion = VK_API_VERSION_1_0; @@ -543,6 +541,11 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, application_info.engineVersion = vkd3d_application_info->engine_version; } } + else + { + application_info.pApplicationName = vkd3d_get_program_name(); + application_info.applicationVersion = 0; + } if (!(extensions = vkd3d_calloc(extension_count, sizeof(*extensions)))) { diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index ea468b37d37d..21919815537a 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -602,6 +602,37 @@ HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs, return S_OK; } +const char *vkd3d_get_program_name(void) +{ +#ifdef _GNU_SOURCE + char *name; + + if ((name = strrchr(program_invocation_name, '/'))) + { + const char *path = realpath("/proc/self/exe", NULL); + + /* Try to strip command line arguments. */ + if (path && !strncmp(path, program_invocation_name, strlen(path))) + { + const char *p = strrchr(path, '/'); + + if (p) + return p + 1; + } + + return name + 1; + } + + if ((name = strrchr(program_invocation_name, '\\'))) + return name + 1; + + return program_invocation_name; + +#else + return NULL; +#endif +} + static struct vkd3d_private_data *vkd3d_private_store_get_private_data( const struct vkd3d_private_store *store, const GUID *tag) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 057a0a7c0dea..da177d346ec9 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -1126,6 +1126,8 @@ HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs, extern const char vkd3d_build[]; +const char *vkd3d_get_program_name(void) DECLSPEC_HIDDEN; + static inline void vkd3d_set_thread_name(const char *name) { #if defined(HAVE_PTHREAD_SETNAME_NP_2) -- 2.21.0

1 0

[PATCH vkd3d 4/6] vkd3d: Introduce vkd3d_application_info.
by Józef Kucia 07 May '19

07 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- include/vkd3d.h | 14 ++++++++++++++ libs/vkd3d/device.c | 35 ++++++++++++++++++++++++++++++++--- tests/vkd3d_api.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 90 insertions(+), 3 deletions(-) diff --git a/include/vkd3d.h b/include/vkd3d.h index 24cb34eb3c34..b78076e43927 100644 --- a/include/vkd3d.h +++ b/include/vkd3d.h @@ -43,6 +43,7 @@ enum vkd3d_structure_type VKD3D_STRUCTURE_TYPE_OPTIONAL_INSTANCE_EXTENSIONS_INFO, VKD3D_STRUCTURE_TYPE_OPTIONAL_DEVICE_EXTENSIONS_INFO, + VKD3D_STRUCTURE_TYPE_APPLICATION_INFO, VKD3D_FORCE_32_BIT_ENUM(VKD3D_STRUCTURE_TYPE), }; @@ -83,6 +84,19 @@ struct vkd3d_optional_instance_extensions_info uint32_t extension_count; }; +/* Extends vkd3d_instance_create_info. */ +struct vkd3d_application_info +{ + enum vkd3d_structure_type type; + const void *next; + + const char *application_name; + uint32_t application_version; + + const char *engine_name; /* "vkd3d" if NULL */ + uint32_t engine_version; /* vkd3d version if engine_name is NULL */ +}; + struct vkd3d_device_create_info { enum vkd3d_structure_type type; diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index a107e1e6414c..3476fdead708 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -18,6 +18,8 @@ #include "vkd3d_private.h" +#include <ctype.h> + #ifdef HAVE_DLFCN_H #include <dlfcn.h> @@ -104,6 +106,21 @@ static void *vk_find_struct_(struct vk_struct *chain, VkStructureType sType) return NULL; } +static uint32_t vkd3d_get_vk_version(void) +{ + const char *ptr = PACKAGE_VERSION; + int major, minor; + + major = atoi(ptr); + + while (isdigit(*ptr) || *ptr == '.') + ++ptr; + + minor = atoi(ptr); + + return VK_MAKE_VERSION(major, minor, 0); +} + struct vkd3d_optional_extension_info { const char *extension_name; @@ -459,6 +476,7 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, { const struct vkd3d_vk_global_procs *vk_global_procs = &instance->vk_global_procs; const struct vkd3d_optional_instance_extensions_info *optional_extensions; + const struct vkd3d_application_info *vkd3d_application_info; bool *user_extension_supported = NULL; VkApplicationInfo application_info; VkInstanceCreateInfo instance_info; @@ -509,12 +527,23 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; application_info.pNext = NULL; - application_info.pApplicationName = PACKAGE_NAME; + application_info.pApplicationName = NULL; application_info.applicationVersion = 0; - application_info.pEngineName = NULL; - application_info.engineVersion = 0; + application_info.pEngineName = PACKAGE_NAME; + application_info.engineVersion = vkd3d_get_vk_version(); application_info.apiVersion = VK_API_VERSION_1_0; + if ((vkd3d_application_info = vkd3d_find_struct(create_info->next, APPLICATION_INFO))) + { + application_info.pApplicationName = vkd3d_application_info->application_name; + application_info.applicationVersion = vkd3d_application_info->application_version; + if (vkd3d_application_info->engine_name) + { + application_info.pEngineName = vkd3d_application_info->engine_name; + application_info.engineVersion = vkd3d_application_info->engine_version; + } + } + if (!(extensions = vkd3d_calloc(extension_count, sizeof(*extensions)))) { if (instance->libvulkan) diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index 14d0914512bc..5acec56d8646 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -1052,6 +1052,49 @@ static void test_formats(void) } } +static void test_application_info(void) +{ + struct vkd3d_instance_create_info create_info; + struct vkd3d_application_info app_info; + struct vkd3d_instance *instance; + ULONG refcount; + HRESULT hr; + + app_info.type = VKD3D_STRUCTURE_TYPE_APPLICATION_INFO; + app_info.next = NULL; + app_info.engine_name = NULL; + app_info.engine_version = 0; + app_info.application_name = NULL; + app_info.application_version = 0; + + create_info = instance_default_create_info; + create_info.next = &app_info; + hr = vkd3d_create_instance(&create_info, &instance); + ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr); + refcount = vkd3d_instance_decref(instance); + ok(!refcount, "Instance has %u references left.\n", refcount); + + app_info.application_name = "vkd3d_api_tests"; + app_info.application_version = 0xdeadbeef; + hr = vkd3d_create_instance(&create_info, &instance); + ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr); + refcount = vkd3d_instance_decref(instance); + ok(!refcount, "Instance has %u references left.\n", refcount); + + app_info.engine_name = "engine_name"; + hr = vkd3d_create_instance(&create_info, &instance); + ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr); + refcount = vkd3d_instance_decref(instance); + ok(!refcount, "Instance has %u references left.\n", refcount); + + app_info.engine_name = "engine_name"; + app_info.engine_version = 2; + hr = vkd3d_create_instance(&create_info, &instance); + ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr); + refcount = vkd3d_instance_decref(instance); + ok(!refcount, "Instance has %u references left.\n", refcount); +} + static bool have_d3d12_device(void) { ID3D12Device *device; @@ -1083,4 +1126,5 @@ START_TEST(vkd3d_api) run_test(test_external_resource_map); run_test(test_external_resource_present_state); run_test(test_formats); + run_test(test_application_info); } -- 2.21.0

1 0

[PATCH 1/4] mfplat: Write attribute store when registering MFT.
by Nikolay Sivov 07 May '19

07 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mfplat/main.c | 68 ++++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 26 deletions(-) diff --git a/dlls/mfplat/main.c b/dlls/mfplat/main.c index 61521ce779..4f634e0d82 100644 --- a/dlls/mfplat/main.c +++ b/dlls/mfplat/main.c @@ -70,6 +70,7 @@ static const WCHAR categories_keyW[] = {'M','e','d','i','a','F','o','u','n','d', 'C','a','t','e','g','o','r','i','e','s',0}; static const WCHAR inputtypesW[] = {'I','n','p','u','t','T','y','p','e','s',0}; static const WCHAR outputtypesW[] = {'O','u','t','p','u','t','T','y','p','e','s',0}; +static const WCHAR attributesW[] = {'A','t','t','r','i','b','u','t','e','s',0}; static const WCHAR szGUIDFmt[] = { '%','0','8','x','-','%','0','4','x','-','%','0','4','x','-','%','0', @@ -166,46 +167,65 @@ BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) return TRUE; } -static HRESULT register_transform(CLSID *clsid, WCHAR *name, - UINT32 cinput, MFT_REGISTER_TYPE_INFO *input_types, - UINT32 coutput, MFT_REGISTER_TYPE_INFO *output_types) +static HRESULT register_transform(const CLSID *clsid, const WCHAR *name, + UINT32 cinput, const MFT_REGISTER_TYPE_INFO *input_types, UINT32 coutput, + const MFT_REGISTER_TYPE_INFO *output_types, IMFAttributes *attributes) { static const WCHAR reg_format[] = {'%','s','\\','%','s',0}; + HRESULT hr = S_OK; HKEY hclsid = 0; WCHAR buffer[64]; - DWORD size; + DWORD size, ret; WCHAR str[250]; + UINT8 *blob; GUIDToString(buffer, clsid); sprintfW(str, reg_format, transform_keyW, buffer); - if (RegCreateKeyW(HKEY_CLASSES_ROOT, str, &hclsid)) - return E_FAIL; + if ((ret = RegCreateKeyW(HKEY_CLASSES_ROOT, str, &hclsid))) + hr = HRESULT_FROM_WIN32(ret); - size = (strlenW(name) + 1) * sizeof(WCHAR); - if (RegSetValueExW(hclsid, NULL, 0, REG_SZ, (BYTE *)name, size)) - goto err; + if (SUCCEEDED(hr)) + { + size = (strlenW(name) + 1) * sizeof(WCHAR); + if ((ret = RegSetValueExW(hclsid, NULL, 0, REG_SZ, (BYTE *)name, size))) + hr = HRESULT_FROM_WIN32(ret); + } - if (cinput && input_types) + if (SUCCEEDED(hr) && cinput && input_types) { size = cinput * sizeof(MFT_REGISTER_TYPE_INFO); - if (RegSetValueExW(hclsid, inputtypesW, 0, REG_BINARY, (BYTE *)input_types, size)) - goto err; + if ((ret = RegSetValueExW(hclsid, inputtypesW, 0, REG_BINARY, (BYTE *)input_types, size))) + hr = HRESULT_FROM_WIN32(ret); } - if (coutput && output_types) + if (SUCCEEDED(hr) && coutput && output_types) { size = coutput * sizeof(MFT_REGISTER_TYPE_INFO); - if (RegSetValueExW(hclsid, outputtypesW, 0, REG_BINARY, (BYTE *)output_types, size)) - goto err; + if ((ret = RegSetValueExW(hclsid, outputtypesW, 0, REG_BINARY, (BYTE *)output_types, size))) + hr = HRESULT_FROM_WIN32(ret); } - RegCloseKey(hclsid); - return S_OK; + if (SUCCEEDED(hr) && attributes) + { + if (SUCCEEDED(hr = MFGetAttributesAsBlobSize(attributes, &size))) + { + if ((blob = heap_alloc(size))) + { + if (SUCCEEDED(hr = MFGetAttributesAsBlob(attributes, blob, size))) + { + if ((ret = RegSetValueExW(hclsid, attributesW, 0, REG_BINARY, blob, size))) + hr = HRESULT_FROM_WIN32(ret); + } + heap_free(blob); + } + else + hr = E_OUTOFMEMORY; + } + } -err: RegCloseKey(hclsid); - return E_FAIL; + return hr; } static HRESULT register_category(CLSID *clsid, GUID *category) @@ -236,17 +256,13 @@ HRESULT WINAPI MFTRegister(CLSID clsid, GUID category, LPWSTR name, UINT32 flags { HRESULT hr; - TRACE("(%s, %s, %s, %x, %u, %p, %u, %p, %p)\n", debugstr_guid(&clsid), debugstr_guid(&category), - debugstr_w(name), flags, cinput, input_types, - coutput, output_types, attributes); - - if (attributes) - FIXME("attributes not yet supported.\n"); + TRACE("%s, %s, %s, %#x, %u, %p, %u, %p, %p.\n", debugstr_guid(&clsid), debugstr_guid(&category), + debugstr_w(name), flags, cinput, input_types, coutput, output_types, attributes); if (flags) FIXME("flags not yet supported.\n"); - hr = register_transform(&clsid, name, cinput, input_types, coutput, output_types); + hr = register_transform(&clsid, name, cinput, input_types, coutput, output_types, attributes); if(FAILED(hr)) ERR("Failed to write register transform\n"); -- 2.20.1

2 4

[PATCH] mshtml: Implement HTMLStyleSheetRulesCollection::item.
by Jacek Caban 07 May '19

07 May '19

From: Dmitry Timoshkov <dmitry(a)baikal.ru> Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmlstylesheet.c | 188 +++++++++++++++++++++++++++++++++- dlls/mshtml/mshtml_private.h | 2 + dlls/mshtml/tests/dom.c | 16 +++ dlls/mshtml/tests/elements.js | 19 ++++ 4 files changed, 223 insertions(+), 2 deletions(-)

1 0

[PATCH] mshtml: Implement HTMLStyleSheetRulesCollection::item.
by Jacek Caban 07 May '19

07 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmlstylesheet.c | 188 +++++++++++++++++++++++++++++++++- dlls/mshtml/mshtml_private.h | 2 + dlls/mshtml/tests/dom.c | 16 +++ dlls/mshtml/tests/elements.js | 19 ++++ 4 files changed, 223 insertions(+), 2 deletions(-)

1 1

[PATCH v2] mshtml: Implement HTMLStyleSheetRulesCollection::item.
by Dmitry Timoshkov 07 May '19

07 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/mshtml/htmlstylesheet.c | 187 ++++++++++++++++++++++++++++++++++- dlls/mshtml/mshtml_private.h | 2 + 2 files changed, 187 insertions(+), 2 deletions(-) diff --git a/dlls/mshtml/htmlstylesheet.c b/dlls/mshtml/htmlstylesheet.c index b0e024cfed..19289eb2e9 100644 --- a/dlls/mshtml/htmlstylesheet.c +++ b/dlls/mshtml/htmlstylesheet.c @@ -59,6 +59,176 @@ struct HTMLStyleSheetRulesCollection { nsIDOMCSSRuleList *nslist; }; +struct HTMLStyleSheetRule { + DispatchEx dispex; + IHTMLStyleSheetRule IHTMLStyleSheetRule_iface; + + LONG ref; + + nsIDOMCSSRule *nsstylesheetrule; +}; + +static inline HTMLStyleSheetRule *impl_from_IHTMLStyleSheetRule(IHTMLStyleSheetRule *iface) +{ + return CONTAINING_RECORD(iface, HTMLStyleSheetRule, IHTMLStyleSheetRule_iface); +} + +static HRESULT WINAPI HTMLStyleSheetRule_QueryInterface(IHTMLStyleSheetRule *iface, + REFIID riid, void **ppv) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + + TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv); + + if (IsEqualGUID(&IID_IUnknown, riid)) + *ppv = &This->IHTMLStyleSheetRule_iface; + else if (IsEqualGUID(&IID_IHTMLStyleSheetRule, riid)) + *ppv = &This->IHTMLStyleSheetRule_iface; + else if (dispex_query_interface(&This->dispex, riid, ppv)) + return *ppv ? S_OK : E_NOINTERFACE; + else + { + *ppv = NULL; + FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv); + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*ppv); + return S_OK; +} + +static ULONG WINAPI HTMLStyleSheetRule_AddRef(IHTMLStyleSheetRule *iface) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG WINAPI HTMLStyleSheetRule_Release(IHTMLStyleSheetRule *iface) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + release_dispex(&This->dispex); + if(This->nsstylesheetrule) + nsIDOMCSSRule_Release(This->nsstylesheetrule); + heap_free(This); + } + + return ref; +} + +static HRESULT WINAPI HTMLStyleSheetRule_GetTypeInfoCount( + IHTMLStyleSheetRule *iface, UINT *pctinfo) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo); +} + +static HRESULT WINAPI HTMLStyleSheetRule_GetTypeInfo(IHTMLStyleSheetRule *iface, + UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo); +} + +static HRESULT WINAPI HTMLStyleSheetRule_GetIDsOfNames(IHTMLStyleSheetRule *iface, + REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames, + lcid, rgDispId); +} + +static HRESULT WINAPI HTMLStyleSheetRule_Invoke(IHTMLStyleSheetRule *iface, + DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, + VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags, + pDispParams, pVarResult, pExcepInfo, puArgErr); +} + +static HRESULT WINAPI HTMLStyleSheetRule_put_selectorText(IHTMLStyleSheetRule *iface, BSTR v) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI HTMLStyleSheetRule_get_selectorText(IHTMLStyleSheetRule *iface, BSTR *p) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI HTMLStyleSheetRule_get_style(IHTMLStyleSheetRule *iface, IHTMLRuleStyle **p) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI HTMLStyleSheetRule_get_readOnly(IHTMLStyleSheetRule *iface, VARIANT_BOOL *p) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static const IHTMLStyleSheetRuleVtbl HTMLStyleSheetRuleVtbl = { + HTMLStyleSheetRule_QueryInterface, + HTMLStyleSheetRule_AddRef, + HTMLStyleSheetRule_Release, + HTMLStyleSheetRule_GetTypeInfoCount, + HTMLStyleSheetRule_GetTypeInfo, + HTMLStyleSheetRule_GetIDsOfNames, + HTMLStyleSheetRule_Invoke, + HTMLStyleSheetRule_put_selectorText, + HTMLStyleSheetRule_get_selectorText, + HTMLStyleSheetRule_get_style, + HTMLStyleSheetRule_get_readOnly +}; + +static const tid_t HTMLStyleSheetRule_iface_tids[] = { + IHTMLStyleSheetRule_tid, + 0 +}; +static dispex_static_data_t HTMLStyleSheetRule_dispex = { + NULL, + DispHTMLStyleSheetRule_tid, + HTMLStyleSheetRule_iface_tids +}; + +static IHTMLStyleSheetRule *HTMLStyleSheetRule_Create(nsIDOMCSSRule *nsstylesheetrule) +{ + HTMLStyleSheetRule *ret = heap_alloc(sizeof(*ret)); + nsresult nsres; + + ret->IHTMLStyleSheetRule_iface.lpVtbl = &HTMLStyleSheetRuleVtbl; + ret->ref = 1; + ret->nsstylesheetrule = NULL; + + init_dispex(&ret->dispex, (IUnknown *)&ret->IHTMLStyleSheetRule_iface, &HTMLStyleSheetRule_dispex); + + if (nsstylesheetrule) + { + nsres = nsIDOMCSSRule_QueryInterface(nsstylesheetrule, &IID_nsIDOMCSSRule, + (void **)&ret->nsstylesheetrule); + if (NS_FAILED(nsres)) + ERR("Could not get nsIDOMCSSRule interface: %08x\n", nsres); + } + + return &ret->IHTMLStyleSheetRule_iface; +} + static inline HTMLStyleSheetRulesCollection *impl_from_IHTMLStyleSheetRulesCollection(IHTMLStyleSheetRulesCollection *iface) { return CONTAINING_RECORD(iface, HTMLStyleSheetRulesCollection, IHTMLStyleSheetRulesCollection_iface); @@ -169,8 +339,21 @@ static HRESULT WINAPI HTMLStyleSheetRulesCollection_item(IHTMLStyleSheetRulesCol LONG index, IHTMLStyleSheetRule **ppHTMLStyleSheetRule) { HTMLStyleSheetRulesCollection *This = impl_from_IHTMLStyleSheetRulesCollection(iface); - FIXME("(%p)->(%d %p)\n", This, index, ppHTMLStyleSheetRule); - return E_NOTIMPL; + nsIDOMCSSRule *nsstylesheetrule; + nsresult nsres; + + TRACE("(%p)->(%d %p)\n", This, index, ppHTMLStyleSheetRule); + + nsres = nsIDOMCSSRuleList_Item(This->nslist, index, &nsstylesheetrule); + if (NS_FAILED(nsres) || !nsstylesheetrule) + { + WARN("Item failed: %08x\n", nsres); + *ppHTMLStyleSheetRule = NULL; + return E_INVALIDARG; + } + + *ppHTMLStyleSheetRule = HTMLStyleSheetRule_Create(nsstylesheetrule); + return S_OK; } static const IHTMLStyleSheetRulesCollectionVtbl HTMLStyleSheetRulesCollectionVtbl = { diff --git a/dlls/mshtml/mshtml_private.h b/dlls/mshtml/mshtml_private.h index f4bbe76ff0..5b94d075cb 100644 --- a/dlls/mshtml/mshtml_private.h +++ b/dlls/mshtml/mshtml_private.h @@ -121,6 +121,7 @@ typedef struct EventTarget EventTarget; XDIID(DispHTMLStyle) \ XDIID(DispHTMLStyleElement) \ XDIID(DispHTMLStyleSheet) \ + XDIID(DispHTMLStyleSheetRule) \ XDIID(DispHTMLStyleSheetRulesCollection) \ XDIID(DispHTMLStyleSheetsCollection) \ XDIID(DispHTMLTable) \ @@ -230,6 +231,7 @@ typedef struct EventTarget EventTarget; XIID(IHTMLStyle6) \ XIID(IHTMLStyleElement) \ XIID(IHTMLStyleSheet) \ + XIID(IHTMLStyleSheetRule) \ XIID(IHTMLStyleSheetRulesCollection) \ XIID(IHTMLStyleSheetsCollection) \ XIID(IHTMLTable) \ -- 2.20.1

2 1

[PATCH] mshtml: Implement HTMLStyleSheetRulesCollection::item.
by Dmitry Timoshkov 07 May '19

07 May '19

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/mshtml/htmlstylesheet.c | 188 ++++++++++++++++++++++++++++++++++- dlls/mshtml/mshtml_private.h | 2 + 2 files changed, 188 insertions(+), 2 deletions(-) diff --git a/dlls/mshtml/htmlstylesheet.c b/dlls/mshtml/htmlstylesheet.c index b0e024cfed..e2e08a7eef 100644 --- a/dlls/mshtml/htmlstylesheet.c +++ b/dlls/mshtml/htmlstylesheet.c @@ -59,6 +59,176 @@ struct HTMLStyleSheetRulesCollection { nsIDOMCSSRuleList *nslist; }; +struct HTMLStyleSheetRule { + DispatchEx dispex; + IHTMLStyleSheetRule IHTMLStyleSheetRule_iface; + + LONG ref; + + nsIDOMCSSRule *nsstylesheetrule; +}; + +static inline HTMLStyleSheetRule *impl_from_IHTMLStyleSheetRule(IHTMLStyleSheetRule *iface) +{ + return CONTAINING_RECORD(iface, HTMLStyleSheetRule, IHTMLStyleSheetRule_iface); +} + +static HRESULT WINAPI HTMLStyleSheetRule_QueryInterface(IHTMLStyleSheetRule *iface, + REFIID riid, void **ppv) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + + TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv); + + if (IsEqualGUID(&IID_IUnknown, riid)) + *ppv = &This->IHTMLStyleSheetRule_iface; + else if (IsEqualGUID(&IID_IHTMLStyleSheetRule, riid)) + *ppv = &This->IHTMLStyleSheetRule_iface; + else if (dispex_query_interface(&This->dispex, riid, ppv)) + return *ppv ? S_OK : E_NOINTERFACE; + else + { + *ppv = NULL; + FIXME("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv); + return E_NOINTERFACE; + } + + IUnknown_AddRef((IUnknown *)*ppv); + return S_OK; +} + +static ULONG WINAPI HTMLStyleSheetRule_AddRef(IHTMLStyleSheetRule *iface) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + LONG ref = InterlockedIncrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + return ref; +} + +static ULONG WINAPI HTMLStyleSheetRule_Release(IHTMLStyleSheetRule *iface) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + LONG ref = InterlockedDecrement(&This->ref); + + TRACE("(%p) ref=%d\n", This, ref); + + if(!ref) { + release_dispex(&This->dispex); + if(This->nsstylesheetrule) + nsIDOMCSSRule_Release(This->nsstylesheetrule); + heap_free(This); + } + + return ref; +} + +static HRESULT WINAPI HTMLStyleSheetRule_GetTypeInfoCount( + IHTMLStyleSheetRule *iface, UINT *pctinfo) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo); +} + +static HRESULT WINAPI HTMLStyleSheetRule_GetTypeInfo(IHTMLStyleSheetRule *iface, + UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo); +} + +static HRESULT WINAPI HTMLStyleSheetRule_GetIDsOfNames(IHTMLStyleSheetRule *iface, + REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames, + lcid, rgDispId); +} + +static HRESULT WINAPI HTMLStyleSheetRule_Invoke(IHTMLStyleSheetRule *iface, + DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, + VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags, + pDispParams, pVarResult, pExcepInfo, puArgErr); +} + +static HRESULT WINAPI HTMLStyleSheetRule_put_selectorText(IHTMLStyleSheetRule *iface, BSTR v) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%s)\n", This, debugstr_w(v)); + return E_NOTIMPL; +} + +static HRESULT WINAPI HTMLStyleSheetRule_get_selectorText(IHTMLStyleSheetRule *iface, BSTR *p) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI HTMLStyleSheetRule_get_style(IHTMLStyleSheetRule *iface, IHTMLRuleStyle **p) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static HRESULT WINAPI HTMLStyleSheetRule_get_readOnly(IHTMLStyleSheetRule *iface, VARIANT_BOOL *p) +{ + HTMLStyleSheetRule *This = impl_from_IHTMLStyleSheetRule(iface); + FIXME("(%p)->(%p)\n", This, p); + return E_NOTIMPL; +} + +static const IHTMLStyleSheetRuleVtbl HTMLStyleSheetRuleVtbl = { + HTMLStyleSheetRule_QueryInterface, + HTMLStyleSheetRule_AddRef, + HTMLStyleSheetRule_Release, + HTMLStyleSheetRule_GetTypeInfoCount, + HTMLStyleSheetRule_GetTypeInfo, + HTMLStyleSheetRule_GetIDsOfNames, + HTMLStyleSheetRule_Invoke, + HTMLStyleSheetRule_put_selectorText, + HTMLStyleSheetRule_get_selectorText, + HTMLStyleSheetRule_get_style, + HTMLStyleSheetRule_get_readOnly +}; + +static const tid_t HTMLStyleSheetRule_iface_tids[] = { + IHTMLStyleSheetRule_tid, + 0 +}; +static dispex_static_data_t HTMLStyleSheetRule_dispex = { + NULL, + DispHTMLStyleSheetRule_tid, + HTMLStyleSheetRule_iface_tids +}; + +static IHTMLStyleSheetRule *HTMLStyleSheetRule_Create(nsIDOMCSSRule *nsstylesheetrule) +{ + HTMLStyleSheetRule *ret = heap_alloc(sizeof(*ret)); + nsresult nsres; + + ret->IHTMLStyleSheetRule_iface.lpVtbl = &HTMLStyleSheetRuleVtbl; + ret->ref = 1; + ret->nsstylesheetrule = NULL; + + init_dispex(&ret->dispex, (IUnknown *)&ret->IHTMLStyleSheetRule_iface, &HTMLStyleSheetRule_dispex); + + if (nsstylesheetrule) + { + nsres = nsIDOMCSSRule_QueryInterface(nsstylesheetrule, &IID_nsIDOMCSSRule, + (void **)&ret->nsstylesheetrule); + if (NS_FAILED(nsres)) + ERR("Could not get nsIDOMCSSRule interface: %08x\n", nsres); + } + + return &ret->IHTMLStyleSheetRule_iface; +} + static inline HTMLStyleSheetRulesCollection *impl_from_IHTMLStyleSheetRulesCollection(IHTMLStyleSheetRulesCollection *iface) { return CONTAINING_RECORD(iface, HTMLStyleSheetRulesCollection, IHTMLStyleSheetRulesCollection_iface); @@ -169,8 +339,22 @@ static HRESULT WINAPI HTMLStyleSheetRulesCollection_item(IHTMLStyleSheetRulesCol LONG index, IHTMLStyleSheetRule **ppHTMLStyleSheetRule) { HTMLStyleSheetRulesCollection *This = impl_from_IHTMLStyleSheetRulesCollection(iface); - FIXME("(%p)->(%d %p)\n", This, index, ppHTMLStyleSheetRule); - return E_NOTIMPL; + nsIDOMCSSRule *nsstylesheetrule; + nsresult nsres; + + TRACE("(%p)->(%d %p)\n", This, index, ppHTMLStyleSheetRule); + + nsres = nsIDOMCSSRuleList_Item(This->nslist, index, &nsstylesheetrule); + if (NS_FAILED(nsres) || !nsstylesheetrule) + { + WARN("Item failed: %08x\n", nsres); + /* The function returns S_OK even if the element is not found */ + *ppHTMLStyleSheetRule = NULL; + } + else + *ppHTMLStyleSheetRule = HTMLStyleSheetRule_Create(nsstylesheetrule); + + return S_OK; } static const IHTMLStyleSheetRulesCollectionVtbl HTMLStyleSheetRulesCollectionVtbl = { diff --git a/dlls/mshtml/mshtml_private.h b/dlls/mshtml/mshtml_private.h index f4bbe76ff0..5b94d075cb 100644 --- a/dlls/mshtml/mshtml_private.h +++ b/dlls/mshtml/mshtml_private.h @@ -121,6 +121,7 @@ typedef struct EventTarget EventTarget; XDIID(DispHTMLStyle) \ XDIID(DispHTMLStyleElement) \ XDIID(DispHTMLStyleSheet) \ + XDIID(DispHTMLStyleSheetRule) \ XDIID(DispHTMLStyleSheetRulesCollection) \ XDIID(DispHTMLStyleSheetsCollection) \ XDIID(DispHTMLTable) \ @@ -230,6 +231,7 @@ typedef struct EventTarget EventTarget; XIID(IHTMLStyle6) \ XIID(IHTMLStyleElement) \ XIID(IHTMLStyleSheet) \ + XIID(IHTMLStyleSheetRule) \ XIID(IHTMLStyleSheetRulesCollection) \ XIID(IHTMLStyleSheetsCollection) \ XIID(IHTMLTable) \ -- 2.20.1

2 2

[PATCH v3 1/2] mspatcha: Implement ApplyPatchToFile and related functions.
by Conor McCarthy 07 May '19

07 May '19

This can patch non-executables and 64-bit executable files, but patching of 32-bit executables is not supported. They are subject to special processing which alters PE relocations to match with those in the old file to improve compression. To reverse this, the meaning of the decoding data must be interpreted. Details, including where to find that data in the patch file, are included in pa19.c. Interleaved decompression of large files is also not supported. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=12501 Signed-off-by: Conor McCarthy <conor.mccarthy.444(a)gmail.com> --- dlls/mspatcha/Makefile.in | 4 +- dlls/mspatcha/lzxd_dec.c | 776 ++++++++++++++++++++++++++++++ dlls/mspatcha/lzxd_dec.h | 27 ++ dlls/mspatcha/mspatcha.spec | 28 +- dlls/mspatcha/mspatcha_main.c | 247 ++++++++-- dlls/mspatcha/pa19.c | 1060 +++++++++++++++++++++++++++++++++++++++++ dlls/mspatcha/pa19.h | 52 ++ include/patchapi.h | 73 +++ 8 files changed, 2223 insertions(+), 44 deletions(-) create mode 100755 dlls/mspatcha/lzxd_dec.c create mode 100755 dlls/mspatcha/lzxd_dec.h create mode 100755 dlls/mspatcha/pa19.c create mode 100755 dlls/mspatcha/pa19.h diff --git a/dlls/mspatcha/Makefile.in b/dlls/mspatcha/Makefile.in index bd0da7d..34cf719 100644 --- a/dlls/mspatcha/Makefile.in +++ b/dlls/mspatcha/Makefile.in @@ -2,6 +2,8 @@ MODULE = mspatcha.dll IMPORTLIB = mspatcha C_SRCS = \ - mspatcha_main.c + mspatcha_main.c \ + pa19.c \ + lzxd_dec.c RC_SRCS = version.rc diff --git a/dlls/mspatcha/lzxd_dec.c b/dlls/mspatcha/lzxd_dec.c new file mode 100755 index 0000000..b391467 --- /dev/null +++ b/dlls/mspatcha/lzxd_dec.c @@ -0,0 +1,776 @@ +/* + * LZXD decoder + * + * Copyright 2019 Conor McCarthy + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * TODO + * - Implememnt interleaved decoding + */ + +#include "config.h" + +#include <stdarg.h> +#include <stdlib.h> +#include <assert.h> + +#include "windef.h" +#include "winbase.h" +#include "wine/debug.h" + +#include "patchapi.h" + +#include "lzxd_dec.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mspatcha); + + +#define ELEM_SIZE 2 +#define MAX_CODE_LEN 16 +#define MAX_ALIGN_CODE_LEN 7 +#define PRE_LEN_BITS 4 +#define MAX_PRE_CODE_LEN ((1 << PRE_LEN_BITS) - 1) +#define MAIN_TABLE_SIZE (1 << MAX_CODE_LEN) +#define ALIGN_TABLE_SIZE (1 << MAX_ALIGN_CODE_LEN) +#define HUFF_ERROR 0xFFFF +#define REP_COUNT 3 +#define MAX_POS_SLOTS 290 +#define ALIGN_CODE_COUNT 8 +#define PRE_LEN_CODE_COUNT 20 +#define MAIN_CODE_COUNT(slots) (256 + 8 * (slots)) +#define MAX_MAIN_CODES MAIN_CODE_COUNT(MAX_POS_SLOTS) +#define LEN_CODE_COUNT 249 +#define MAX_CHUNK_UNCOMPRESSED_SIZE 0x8000 +#define E8_TRANSFORM_LIMIT_BITS 30 +#define E8_TRANSFORM_DEAD_ZONE 10 + +#define my_min(a, b) ((a) < (b) ? (a) : (b)) + +struct LZXD_dec { + /* use byte pointers instead of uint16 for simplicity on uncompressed + * chunks, and the stream is not 16-bit aligned anyway */ + const BYTE *stream_buf; + /* the next word to load into the bit cache */ + const BYTE *src; + /* location of the next chunk size field */ + const BYTE *chunk_end; + /* position in the output where the maximum allowed decompressed chunk size is reached */ + size_t uncomp_chunk_end; + /* end of the input */ + const BYTE *stream_end; + /* bit cache */ + UINT32 bits; + /* number of unused bits in the cache starting from bit 0 */ + unsigned bit_pos; + /* number of padding bits added trying to read at the chunk end */ + unsigned tail_bits; + /* repeat matches */ + size_t reps[REP_COUNT]; + /* distance slot count is required for loading code lengths */ + unsigned dist_slot_count; + /* huffman code lengths */ + BYTE align_lengths[ALIGN_CODE_COUNT]; + BYTE main_lengths[MAX_MAIN_CODES]; + BYTE len_lengths[LEN_CODE_COUNT]; + UINT16 align_table[ALIGN_TABLE_SIZE]; + UINT16 main_table[MAIN_TABLE_SIZE]; + UINT16 len_table[MAIN_TABLE_SIZE]; +}; + +/* PA19 container format is unaligned, so the LZXD stream is not aligned either. + * None of this is super optimized but it's fast enough for installer work. + */ +static inline UINT16 read_uint16(struct LZXD_dec *dec) +{ + /* bounds check was done before calling */ + UINT16 u = dec->src[0] | (dec->src[1] << 8); + dec->src += ELEM_SIZE; + return u; +} + +/* load the next chunk size, reset bit_pos and set up limits + */ +static int init_chunk(struct LZXD_dec *dec, size_t index, size_t buf_limit) +{ + UINT32 chunk_size; + + if (dec->src + ELEM_SIZE > dec->stream_end) + return -1; + + /* error if tail padding bits were decoded as input */ + if (dec->bit_pos < dec->tail_bits) + return -1; + + chunk_size = read_uint16(dec); + + dec->chunk_end = dec->src + chunk_size; + if (dec->chunk_end > dec->stream_end) + return -1; + + dec->bit_pos = 0; + dec->tail_bits = 0; + + dec->uncomp_chunk_end = my_min(buf_limit, index + MAX_CHUNK_UNCOMPRESSED_SIZE); + + return 0; +} + +/* ensure at least 17 bits are loaded but do not advance + */ +static inline void prime_bits(struct LZXD_dec *dec) +{ + while (dec->bit_pos < 17) + { + if (dec->src + ELEM_SIZE <= dec->chunk_end) + { + dec->bits = (dec->bits << 16) | read_uint16(dec); + } + else + { + /* Need to pad at the end of the chunk to decode the last codes. + In an error state, 0xFFFF sends the decoder down the right + side of the huffman tree to error out sooner. */ + dec->bits = (dec->bits << 16) | 0xFFFF; + dec->tail_bits += 16; + } + dec->bit_pos += 16; + } +} + +/* read and advance n bits + */ +static inline UINT32 read_bits(struct LZXD_dec *dec, unsigned n) +{ + UINT32 bits; + + dec->bit_pos -= n; + bits = dec->bits >> dec->bit_pos; + bits &= ((1 << n) - 1); + + while (dec->bit_pos < 17) + { + if (dec->src + ELEM_SIZE <= dec->chunk_end) + { + dec->bits = (dec->bits << 16) | read_uint16(dec); + } + else + { + /* tail padding */ + dec->bits = (dec->bits << 16) | 0xFFFF; + dec->tail_bits += 16; + } + dec->bit_pos += 16; + } + + return bits; +} + +/* read n bits but do not advance + */ +static inline UINT32 peek_bits(struct LZXD_dec *dec, unsigned n) +{ + UINT32 bits = dec->bits >> (dec->bit_pos - n); + return bits & ((1 << n) - 1); +} + +static inline void advance_bits(struct LZXD_dec *dec, unsigned length) +{ + dec->bit_pos -= length; + prime_bits(dec); +} + +/* read a 16-bit aligned UINT32 + */ +static UINT32 read_uint32(struct LZXD_dec *dec) +{ + UINT32 u = 0; + unsigned n = 0; + + assert((dec->bit_pos & 0xF) == 0); + + while (dec->bit_pos) + { + dec->bit_pos -= 16; + u |= ((dec->bits >> dec->bit_pos) & 0xFFFF) << n; + n += 16; + } + while (n < 32 && dec->src + ELEM_SIZE <= dec->chunk_end) + { + u |= read_uint16(dec) << n; + n += 16; + } + + return u; +} + +static int make_huffman_codes(unsigned *codes, const BYTE *lengths, unsigned count) +{ + unsigned len_count[MAX_CODE_LEN + 1]; + unsigned next_code[MAX_CODE_LEN + 1]; + unsigned i; + unsigned code = 0; + + memset(len_count, 0, sizeof(len_count)); + for (i = 0; i < count; ++i) + ++len_count[lengths[i]]; + len_count[0] = 0; + + for (i = 1; i <= MAX_CODE_LEN; ++i) + { + code = (code + len_count[i - 1]) << 1; + next_code[i] = code; + } + for (i = 0; i < count; i++) + { + unsigned len = lengths[i]; + if (len) + { + /* test for bad code tree */ + if (next_code[len] >= (1U << len)) + return -1; + + codes[i] = next_code[len]; + ++next_code[len]; + } + } + return 0; +} + +void make_decode_table(UINT16 *table, const unsigned *codes, + const BYTE *lengths, unsigned max_len, unsigned count) +{ + const size_t table_size = (size_t)1 << max_len; + size_t i; + + for (i = 0; i < table_size; i++) + table[i] = HUFF_ERROR; + + for (i = 0; i < count; i++) if (lengths[i]) + { + BYTE diff = (BYTE)max_len - lengths[i]; + size_t n = codes[i] << diff; + size_t end = n + ((size_t)1 << diff); + for (; n < end; ++n) + table[n] = (UINT16)i; + } +} + +#define ret_if_failed(r_) do { int err_ = r_; if(err_) return err_; } while(0) + +static int decode_lengths(struct LZXD_dec *dec, + BYTE *lengths, unsigned index, unsigned count) +{ + unsigned codes[PRE_LEN_CODE_COUNT]; + BYTE pre_lens[PRE_LEN_CODE_COUNT]; + size_t i; + unsigned repeats = 1; + + for (i = 0; i < PRE_LEN_CODE_COUNT; ++i) + pre_lens[i] = (BYTE)read_bits(dec, PRE_LEN_BITS); + + ret_if_failed(make_huffman_codes(codes, pre_lens, PRE_LEN_CODE_COUNT)); + make_decode_table(dec->main_table, codes, pre_lens, MAX_PRE_CODE_LEN, PRE_LEN_CODE_COUNT); + + while (index < count) + { + UINT32 bits = peek_bits(dec, MAX_PRE_CODE_LEN); + UINT16 sym = dec->main_table[bits]; + if (sym == HUFF_ERROR) + return -1; + advance_bits(dec, pre_lens[sym]); + + if (sym < 17) + { + sym = (lengths[index] + 17 - sym) % 17; + do + { + lengths[index] = (BYTE)sym; + ++index; + --repeats; + } while (repeats && index < count); + + repeats = 1; + } + else if (sym < 19) + { + unsigned zeros; + + sym -= 13; + zeros = read_bits(dec, sym) + (1 << sym) - 12; + do + { + lengths[index] = 0; + ++index; + --zeros; + } while (zeros && index < count); + } + else + { + /* the repeat count applies to the next symbol */ + repeats = 4 + read_bits(dec, 1); + } + } + return 0; +} + +/* distance decoder for block_type == 1 + */ +static size_t decode_dist_verbatim(struct LZXD_dec *dec, unsigned dist_slot) +{ + size_t dist; + unsigned footer_bits = 17; + + if (dist_slot < 38) + { + footer_bits = (dist_slot >> 1) - 1; + dist = ((size_t)2 + (dist_slot & 1)) << footer_bits; + } + else + { + dist = ((size_t)1 << 19) + ((size_t)1 << 17) * (dist_slot - 38); + } + return dist + read_bits(dec, footer_bits); +} + +/* distance decoder for block_type == 2 + */ +static size_t decode_dist_aligned(struct LZXD_dec *dec, unsigned dist_slot) +{ + size_t dist; + unsigned footer_bits = 17; + + if (dist_slot < 38) + { + footer_bits = (dist_slot >> 1) - 1; + dist = ((size_t)2 + (dist_slot & 1)) << footer_bits; + } + else + { + dist = ((size_t)1 << 19) + ((size_t)1 << 17) * (dist_slot - 38); + } + if (footer_bits >= 3) + { + UINT32 bits; + UINT16 sym; + + footer_bits -= 3; + if (footer_bits) + dist += read_bits(dec, footer_bits) << 3; + + bits = peek_bits(dec, MAX_ALIGN_CODE_LEN); + sym = dec->align_table[bits]; + if (sym == HUFF_ERROR) + return ~(size_t)0; + advance_bits(dec, dec->align_lengths[sym]); + + dist += sym; + } + else + { + dist += read_bits(dec, footer_bits); + } + return dist; +} + +static inline void align_16_or_maybe_advance_anyway(struct LZXD_dec *dec) +{ + dec->bit_pos &= 0x30; + /* The specification requires 16 bits of zero padding in some cases where the stream is already aligned, but + * the logic behind the choice to pad any particular block is undefined (it's a feature!). Fortunately it + * seems always to coincide with a bit_pos of 0x20, but 0x20 doesn't always mean padding, so we test for zero + * too. A remote chance of failure may still exist but I've never seen one occur. */ + if (dec->bit_pos == 0x20 && (dec->bits >> 16) == 0) + dec->bit_pos = 0x10; +} + +static int copy_uncompressed(struct LZXD_dec *dec, BYTE *base, size_t *index_ptr, size_t buf_limit, UINT32 block_size) +{ + size_t index = *index_ptr; + size_t end = index + block_size; + size_t realign; + + if (end > buf_limit) + return -1; + /* save the current alignment */ + realign = (dec->src - dec->stream_buf) & 1; + + while (dec->src < dec->stream_end) + { + /* now treat the input as an unaligned byte stream */ + size_t to_copy = my_min(end - index, dec->uncomp_chunk_end - index); + to_copy = my_min(to_copy, (size_t)(dec->stream_end - dec->src)); + + memcpy(base + index, dec->src, to_copy); + index += to_copy; + dec->src += to_copy; + + if (index == end) + { + /* realign at the end of the block */ + dec->src += ((dec->src - dec->stream_buf) & 1) ^ realign; + /* fill the bit cache for block header decoding */ + prime_bits(dec); + break; + } + /* chunk sizes are also unaligned */ + ret_if_failed(init_chunk(dec, index, buf_limit)); + } + *index_ptr = index; + return 0; +} + +static int prime_next_chunk(struct LZXD_dec *dec, size_t index, size_t buf_limit) +{ + if (dec->src < dec->chunk_end) + return -1; + ret_if_failed(init_chunk(dec, index, buf_limit)); + prime_bits(dec); + return 0; +} + +#define MAX_LONG_MATCH_CODE_LEN 3 +#define LONG_MATCH_TABLE_SIZE (1 << MAX_LONG_MATCH_CODE_LEN) + +struct long_match { + BYTE code_len; + unsigned extra_bits; + unsigned base; +}; + +static const struct long_match long_match_table[LONG_MATCH_TABLE_SIZE] = { + {1, 8, 0x101}, + {1, 8, 0x101}, + {1, 8, 0x101}, + {1, 8, 0x101}, + {2, 10, 0x201}, + {2, 10, 0x201}, + {3, 12, 0x601}, + {3, 15, 0x101} +}; + +static int decode_lzxd_block(struct LZXD_dec *dec, BYTE *base, size_t predef_size, size_t *index_ptr, size_t buf_limit) +{ + unsigned codes[MAX_MAIN_CODES]; + unsigned main_code_count; + UINT32 block_type; + UINT32 block_size; + size_t i; + size_t block_limit; + size_t index = *index_ptr; + size_t (*dist_decoder)(struct LZXD_dec *dec, unsigned dist_slot); + + if (index >= dec->uncomp_chunk_end && prime_next_chunk(dec, index, buf_limit)) + return -1; + + block_type = read_bits(dec, 3); + + /* check for invalid block types */ + if (block_type == 0 || block_type > 3) + return -1; + + block_size = read_bits(dec, 8); + block_size = (block_size << 8) | read_bits(dec, 8); + block_size = (block_size << 8) | read_bits(dec, 8); + + if (block_type == 3) + { + /* uncompressed block */ + align_16_or_maybe_advance_anyway(dec); + /* must have run out of coffee at the office */ + for (i = 0; i < REP_COUNT; ++i) + { + dec->reps[i] = read_uint32(dec); + if (dec->reps[i] == 0) + return -1; + } + /* copy the block to output */ + return copy_uncompressed(dec, base, index_ptr, buf_limit, block_size); + } + else if (block_type == 2) + { + /* distance alignment decoder will be used */ + for (i = 0; i < ALIGN_CODE_COUNT; ++i) + dec->align_lengths[i] = read_bits(dec, 3); + } + + main_code_count = MAIN_CODE_COUNT(dec->dist_slot_count); + ret_if_failed(decode_lengths(dec, dec->main_lengths, 0, 256)); + ret_if_failed(decode_lengths(dec, dec->main_lengths, 256, main_code_count)); + ret_if_failed(decode_lengths(dec, dec->len_lengths, 0, LEN_CODE_COUNT)); + + dist_decoder = (block_type == 2) ? decode_dist_aligned : decode_dist_verbatim; + + if (block_type == 2) + { + ret_if_failed(make_huffman_codes(codes, dec->align_lengths, ALIGN_CODE_COUNT)); + make_decode_table(dec->align_table, codes, dec->align_lengths, MAX_ALIGN_CODE_LEN, ALIGN_CODE_COUNT); + } + + ret_if_failed(make_huffman_codes(codes, dec->main_lengths, main_code_count)); + make_decode_table(dec->main_table, codes, dec->main_lengths, MAX_CODE_LEN, main_code_count); + + ret_if_failed(make_huffman_codes(codes, dec->len_lengths, LEN_CODE_COUNT)); + make_decode_table(dec->len_table, codes, dec->len_lengths, MAX_CODE_LEN, LEN_CODE_COUNT); + + block_limit = my_min(buf_limit, index + block_size); + + while (index < block_limit) + { + UINT32 bits; + UINT16 sym; + + if (index >= dec->uncomp_chunk_end && prime_next_chunk(dec, index, buf_limit)) + return -1; + + bits = peek_bits(dec, MAX_CODE_LEN); + sym = dec->main_table[bits]; + if (sym == HUFF_ERROR) + return -1; + advance_bits(dec, dec->main_lengths[sym]); + + if (sym < 256) + { + /* literal */ + base[index] = (BYTE)sym; + ++index; + } + else { + size_t length; + size_t dist; + size_t end; + unsigned dist_slot; + + sym -= 256; + length = (sym & 7) + 2; + dist_slot = sym >> 3; + + if (length == 9) + { + /* extra length bits */ + bits = peek_bits(dec, MAX_CODE_LEN); + sym = dec->len_table[bits]; + if (sym == HUFF_ERROR) + return -1; + advance_bits(dec, dec->len_lengths[sym]); + + length += sym; + } + dist = dist_slot; + if (dist_slot > 3) + { + /* extra distance bits */ + dist = dist_decoder(dec, dist_slot); + if (dist == ~(size_t)0) + return -1; + } + if (length == 257) + { + /* extra-long match length */ + bits = peek_bits(dec, MAX_LONG_MATCH_CODE_LEN); + advance_bits(dec, long_match_table[bits].code_len); + + length = long_match_table[bits].base; + length += read_bits(dec, long_match_table[bits].extra_bits); + } + if (dist < 3) + { + /* repeat match */ + size_t rep = dist; + dist = dec->reps[dist]; + dec->reps[rep] = dec->reps[0]; + } + else + { + dist -= REP_COUNT - 1; + dec->reps[2] = dec->reps[1]; + dec->reps[1] = dec->reps[0]; + } + dec->reps[0] = dist; + + while (dist > index && length && index < block_limit) + { + /* undocumented: the encoder assumes an imaginary buffer + * of zeros exists before the start of the real buffer */ + base[index] = 0; + ++index; + --length; + } + + end = my_min(index + length, block_limit); + while (index < end) + { + base[index] = base[index - dist]; + ++index; + } + } + } + /* error if tail padding bits were decoded as input */ + if (dec->bit_pos < dec->tail_bits) + return -1; + + *index_ptr = index; + return 0; +} + +static void reverse_e8_transform(BYTE *decode_buf, ptrdiff_t len, ptrdiff_t e8_file_size) +{ + ptrdiff_t limit = my_min((ptrdiff_t)1 << E8_TRANSFORM_LIMIT_BITS, len); + ptrdiff_t i; + + for (i = 0; i < limit; ) + { + ptrdiff_t end = my_min(i + MAX_CHUNK_UNCOMPRESSED_SIZE - E8_TRANSFORM_DEAD_ZONE, + limit - E8_TRANSFORM_DEAD_ZONE); + ptrdiff_t next = i + MAX_CHUNK_UNCOMPRESSED_SIZE; + + for (; i < end; ++i) + { + if (decode_buf[i] == 0xE8) + { + ptrdiff_t delta; + ptrdiff_t value = (ptrdiff_t)decode_buf[i + 1] | + decode_buf[i + 2] << 8 | + decode_buf[i + 3] << 16 | + decode_buf[i + 4] << 24; + + if (value >= -i && value < e8_file_size) + { + if (value >= 0) + delta = value - i; + else + delta = value + e8_file_size; + + decode_buf[i + 1] = (BYTE)delta; + decode_buf[i + 2] = (BYTE)(delta >> 8); + decode_buf[i + 3] = (BYTE)(delta >> 16); + decode_buf[i + 4] = (BYTE)(delta >> 24); + } + i += 4; + } + } + i = next; + } +} + +DWORD decode_lzxd_stream(const BYTE *src, const size_t input_size, + BYTE *dst, const size_t output_size, + const size_t predef_size, + DWORD large_window, + PPATCH_PROGRESS_CALLBACK progress_fn, + PVOID progress_ctx) +{ + struct LZXD_dec *dec; + const BYTE *end = src + input_size; + size_t buf_size = predef_size + output_size; + UINT32 e8; + UINT32 e8_file_size = 0; + DWORD err = ERROR_SUCCESS; + + TRACE("decoding stream of size %u to size %u, starting at %u\n", + (unsigned)input_size, (unsigned)output_size, (unsigned)predef_size); + + if (input_size == 0) + return (output_size == 0) ? ERROR_SUCCESS : ERROR_PATCH_CORRUPT; + + if (progress_fn != NULL && !progress_fn(progress_ctx, 0, (ULONG)output_size)) + return ERROR_CANCELLED; + + dec = malloc(sizeof(*dec)); + if (dec == NULL) + return ERROR_OUTOFMEMORY; + + memset(dec->main_lengths, 0, sizeof(dec->main_lengths)); + memset(dec->len_lengths, 0, sizeof(dec->len_lengths)); + dec->reps[0] = 1; + dec->reps[1] = 1; + dec->reps[2] = 1; + + /* apparently the window size is not recorded and must be deduced from the file sizes */ + { + unsigned max_window = large_window ? MAX_LARGE_WINDOW : MAX_NORMAL_WINDOW; + size_t window = (size_t)1 << 17; + /* round up the old file size per the lzxd spec - correctness verified by fuzz tests */ + size_t total = (predef_size + 0x7FFF) & ~0x7FFF; + unsigned delta; + + total += output_size; + dec->dist_slot_count = 34; + while (window < total && window < ((size_t)1 << 19)) + { + dec->dist_slot_count += 2; + window <<= 1; + } + delta = 4; + while (window < total && window < max_window) + { + dec->dist_slot_count += delta; + delta <<= 1; + window <<= 1; + } + TRACE("setting window to 0x%X\n", (unsigned)window); + } + + dec->bit_pos = 0; + dec->tail_bits = 0; + dec->stream_buf = src; + dec->src = src; + dec->stream_end = end; + dec->chunk_end = dec->src; + + /* load the first chunk size and set the end pointer */ + if(init_chunk(dec, predef_size, buf_size)) + { + err = ERROR_PATCH_DECODE_FAILURE; + goto free_dec; + } + + /* fill the bit cache */ + prime_bits(dec); + + e8 = read_bits(dec, 1); + if (e8) + { + /* E8 transform was used */ + e8_file_size = read_bits(dec, 16) << 16; + e8_file_size |= read_bits(dec, 16); + TRACE("E8 transform detected; file size %u\n", e8_file_size); + } + + { + size_t index = predef_size; + while (dec->src < dec->stream_end && index < buf_size) + { + if (decode_lzxd_block(dec, dst, predef_size, &index, buf_size)) + { + err = ERROR_PATCH_DECODE_FAILURE; + goto free_dec; + } + if (progress_fn != NULL && !progress_fn(progress_ctx, (ULONG)(index - predef_size), (ULONG)output_size)) + { + err = ERROR_CANCELLED; + goto free_dec; + } + } + } + + if (e8) + reverse_e8_transform(dst + predef_size, output_size, e8_file_size); + +free_dec: + free(dec); + + return err; +} diff --git a/dlls/mspatcha/lzxd_dec.h b/dlls/mspatcha/lzxd_dec.h new file mode 100755 index 0000000..a7923cd --- /dev/null +++ b/dlls/mspatcha/lzxd_dec.h @@ -0,0 +1,27 @@ +/* + * Copyright 2019 Conor McCarthy + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#define MAX_NORMAL_WINDOW (8U << 20) +#define MAX_LARGE_WINDOW (32U << 20) + +DWORD decode_lzxd_stream(const BYTE *src, const size_t input_size, + BYTE *dst, const size_t output_size, + const size_t predef_size, + DWORD large_window, + PPATCH_PROGRESS_CALLBACK progress_fn, + PVOID progress_ctx); diff --git a/dlls/mspatcha/mspatcha.spec b/dlls/mspatcha/mspatcha.spec index cc8ca94..8c014b9 100644 --- a/dlls/mspatcha/mspatcha.spec +++ b/dlls/mspatcha/mspatcha.spec @@ -1,12 +1,16 @@ -1 stdcall ApplyPatchToFileA(str str str long) -2 stub ApplyPatchToFileByHandles -3 stub ApplyPatchToFileByHandlesEx -4 stub ApplyPatchToFileExA -5 stub ApplyPatchToFileExW -6 stdcall ApplyPatchToFileW(wstr wstr wstr long) -7 stdcall GetFilePatchSignatureA(str long ptr long ptr long ptr long ptr) -8 stub GetFilePatchSignatureByHandle -9 stdcall GetFilePatchSignatureW(wstr long ptr long ptr long ptr long ptr) -10 stub TestApplyPatchToFileA -11 stub TestApplyPatchToFileByHandles -12 stub TestApplyPatchToFileW +@ stdcall ApplyPatchToFileA(str str str long) +@ stdcall ApplyPatchToFileByBuffers(ptr long ptr long ptr long ptr ptr long ptr ptr) +@ stdcall ApplyPatchToFileByHandles(ptr ptr ptr long) +@ stdcall ApplyPatchToFileByHandlesEx(ptr ptr ptr long ptr ptr) +@ stdcall ApplyPatchToFileExA(str str str long ptr ptr) +@ stdcall ApplyPatchToFileExW(wstr wstr wstr long ptr ptr) +@ stdcall ApplyPatchToFileW(wstr wstr wstr long) +@ stdcall GetFilePatchSignatureA(str long ptr long ptr long ptr long str) +@ stdcall GetFilePatchSignatureByBuffer(ptr long long ptr long ptr long ptr long str) +@ stdcall GetFilePatchSignatureByHandle(ptr long ptr long ptr long ptr long str) +@ stdcall GetFilePatchSignatureW(wstr long ptr long ptr long ptr long wstr) +@ stdcall NormalizeFileForPatchSignature(ptr long long ptr long long long ptr long ptr) +@ stdcall TestApplyPatchToFileA(str str long) +@ stdcall TestApplyPatchToFileByBuffers(ptr long ptr long ptr long) +@ stdcall TestApplyPatchToFileByHandles(ptr ptr long) +@ stdcall TestApplyPatchToFileW(wstr wstr long) diff --git a/dlls/mspatcha/mspatcha_main.c b/dlls/mspatcha/mspatcha_main.c index f78b8ab..3a311bc 100644 --- a/dlls/mspatcha/mspatcha_main.c +++ b/dlls/mspatcha/mspatcha_main.c @@ -2,6 +2,7 @@ * PatchAPI * * Copyright 2011 David Hedberg for CodeWeavers + * Copyright 2019 Conor McCarthy (implementations) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -16,6 +17,31 @@ * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * TODO + * - Special processing of 32-bit executables is not supported, so this + * version cannot patch 32-bit .exe and .dll files. See pa19.c for details. + * - Implement interleaved decoding when PATCH_OPTION_INTERLEAVE_FILES was + * used or the old file exceeds the lzxd window size. + * - APPLY_OPTION_FAIL_IF_CLOSE is ignored. Normalization of 32-bit PE files + * is required for checking this. + * - GetFilePatchSignature* and NormalizeFileForPatchSignature require a + * solution to the above 32-bit exe problem. */ #include "config.h" @@ -28,6 +54,8 @@ #include "patchapi.h" #include "wine/debug.h" +#include "pa19.h" + WINE_DEFAULT_DEBUG_CHANNEL(mspatcha); /***************************************************** @@ -49,79 +77,236 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) return TRUE; } -static inline WCHAR *strdupAW( const char *src ) +static WCHAR *strdupAW(const char *src) { WCHAR *dst = NULL; if (src) { - int len = MultiByteToWideChar( CP_ACP, 0, src, -1, NULL, 0 ); - if ((dst = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) - MultiByteToWideChar( CP_ACP, 0, src, -1, dst, len ); + int len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0); + if ((dst = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)))) + MultiByteToWideChar(CP_ACP, 0, src, -1, dst, len); } return dst; } /***************************************************** - * ApplyPatchToFileA (MSPATCHA.1) + * TestApplyPatchToFileA (MSPATCHA.@) */ -BOOL WINAPI ApplyPatchToFileA(LPCSTR patch_file, LPCSTR old_file, LPCSTR new_file, ULONG apply_flags) +BOOL WINAPI TestApplyPatchToFileA(LPCSTR patch_file, LPCSTR old_file, ULONG apply_flags) { BOOL ret; - WCHAR *patch_fileW, *new_fileW, *old_fileW = NULL; + WCHAR *patch_fileW, *old_fileW = NULL; - if (!(patch_fileW = strdupAW( patch_file ))) return FALSE; - if (old_file && !(old_fileW = strdupAW( old_file ))) + if (!(patch_fileW = strdupAW(patch_file))) return FALSE; + if (old_file && !(old_fileW = strdupAW(old_file))) { - HeapFree( GetProcessHeap(), 0, patch_fileW ); + HeapFree(GetProcessHeap(), 0, patch_fileW); return FALSE; } - if (!(new_fileW = strdupAW( new_file ))) + ret = apply_patch_to_file(patch_fileW, old_fileW, NULL, apply_flags, NULL, NULL, TRUE); + HeapFree(GetProcessHeap(), 0, patch_fileW); + if(old_fileW) + HeapFree(GetProcessHeap(), 0, old_fileW); + return ret; +} + +BOOL WINAPI TestApplyPatchToFileW(LPCWSTR patch_file_name, LPCWSTR old_file_name, ULONG apply_option_flags) +{ + return apply_patch_to_file(patch_file_name, old_file_name, NULL, apply_option_flags, NULL, NULL, TRUE); +} + +BOOL WINAPI TestApplyPatchToFileByHandles(HANDLE patch_file_hndl, HANDLE old_file_hndl, ULONG apply_option_flags) +{ + return apply_patch_to_file_by_handles(patch_file_hndl, old_file_hndl, NULL, + apply_option_flags, NULL, NULL, TRUE); +} + +BOOL WINAPI TestApplyPatchToFileByBuffers(BYTE *patch_file_buf, ULONG patch_file_size, + BYTE *old_file_buf, ULONG old_file_size, + ULONG* new_file_size, + ULONG apply_option_flags) +{ + /* preserve last error on success as per windows */ + DWORD last = GetLastError(); + + DWORD err = apply_patch_to_file_by_buffers(patch_file_buf, patch_file_size, + old_file_buf, old_file_size, + NULL, 0, new_file_size, NULL, + apply_option_flags, + NULL, NULL, + TRUE); + + SetLastError(err == ERROR_SUCCESS ? last : err); + + return err == ERROR_SUCCESS; +} + +/***************************************************** + * ApplyPatchToFileExA (MSPATCHA.@) + */ +BOOL WINAPI ApplyPatchToFileExA(LPCSTR patch_file, LPCSTR old_file, LPCSTR new_file, ULONG apply_flags, + PPATCH_PROGRESS_CALLBACK progress_fn, PVOID progress_ctx) +{ + BOOL ret = FALSE; + WCHAR *patch_fileW, *new_fileW, *old_fileW = NULL; + + if (!(patch_fileW = strdupAW(patch_file))) return FALSE; + if (old_file && !(old_fileW = strdupAW(old_file))) { - HeapFree( GetProcessHeap(), 0, patch_fileW ); - HeapFree( GetProcessHeap(), 0, old_fileW ); + HeapFree(GetProcessHeap(), 0, patch_fileW); return FALSE; } - ret = ApplyPatchToFileW( patch_fileW, old_fileW, new_fileW, apply_flags ); - HeapFree( GetProcessHeap(), 0, patch_fileW ); - HeapFree( GetProcessHeap(), 0, old_fileW ); - HeapFree( GetProcessHeap(), 0, new_fileW ); + if (!(new_fileW = strdupAW(new_file))) + { + goto free_wstrs; + } + ret = apply_patch_to_file(patch_fileW, old_fileW, new_fileW, apply_flags, progress_fn, progress_ctx, FALSE); + HeapFree(GetProcessHeap(), 0, new_fileW); +free_wstrs: + HeapFree(GetProcessHeap(), 0, patch_fileW); + if(old_fileW) + HeapFree(GetProcessHeap(), 0, old_fileW); return ret; } /***************************************************** - * ApplyPatchToFileW (MSPATCHA.6) + * ApplyPatchToFileA (MSPATCHA.@) */ -BOOL WINAPI ApplyPatchToFileW(LPCWSTR patch_file, LPCWSTR old_file, LPCWSTR new_file, ULONG apply_flags) +BOOL WINAPI ApplyPatchToFileA(LPCSTR patch_file, LPCSTR old_file, LPCSTR new_file, ULONG apply_flags) { - FIXME("stub - %s, %s, %s, %08x\n", debugstr_w(patch_file), debugstr_w(old_file), - debugstr_w(new_file), apply_flags); + return ApplyPatchToFileExA(patch_file, old_file, new_file, apply_flags, NULL, NULL); +} - SetLastError(ERROR_CALL_NOT_IMPLEMENTED); - return FALSE; +/***************************************************** + * ApplyPatchToFileW (MSPATCHA.@) + */ +BOOL WINAPI ApplyPatchToFileW(LPCWSTR patch_file_name, LPCWSTR old_file_name, LPCWSTR new_file_name, + ULONG apply_option_flags) +{ + return apply_patch_to_file(patch_file_name, old_file_name, new_file_name, apply_option_flags, + NULL, NULL, FALSE); +} + +/***************************************************** + * ApplyPatchToFileByHandles (MSPATCHA.@) + */ +BOOL WINAPI ApplyPatchToFileByHandles(HANDLE patch_file_hndl, HANDLE old_file_hndl, HANDLE new_file_hndl, + ULONG apply_option_flags) +{ + return apply_patch_to_file_by_handles(patch_file_hndl, old_file_hndl, new_file_hndl, + apply_option_flags, NULL, NULL, FALSE); +} + +/***************************************************** + * ApplyPatchToFileExW (MSPATCHA.@) + */ +BOOL WINAPI ApplyPatchToFileExW(LPCWSTR patch_file_name, LPCWSTR old_file_name, LPCWSTR new_file_name, + ULONG apply_option_flags, + PPATCH_PROGRESS_CALLBACK progress_fn, PVOID progress_ctx) +{ + return apply_patch_to_file(patch_file_name, old_file_name, new_file_name, apply_option_flags, + progress_fn, progress_ctx, FALSE); } /***************************************************** - * GetFilePatchSignatureA (MSPATCHA.7) + * ApplyPatchToFileByHandlesEx (MSPATCHA.@) + */ +BOOL WINAPI ApplyPatchToFileByHandlesEx(HANDLE patch_file_hndl, HANDLE old_file_hndl, HANDLE new_file_hndl, + ULONG apply_option_flags, + PPATCH_PROGRESS_CALLBACK progress_fn, + PVOID progress_ctx) +{ + return apply_patch_to_file_by_handles(patch_file_hndl, old_file_hndl, new_file_hndl, + apply_option_flags, progress_fn, progress_ctx, FALSE); +} + +/***************************************************** + * ApplyPatchToFileByBuffers (MSPATCHA.@) + */ +BOOL WINAPI ApplyPatchToFileByBuffers(PBYTE patch_file_view, ULONG patch_file_size, + PBYTE old_file_view, ULONG old_file_size, + PBYTE* new_file_buf, ULONG new_file_buf_size, ULONG* new_file_size, + FILETIME* new_file_time, + ULONG apply_option_flags, + PPATCH_PROGRESS_CALLBACK progress_fn, PVOID progress_ctx) +{ + /* preserve last error on success as per windows */ + DWORD last = GetLastError(); + + DWORD err = apply_patch_to_file_by_buffers(patch_file_view, patch_file_size, + old_file_view, old_file_size, + new_file_buf, new_file_buf_size, new_file_size, new_file_time, + apply_option_flags, + progress_fn, progress_ctx, + FALSE); + + SetLastError(err == ERROR_SUCCESS ? last : err); + + return err == ERROR_SUCCESS; +} + +/***************************************************** + * GetFilePatchSignatureA (MSPATCHA.@) */ BOOL WINAPI GetFilePatchSignatureA(LPCSTR filename, ULONG flags, PVOID data, ULONG ignore_range_count, - PPATCH_IGNORE_RANGE ignore_range, ULONG retain_range_count, - PPATCH_RETAIN_RANGE retain_range, ULONG bufsize, LPSTR buffer) + PPATCH_IGNORE_RANGE ignore_range, ULONG retain_range_count, + PPATCH_RETAIN_RANGE retain_range, ULONG bufsize, LPSTR buffer) { FIXME("stub - %s, %x, %p, %u, %p, %u, %p, %u, %p\n", debugstr_a(filename), flags, data, - ignore_range_count, ignore_range, retain_range_count, retain_range, bufsize, buffer); + ignore_range_count, ignore_range, retain_range_count, retain_range, bufsize, buffer); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE; } /***************************************************** - * GetFilePatchSignatureW (MSPATCHA.9) + * GetFilePatchSignatureW (MSPATCHA.@) */ BOOL WINAPI GetFilePatchSignatureW(LPCWSTR filename, ULONG flags, PVOID data, ULONG ignore_range_count, - PPATCH_IGNORE_RANGE ignore_range, ULONG retain_range_count, - PPATCH_RETAIN_RANGE retain_range, ULONG bufsize, LPWSTR buffer) + PPATCH_IGNORE_RANGE ignore_range, ULONG retain_range_count, + PPATCH_RETAIN_RANGE retain_range, ULONG bufsize, LPWSTR buffer) { FIXME("stub - %s, %x, %p, %u, %p, %u, %p, %u, %p\n", debugstr_w(filename), flags, data, - ignore_range_count, ignore_range, retain_range_count, retain_range, bufsize, buffer); + ignore_range_count, ignore_range, retain_range_count, retain_range, bufsize, buffer); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} + +/***************************************************** + * GetFilePatchSignatureByHandle (MSPATCHA.@) + */ +BOOL WINAPI GetFilePatchSignatureByHandle(HANDLE handle, ULONG flags, PVOID options, ULONG ignore_range_count, + PPATCH_IGNORE_RANGE ignore_range, ULONG retain_range_count, + PPATCH_RETAIN_RANGE retain_range, ULONG bufsize, LPSTR buffer) +{ + FIXME("stub - %p, %x, %p, %u, %p, %u, %p, %u, %p\n", handle, flags, options, + ignore_range_count, ignore_range, retain_range_count, retain_range, bufsize, buffer); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} + +/***************************************************** + * GetFilePatchSignatureByBuffer (MSPATCHA.@) + */ +BOOL WINAPI GetFilePatchSignatureByBuffer(PBYTE file_buf, ULONG file_size, ULONG flags, PVOID options, + ULONG ignore_range_count, PPATCH_IGNORE_RANGE ignore_range, + ULONG retain_range_count, PPATCH_RETAIN_RANGE retain_range, + ULONG bufsize, LPSTR buffer) +{ + FIXME("stub - %p, %u, %x, %p, %u, %p, %u, %p, %u, %p\n", file_buf, file_size, flags, options, + ignore_range_count, ignore_range, retain_range_count, retain_range, bufsize, buffer); SetLastError(ERROR_CALL_NOT_IMPLEMENTED); return FALSE; } + +/***************************************************** + * NormalizeFileForPatchSignature (MSPATCHA.@) + */ +INT WINAPI NormalizeFileForPatchSignature(PVOID file_buffer, ULONG file_size, ULONG flags, PATCH_OPTION_DATA *options, + ULONG new_coff_base, ULONG new_coff_time, ULONG ignore_range_count, PPATCH_IGNORE_RANGE ignore_range, + ULONG retain_range_count, PPATCH_RETAIN_RANGE retain_range) +{ + FIXME("stub - %p, %u, %x, %p, %u, %u, %u, %p, %u, %p\n", file_buffer, file_size, flags, options, new_coff_base, + new_coff_time, ignore_range_count, ignore_range, retain_range_count, retain_range); + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return 0; +} diff --git a/dlls/mspatcha/pa19.c b/dlls/mspatcha/pa19.c new file mode 100755 index 0000000..1c20fc1 --- /dev/null +++ b/dlls/mspatcha/pa19.c @@ -0,0 +1,1060 @@ +/* + * PatchAPI PA19 file handlers + * + * Copyright 2019 Conor McCarthy + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * TODO + * - Normalization of 32-bit PE executable files and reversal of special + * processing of these executables is not implemented. + * Without normalization, old files cannot be validated for patching. The + * function NormalizeFileForPatchSignature() in Windows could be used to work + * out exactly how normalization works. + * Most/all of the special processing seems to be relocation of targets for + * some jump/call instructions to match more of the old file and improve + * compression. Patching of 64-bit exes works because mspatchc.dll does not + * implement special processing of them. In 32-bit patches, the variable + * named here 'unknown_count' seems to indicate presence of data related to + * reversing the processing. The changes that must be reversed occur at some, + * but not all, of the positions listed in the PE .reloc table. + */ + +#include "config.h" + +#include <stdarg.h> +#include <stdlib.h> + +#include "windef.h" +#include "winbase.h" +#include "wine/debug.h" + +#include "patchapi.h" + +#include "pa19.h" +#include "lzxd_dec.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mspatcha); + +#define PA19_FILE_MAGIC 0x39314150 +#define PATCH_OPTION_EXTRA_FLAGS 0x80000000 + +#define my_max(a, b) ((a) > (b) ? (a) : (b)) +#define my_min(a, b) ((a) < (b) ? (a) : (b)) + + +/* The CRC32 code is copyright (C) 1986 Gary S. Brown and was placed in the + * public domain. + * CRC polynomial 0xedb88320 + */ +static const UINT32 CRC_table[256] = +{ + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, + 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, + 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, + 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, + 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, + 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, + 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, + 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, + 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, + 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, + 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, + 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, + 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, + 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, + 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, + 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, + 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, + 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, + 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, + 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, + 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, + 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, + 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, + 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, + 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, + 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, + 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, + 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, + 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, + 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, + 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, + 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, + 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d +}; + +static UINT32 compute_crc32(UINT32 crc, const BYTE *pData, INT_PTR iLen) +{ + crc ^= 0xFFFFFFFF; + + while (iLen > 0) { + crc = CRC_table[(crc ^ *pData) & 0xFF] ^ (crc >> 8); + pData++; + iLen--; + } + return crc ^ 0xFFFFFFFF; +} + +static UINT32 compute_zero_crc32(UINT32 crc, INT_PTR iLen) +{ + crc ^= 0xFFFFFFFF; + + while (iLen > 0) + { + crc = CRC_table[crc & 0xFF] ^ (crc >> 8); + iLen--; + } + return crc ^ 0xFFFFFFFF; +} + + +/*********************************************************************************** + * PatchAPI PA19 file header + * + * BYTE magic[4]; + * UINT32 options; + * UINT32 options_2; (present if PATCH_OPTION_EXTRA_FLAGS set) + * UINT32 timestamp; (if PATCH_OPTION_NO_TIMESTAMP is SET in options) + * UVLI rebase; (present if PATCH_OPTION_NO_REBASE is not set; used on 32-bit executables) + * UVLI unpatched_size; + * UINT32 crc32_patched; + * BYTE input_file_count; + * + * For each source file: + * SVLI (patched_size - unpatched_size); + * UINT32 crc32_unpatched; + * BYTE ignore_range_count; + * For each ignore range: + * SVLI OffsetInOldFile; + * UVLI LengthInBytes; + * BYTE retain_range_count; + * For each retain range: + * SVLI (OffsetInOldFile - (prevOffsetInOldFile + prevLengthInBytes)); + * SVLI (OffsetInNewFile - OffsetInOldFile); + * UVLI LengthInBytes; + * UVLI unknown_count; (a count of pairs of values related to the reversal of special + * processing done to improve compression of 32-bit executables) + * UVLI interleave_count; (present only if PATCH_OPTION_INTERLEAVE_FILES is set in options) + * UVLI interleave_values[interleave_count * 3 - 1]; + * UVLI lzxd_input_size; + * + * For each source file: + * UINT16 lzxd_block[lzxd_input_size / 2]; (NOT always 16-bit aligned) + * + * UINT32 crc_hack; (rounds out the entire file crc32 to 0) +*/ + + +#define MAX_RANGES 255 + +struct input_file_info { + size_t input_size; + DWORD crc32; + BYTE ignore_range_count; + BYTE retain_range_count; + PATCH_IGNORE_RANGE ignore_table[MAX_RANGES]; + PATCH_RETAIN_RANGE retain_table[MAX_RANGES]; + size_t unknown_count; + size_t stream_size; + const BYTE *stream_start; + int next_i; + int next_r; +}; + +struct patch_file_header { + DWORD flags; + DWORD timestamp; + size_t patched_size; + DWORD patched_crc32; + unsigned input_file_count; + struct input_file_info *file_table; + const BYTE *src; + const BYTE *end; + DWORD err; +}; + + +/* Currently supported options. Some such as PATCH_OPTION_FAIL_IF_BIGGER don't + * affect decoding but can get recorded in the patch file anyway */ +#define PATCH_OPTION_SUPPORTED_FLAGS ( \ + PATCH_OPTION_USE_LZX_A \ + | PATCH_OPTION_USE_LZX_B \ + | PATCH_OPTION_USE_LZX_LARGE \ + | PATCH_OPTION_NO_BINDFIX \ + | PATCH_OPTION_NO_LOCKFIX \ + | PATCH_OPTION_NO_REBASE \ + | PATCH_OPTION_FAIL_IF_SAME_FILE \ + | PATCH_OPTION_FAIL_IF_BIGGER \ + | PATCH_OPTION_NO_CHECKSUM \ + | PATCH_OPTION_NO_RESTIMEFIX \ + | PATCH_OPTION_NO_TIMESTAMP \ + | PATCH_OPTION_EXTRA_FLAGS) + + +/* read a byte-aligned little-endian UINT32 from input and set error if eof + */ +static inline UINT32 read_raw_uint32(struct patch_file_header *ph) +{ + const BYTE *src = ph->src; + + ph->src += 4; + if (ph->src > ph->end) + { + ph->err = ERROR_PATCH_CORRUPT; + return 0; + } + return src[0] + | (src[1] << 8) + | (src[2] << 16) + | (src[3] << 24); +} + +/* Read a variable-length integer from a sequence of bytes terminated by + * a value with bit 7 set. Set error if invalid or eof */ +static UINT64 read_uvli(struct patch_file_header *ph) +{ + const BYTE *vli = ph->src; + UINT64 n; + ptrdiff_t i; + ptrdiff_t limit = my_min(ph->end - vli, 9); + + if (ph->src >= ph->end) + { + ph->err = ERROR_PATCH_CORRUPT; + return 0; + } + + n = vli[0] & 0x7F; + for (i = 1; i < limit && vli[i - 1] < 0x80; ++i) + n += (UINT64)(vli[i] & 0x7F) << (7 * i); + + if (vli[i - 1] < 0x80) + { + TRACE("exceeded maximum vli size\n"); + ph->err = ERROR_PATCH_CORRUPT; + return 0; + } + + ph->src += i; + + return n; +} + +/* Signed variant of the above. First byte sign flag is 0x40. + */ +static INT64 read_svli(struct patch_file_header *ph) +{ + const BYTE *vli = ph->src; + INT64 n; + ptrdiff_t i; + ptrdiff_t limit = my_min(ph->end - vli, 9); + + if (ph->src >= ph->end) + { + ph->err = ERROR_PATCH_CORRUPT; + return 0; + } + + n = vli[0] & 0x3F; + for (i = 1; i < limit && vli[i - 1] < 0x80; ++i) + n += (INT64)(vli[i] & 0x7F) << (7 * i - 1); + + if (vli[i - 1] < 0x80) + { + TRACE("exceeded maximum vli size\n"); + ph->err = ERROR_PATCH_CORRUPT; + return 0; + } + + if (vli[0] & 0x40) + n = -n; + + ph->src += i; + + return n; +} + +static int compare_ignored_range(const void *a, const void *b) +{ + LONG delta = ((PATCH_IGNORE_RANGE*)a)->OffsetInOldFile - ((PATCH_IGNORE_RANGE*)b)->OffsetInOldFile; + if (delta > 0) + return 1; + if (delta < 0) + return -1; + return 0; +} + +static int compare_retained_range_old(const void *a, const void *b) +{ + LONG delta = ((PATCH_RETAIN_RANGE*)a)->OffsetInOldFile - ((PATCH_RETAIN_RANGE*)b)->OffsetInOldFile; + if (delta > 0) + return 1; + if (delta < 0) + return -1; + return 0; +} + +static int compare_retained_range_new(const void *a, const void *b) +{ + LONG delta = ((PATCH_RETAIN_RANGE*)a)->OffsetInNewFile - ((PATCH_RETAIN_RANGE*)b)->OffsetInNewFile; + if (delta > 0) + return 1; + if (delta < 0) + return -1; + return 0; +} + +static int read_header(struct patch_file_header *ph, const BYTE *buf, size_t size) +{ + unsigned fileno; + + ph->src = buf; + ph->end = buf + size; + + ph->file_table = NULL; + ph->err = ERROR_SUCCESS; + + if (read_raw_uint32(ph) != PA19_FILE_MAGIC) + { + TRACE("no PA19 signature\n"); + ph->err = ERROR_PATCH_CORRUPT; + return -1; + } + + ph->flags = read_raw_uint32(ph); + if ((ph->flags & PATCH_OPTION_SUPPORTED_FLAGS) != ph->flags) + { + FIXME("unsupported option flag(s): 0x%08x\n", ph->flags & ~PATCH_OPTION_SUPPORTED_FLAGS); + ph->err = ERROR_PATCH_PACKAGE_UNSUPPORTED; + return -1; + } + + /* additional 32-bit flag field */ + if (ph->flags & PATCH_OPTION_EXTRA_FLAGS) + { + TRACE("skipping extra flag field\n"); + (void)read_raw_uint32(ph); + } + + /* the meaning of PATCH_OPTION_NO_TIMESTAMP is inverted for decoding */ + if(ph->flags & PATCH_OPTION_NO_TIMESTAMP) + ph->timestamp = read_raw_uint32(ph); + + /* not sure what this value is for but it seems to have no effect on output */ + if (!(ph->flags & PATCH_OPTION_NO_REBASE)) + { + TRACE("skipping rebase field\n"); + (void)read_uvli(ph); + } + + ph->patched_size = (size_t)read_uvli(ph); + TRACE("patched file size will be %u\n", (unsigned)ph->patched_size); + ph->patched_crc32 = read_raw_uint32(ph); + + ph->input_file_count = *ph->src; + ++ph->src; + TRACE("patch supports %u old file(s)\n", ph->input_file_count); + /* if no old file used, input_file_count is still 1 */ + if (ph->input_file_count == 0) + { + ph->err = ERROR_PATCH_CORRUPT; + return -1; + } + + if (ph->err != ERROR_SUCCESS) + return -1; + + ph->file_table = calloc(ph->input_file_count, sizeof(struct input_file_info)); + if (ph->file_table == NULL) + { + ph->err = ERROR_OUTOFMEMORY; + return -1; + } + + for (fileno = 0; fileno < ph->input_file_count; ++fileno) { + struct input_file_info *fi = ph->file_table + fileno; + ptrdiff_t delta; + unsigned i; + + delta = (ptrdiff_t)read_svli(ph); + fi->input_size = ph->patched_size + delta; + + fi->crc32 = read_raw_uint32(ph); + + fi->ignore_range_count = *ph->src; + ++ph->src; + TRACE("found %u range(s) to ignore\n", fi->ignore_range_count); + + for (i = 0; i < fi->ignore_range_count; ++i) { + PATCH_IGNORE_RANGE *ir = fi->ignore_table + i; + + ir->OffsetInOldFile = (LONG)read_svli(ph); + ir->LengthInBytes = (ULONG)read_uvli(ph); + + if (i != 0) + { + ir->OffsetInOldFile += fi->ignore_table[i - 1].OffsetInOldFile + + fi->ignore_table[i - 1].LengthInBytes; + } + if (ir->OffsetInOldFile > fi->input_size + || ir->OffsetInOldFile + ir->LengthInBytes > fi->input_size + || ir->LengthInBytes > fi->input_size) + { + ph->err = ERROR_PATCH_CORRUPT; + return -1; + } + } + + fi->retain_range_count = *ph->src; + ++ph->src; + TRACE("found %u range(s) to retain\n", fi->retain_range_count); + + for (i = 0; i < fi->retain_range_count; ++i) { + PATCH_RETAIN_RANGE *rr = fi->retain_table + i; + + rr->OffsetInOldFile = (LONG)read_svli(ph); + if (i != 0) + rr->OffsetInOldFile += + fi->retain_table[i - 1].OffsetInOldFile + fi->retain_table[i - 1].LengthInBytes; + + rr->OffsetInNewFile = rr->OffsetInOldFile + (LONG)read_svli(ph); + rr->LengthInBytes = (ULONG)read_uvli(ph); + + if (rr->OffsetInOldFile > fi->input_size + || rr->OffsetInOldFile + rr->LengthInBytes > fi->input_size + || rr->OffsetInNewFile > ph->patched_size + || rr->OffsetInNewFile + rr->LengthInBytes > ph->patched_size + || rr->LengthInBytes > ph->patched_size) + { + ph->err = ERROR_PATCH_CORRUPT; + return -1; + } + + /* ranges in new file must be equal and in the same order for all source files */ + if (fileno != 0) + { + PATCH_RETAIN_RANGE *rr_0 = ph->file_table[0].retain_table + i; + if (rr->OffsetInNewFile != rr_0->OffsetInNewFile + || rr->LengthInBytes != rr_0->LengthInBytes) + { + ph->err = ERROR_PATCH_CORRUPT; + return -1; + } + } + } + + fi->unknown_count = (size_t)read_uvli(ph); + if (fi->unknown_count) + { + FIXME("special processing of 32-bit executables not implemented.\n"); + ph->err = ERROR_PATCH_PACKAGE_UNSUPPORTED; + return -1; + } + fi->stream_size = (size_t)read_uvli(ph); + } + + for (fileno = 0; fileno < ph->input_file_count; ++fileno) + { + struct input_file_info *fi = ph->file_table + fileno; + + qsort(fi->ignore_table, fi->ignore_range_count, sizeof(fi->ignore_table[0]), compare_ignored_range); + qsort(fi->retain_table, fi->retain_range_count, sizeof(fi->retain_table[0]), compare_retained_range_old); + + fi->stream_start = ph->src; + ph->src += fi->stream_size; + } + + /* skip the crc adjustment field */ + ph->src = my_min(ph->src + 4, ph->end); + + { + UINT32 crc = compute_crc32(0, buf, ph->src - buf) ^ 0xFFFFFFFF; + if (crc != 0) + { + TRACE("patch file crc32 failed\n"); + if (ph->src < ph->end) + FIXME("probable header parsing error\n"); + ph->err = ERROR_PATCH_CORRUPT; + } + } + + return (ph->err == ERROR_SUCCESS) ? 0 : -1; +} + +static void free_header(struct patch_file_header *ph) +{ + free(ph->file_table); +} + +#define TICKS_PER_SEC 10000000 +#define SEC_TO_UNIX_EPOCH 11644473600LL + +static void posix_time_to_file_time(ULONG timestamp, FILETIME *ft) +{ + UINT64 ticks = ((UINT64)timestamp + SEC_TO_UNIX_EPOCH) * TICKS_PER_SEC; + ft->dwLowDateTime = (DWORD)ticks; + ft->dwHighDateTime = (DWORD)(ticks >> 32); +} + +/* Get the next range to ignore in the old file. + * fi->next_i must be initialized before use */ +static ULONG next_ignored_range(const struct input_file_info *fi, size_t index, ULONG old_file_size, ULONG *end) +{ + ULONG start = old_file_size; + *end = old_file_size; + /* if patching is unnecessary, the ignored ranges are skipped during crc calc */ + if (fi->next_i < fi->ignore_range_count && fi->stream_size != 0) + { + start = fi->ignore_table[fi->next_i].OffsetInOldFile; + *end = my_max(start + fi->ignore_table[fi->next_i].LengthInBytes, index); + start = my_max(start, index); + } + return start; +} + +/* Get the next range to retain from the old file. + * fi->next_r must be initialized before use */ +static ULONG next_retained_range_old(const struct input_file_info *fi, size_t index, ULONG old_file_size, ULONG *end) +{ + ULONG start = old_file_size; + *end = old_file_size; + if (fi->next_r < fi->retain_range_count) + { + start = fi->retain_table[fi->next_r].OffsetInOldFile; + *end = my_max(start + fi->retain_table[fi->next_r].LengthInBytes, index); + start = my_max(start, index); + } + return start; +} + +/* Get the next range to retain in the new file. + * fi->next_r must be initialized before use */ +static ULONG next_retained_range_new(const struct input_file_info *fi, size_t index, ULONG new_file_size, ULONG *end) +{ + ULONG start = new_file_size; + *end = new_file_size; + if (fi->next_r < fi->retain_range_count) + { + start = fi->retain_table[fi->next_r].OffsetInNewFile; + *end = my_max(start + fi->retain_table[fi->next_r].LengthInBytes, index); + start = my_max(start, index); + } + return start; +} + +/* Find the next range in the old file which must be assumed zero-filled during crc32 calc + */ +static ULONG next_zeroed_range(struct input_file_info *fi, size_t index, ULONG old_file_size, ULONG *end) +{ + ULONG start = old_file_size; + ULONG end_i; + ULONG start_i; + ULONG end_r; + ULONG start_r; + + *end = old_file_size; + + start_i = next_ignored_range(fi, index, old_file_size, &end_i); + start_r = next_retained_range_old(fi, index, old_file_size, &end_r); + + if (start_i < start_r) + { + start = start_i; + *end = end_i; + ++fi->next_i; + } + else + { + start = start_r; + *end = end_r; + ++fi->next_r; + } + return start; +} + +/* Use the crc32 of the input file to match the file with an entry in the patch file table + */ +struct input_file_info *find_matching_old_file(const struct patch_file_header *ph, const BYTE *old_file_view, ULONG old_file_size) +{ + unsigned i; + + for (i = 0; i < ph->input_file_count; ++i) + { + DWORD crc32 = 0; + ULONG index; + + if (ph->file_table[i].input_size != old_file_size) + continue; + + ph->file_table[i].next_i = 0; + for (index = 0; index < old_file_size; ) + { + ULONG end; + ULONG start = next_zeroed_range(ph->file_table + i, index, old_file_size, &end); + crc32 = compute_crc32(crc32, old_file_view + index, start - index); + crc32 = compute_zero_crc32(crc32, end - start); + index = end; + } + if (ph->file_table[i].crc32 == crc32) + return ph->file_table + i; + } + return NULL; +} + +/* Zero-fill ignored ranges in the old file data for decoder matching + */ +static void zero_fill_ignored_ranges(BYTE *old_file_buf, const struct input_file_info *fi) +{ + size_t i; + for (i = 0; i < fi->ignore_range_count; ++i) + { + memset(old_file_buf + fi->ignore_table[i].OffsetInOldFile, + 0, + fi->ignore_table[i].LengthInBytes); + } +} + +/* Zero-fill retained ranges in the old file data for decoder matching + */ +static void zero_fill_retained_ranges(BYTE *old_file_buf, BYTE *new_file_buf, const struct input_file_info *fi) +{ + size_t i; + for (i = 0; i < fi->retain_range_count; ++i) + { + memset(old_file_buf + fi->retain_table[i].OffsetInOldFile, + 0, + fi->retain_table[i].LengthInBytes); + } +} + +/* Copy the retained ranges to the new file buffer + */ +static void apply_retained_ranges(const BYTE *old_file_buf, BYTE *new_file_buf, const struct input_file_info *fi) +{ + size_t i; + + if (old_file_buf == NULL) + return; + + for (i = 0; i < fi->retain_range_count; ++i) + { + memcpy(new_file_buf + fi->retain_table[i].OffsetInNewFile, + old_file_buf + fi->retain_table[i].OffsetInOldFile, + fi->retain_table[i].LengthInBytes); + } +} + +/* Compute the crc32 for the new file, assuming zero for the retained ranges + */ +static DWORD compute_target_crc32(struct input_file_info *fi, const BYTE *new_file_buf, ULONG new_file_size) +{ + DWORD crc32 = 0; + ULONG index; + + qsort(fi->retain_table, fi->retain_range_count, sizeof(fi->retain_table[0]), compare_retained_range_new); + fi->next_r = 0; + + for (index = 0; index < new_file_size; ) + { + ULONG end; + ULONG start = next_retained_range_new(fi, index, new_file_size, &end); + ++fi->next_r; + crc32 = compute_crc32(crc32, new_file_buf + index, start - index); + crc32 = compute_zero_crc32(crc32, end - start); + index = end; + } + return crc32; +} + +DWORD apply_patch_to_file_by_buffers(const BYTE *patch_file_view, const ULONG patch_file_size, + const BYTE *old_file_view, ULONG old_file_size, + BYTE **pnew_file_buf, const ULONG new_file_buf_size, ULONG *new_file_size, + FILETIME *new_file_time, + const ULONG apply_option_flags, + PATCH_PROGRESS_CALLBACK *progress_fn, void *progress_ctx, + const BOOL test_header_only) +{ + DWORD err = ERROR_SUCCESS; + struct input_file_info *file_info; + struct patch_file_header ph; + size_t buf_size; + BYTE *new_file_buf = NULL; + BYTE *decode_buf = NULL; + + if (pnew_file_buf == NULL) + { + if (!test_header_only && !(apply_option_flags & APPLY_OPTION_TEST_ONLY)) + return ERROR_INVALID_PARAMETER; + } + else + { + new_file_buf = *pnew_file_buf; + } + + if (old_file_view == NULL) + old_file_size = 0; + + if (read_header(&ph, patch_file_view, patch_file_size)) + { + err = ph.err; + goto free_patch_header; + } + + if (new_file_size != NULL) + *new_file_size = (ULONG)ph.patched_size; + + if (new_file_buf != NULL && new_file_buf_size < ph.patched_size) + { + err = ERROR_INSUFFICIENT_BUFFER; + goto free_patch_header; + } + + file_info = find_matching_old_file(&ph, old_file_view, old_file_size); + if (file_info == NULL) + { + err = ERROR_PATCH_WRONG_FILE; + goto free_patch_header; + } + if (file_info->input_size != old_file_size) + { + err = ERROR_PATCH_CORRUPT; + goto free_patch_header; + } + if (file_info->stream_size == 0 && (apply_option_flags & APPLY_OPTION_FAIL_IF_EXACT)) + { + err = ERROR_PATCH_NOT_NECESSARY; + goto free_patch_header; + } + if (file_info->stream_size != 0 + && file_info->input_size > ((ph.flags & PATCH_OPTION_USE_LZX_LARGE) ? MAX_LARGE_WINDOW : MAX_NORMAL_WINDOW)) + { + /* interleaved by default but not the same as PATCH_OPTION_INTERLEAVE_FILES */ + FIXME("interleaved LZXD decompression is not supported.\n"); + err = ERROR_PATCH_PACKAGE_UNSUPPORTED; + goto free_patch_header; + } + + if (test_header_only) + goto free_patch_header; + + /* missing lzxd stream means it's a header test extract */ + if (file_info->stream_start + file_info->stream_size > ph.end) + { + err = ERROR_PATCH_NOT_AVAILABLE; + goto free_patch_header; + } + + buf_size = old_file_size + ph.patched_size; + decode_buf = new_file_buf; + if (new_file_buf == NULL || new_file_buf_size < buf_size) + { + /* decode_buf must have room for both files, so allocate a new buffer if + * necessary. This will be returned to the caller if new_file_buf == NULL */ + decode_buf = VirtualAlloc(NULL, buf_size, MEM_COMMIT, PAGE_READWRITE); + if (decode_buf == NULL) + { + err = GetLastError(); + goto free_patch_header; + } + } + + if (old_file_view != NULL) + memcpy(decode_buf, old_file_view, file_info->input_size); + + zero_fill_ignored_ranges(decode_buf, file_info); + zero_fill_retained_ranges(decode_buf, decode_buf + file_info->input_size, file_info); + + if (file_info->stream_size != 0) + { + err = decode_lzxd_stream(file_info->stream_start, file_info->stream_size, + decode_buf, ph.patched_size, file_info->input_size, + ph.flags & PATCH_OPTION_USE_LZX_LARGE, + progress_fn, progress_ctx); + } + else if (file_info->input_size == ph.patched_size) + { + /* files are identical so copy old to new. copying is avoidable but rare */ + memcpy(decode_buf + file_info->input_size, decode_buf, ph.patched_size); + } + else + { + err = ERROR_PATCH_CORRUPT; + goto free_decode_buf; + } + + if(err != ERROR_SUCCESS) + { + if (err == ERROR_PATCH_DECODE_FAILURE) + FIXME("decode failure: data corruption or bug.\n"); + goto free_decode_buf; + } + + apply_retained_ranges(old_file_view, decode_buf + file_info->input_size, file_info); + + if (ph.patched_crc32 != compute_target_crc32(file_info, decode_buf + file_info->input_size, ph.patched_size)) + { + err = ERROR_PATCH_CORRUPT; + goto free_decode_buf; + } + + /* retained ranges must be ignored for this test */ + if ((apply_option_flags & APPLY_OPTION_FAIL_IF_EXACT) + && file_info->input_size == ph.patched_size + && memcmp(decode_buf, decode_buf + file_info->input_size, ph.patched_size) == 0) + { + err = ERROR_PATCH_NOT_NECESSARY; + goto free_decode_buf; + } + + if (!(apply_option_flags & APPLY_OPTION_TEST_ONLY)) + { + if (new_file_buf == NULL) + { + /* caller will VirtualFree the buffer */ + new_file_buf = decode_buf; + *pnew_file_buf = new_file_buf; + } + memmove(new_file_buf, decode_buf + old_file_size, ph.patched_size); + } + + if (new_file_time != NULL) + { + new_file_time->dwLowDateTime = 0; + new_file_time->dwHighDateTime = 0; + + /* the meaning of PATCH_OPTION_NO_TIMESTAMP is inverted for decoding */ + if (ph.flags & PATCH_OPTION_NO_TIMESTAMP) + posix_time_to_file_time(ph.timestamp, new_file_time); + } + +free_decode_buf: + if(decode_buf != NULL && decode_buf != new_file_buf) + VirtualFree(decode_buf, 0, MEM_RELEASE); + +free_patch_header: + free_header(&ph); + + return err; +} + +BOOL apply_patch_to_file_by_handles(HANDLE patch_file_hndl, HANDLE old_file_hndl, HANDLE new_file_hndl, + const ULONG apply_option_flags, + PATCH_PROGRESS_CALLBACK *progress_fn, void *progress_ctx, + const BOOL test_header_only) +{ + LARGE_INTEGER patch_size; + LARGE_INTEGER old_size; + HANDLE patch_map; + HANDLE old_map = NULL; + BYTE *patch_buf; + const BYTE *old_buf = NULL; + BYTE *new_buf = NULL; + ULONG new_size; + FILETIME new_time; + BOOL res = FALSE; + DWORD err = ERROR_SUCCESS; + + /* truncate the output file if required, or set the handle to invalid */ + if (test_header_only || (apply_option_flags & APPLY_OPTION_TEST_ONLY)) + { + new_file_hndl = INVALID_HANDLE_VALUE; + } + else if (SetFilePointer(new_file_hndl, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER + || !SetEndOfFile(new_file_hndl)) + { + err = GetLastError(); + return FALSE; + } + + if (patch_file_hndl == INVALID_HANDLE_VALUE) + { + SetLastError(ERROR_INVALID_HANDLE); + return FALSE; + } + + old_size.QuadPart = 0; + if (!GetFileSizeEx(patch_file_hndl, &patch_size) + || (old_file_hndl != INVALID_HANDLE_VALUE && !GetFileSizeEx(old_file_hndl, &old_size))) + { + /* Last error set by API */ + return FALSE; + } + + patch_map = CreateFileMappingW(patch_file_hndl, NULL, PAGE_READONLY, 0, 0, NULL); + if (patch_map == NULL) + { + /* Last error set by API */ + return FALSE; + } + + if (old_file_hndl != INVALID_HANDLE_VALUE) + { + old_map = CreateFileMappingW(old_file_hndl, NULL, PAGE_READONLY, 0, 0, NULL); + if (old_map == NULL) + { + err = GetLastError(); + goto close_patch_map; + } + } + + patch_buf = MapViewOfFile(patch_map, FILE_MAP_READ, 0, 0, (SIZE_T)patch_size.QuadPart); + if (patch_buf == NULL) + { + err = GetLastError(); + goto close_old_map; + } + + if (old_size.QuadPart) + { + old_buf = MapViewOfFile(old_map, FILE_MAP_READ, 0, 0, (SIZE_T)old_size.QuadPart); + if (old_buf == NULL) + { + err = GetLastError(); + goto unmap_patch_buf; + } + } + + err = apply_patch_to_file_by_buffers(patch_buf, (ULONG)patch_size.QuadPart, + old_buf, (ULONG)old_size.QuadPart, + &new_buf, 0, &new_size, + &new_time, + apply_option_flags, progress_fn, progress_ctx, + test_header_only); + + if(err) + goto free_new_buf; + + res = TRUE; + + if(new_file_hndl != INVALID_HANDLE_VALUE) + { + DWORD Written = 0; + res = WriteFile(new_file_hndl, new_buf, new_size, &Written, NULL); + + if (!res) + err = GetLastError(); + else if (new_time.dwLowDateTime || new_time.dwHighDateTime) + SetFileTime(new_file_hndl, &new_time, NULL, &new_time); + } + +free_new_buf: + if (new_buf != NULL) + VirtualFree(new_buf, 0, MEM_RELEASE); + + if (old_buf != NULL) + UnmapViewOfFile(old_buf); + +unmap_patch_buf: + UnmapViewOfFile(patch_buf); + +close_old_map: + if (old_map != NULL) + CloseHandle(old_map); + +close_patch_map: + CloseHandle(patch_map); + + SetLastError(err); + + return res; +} + +BOOL apply_patch_to_file(LPCWSTR patch_file_name, LPCWSTR old_file_name, LPCWSTR new_file_name, + const ULONG apply_option_flags, + PATCH_PROGRESS_CALLBACK *progress_fn, void *progress_ctx, + const BOOL test_header_only) +{ + HANDLE patch_hndl; + HANDLE old_hndl = INVALID_HANDLE_VALUE; + HANDLE new_hndl = INVALID_HANDLE_VALUE; + BOOL res = FALSE; + DWORD err = ERROR_SUCCESS; + + patch_hndl = CreateFileW(patch_file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); + if (patch_hndl == INVALID_HANDLE_VALUE) + { + /* last error set by CreateFileW */ + return FALSE; + } + + if (old_file_name != NULL) + { + old_hndl = CreateFileW(old_file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); + if (old_hndl == INVALID_HANDLE_VALUE) + { + err = GetLastError(); + goto close_patch_file; + } + } + + if (!test_header_only && !(apply_option_flags & APPLY_OPTION_TEST_ONLY)) + { + new_hndl = CreateFileW(new_file_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); + if (new_hndl == INVALID_HANDLE_VALUE) + { + err = GetLastError(); + goto close_old_file; + } + } + + res = apply_patch_to_file_by_handles(patch_hndl, old_hndl, new_hndl, apply_option_flags, progress_fn, progress_ctx, test_header_only); + if(!res) + err = GetLastError(); + + if (new_hndl != INVALID_HANDLE_VALUE) + { + CloseHandle(new_hndl); + if (!res) + DeleteFileW(new_file_name); + } + +close_old_file: + if (old_hndl != INVALID_HANDLE_VALUE) + CloseHandle(old_hndl); + +close_patch_file: + CloseHandle(patch_hndl); + + /* set last error even on success as per windows */ + SetLastError(err); + + return res; +} diff --git a/dlls/mspatcha/pa19.h b/dlls/mspatcha/pa19.h new file mode 100755 index 0000000..9a9d0f3 --- /dev/null +++ b/dlls/mspatcha/pa19.h @@ -0,0 +1,52 @@ +/* + * PatchAPI PA19 file format handlers + * + * Copyright 2019 Conor McCarthy + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +DWORD apply_patch_to_file_by_buffers(const BYTE *patch_file_view, const ULONG patch_file_size, + const BYTE *old_file_view, ULONG old_file_size, + BYTE **new_file_buf, const ULONG new_file_buf_size, ULONG *new_file_size, + FILETIME *new_file_time, + const ULONG apply_option_flags, + PATCH_PROGRESS_CALLBACK *progress_fn, void *progress_ctx, + const BOOL test_header_only); + +BOOL apply_patch_to_file_by_handles(HANDLE patch_file_hndl, HANDLE old_file_hndl, HANDLE new_file_hndl, + const ULONG apply_option_flags, + PATCH_PROGRESS_CALLBACK *progress_fn, void *progress_ctx, + const BOOL test_header_only); + +BOOL apply_patch_to_file(LPCWSTR patch_file_name, LPCWSTR old_file_name, LPCWSTR new_file_name, + const ULONG apply_option_flags, + PATCH_PROGRESS_CALLBACK *progress_fn, void *progress_ctx, + const BOOL test_header_only); diff --git a/include/patchapi.h b/include/patchapi.h index 5adaf0a..1ccdf9d 100644 --- a/include/patchapi.h +++ b/include/patchapi.h @@ -1,5 +1,6 @@ /* * Copyright 2011 Hans Leidekker for CodeWeavers + * Copyright 2019 Conor McCarthy * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -23,11 +24,33 @@ extern "C" { #endif +#define PATCH_OPTION_USE_LZX_A 0x00000001 +#define PATCH_OPTION_USE_LZX_B 0x00000002 +#define PATCH_OPTION_USE_LZX_LARGE 0x00000004 /* raise maximum window from 8 -> 32 Mb */ + +#define PATCH_OPTION_NO_BINDFIX 0x00010000 +#define PATCH_OPTION_NO_LOCKFIX 0x00020000 +#define PATCH_OPTION_NO_REBASE 0x00040000 +#define PATCH_OPTION_FAIL_IF_SAME_FILE 0x00080000 +#define PATCH_OPTION_FAIL_IF_BIGGER 0x00100000 +#define PATCH_OPTION_NO_CHECKSUM 0x00200000 +#define PATCH_OPTION_NO_RESTIMEFIX 0x00400000 +#define PATCH_OPTION_NO_TIMESTAMP 0x00800000 +#define PATCH_OPTION_INTERLEAVE_FILES 0x40000000 +#define PATCH_OPTION_RESERVED1 0x80000000 + #define APPLY_OPTION_FAIL_IF_EXACT 0x00000001 #define APPLY_OPTION_FAIL_IF_CLOSE 0x00000002 #define APPLY_OPTION_TEST_ONLY 0x00000004 #define APPLY_OPTION_VALID_FLAGS 0x00000007 +#define ERROR_PATCH_DECODE_FAILURE 0xC00E4101 +#define ERROR_PATCH_CORRUPT 0xC00E4102 +#define ERROR_PATCH_NEWER_FORMAT 0xC00E4103 +#define ERROR_PATCH_WRONG_FILE 0xC00E4104 +#define ERROR_PATCH_NOT_NECESSARY 0xC00E4105 +#define ERROR_PATCH_NOT_AVAILABLE 0xC00E4106 + typedef struct _PATCH_IGNORE_RANGE { ULONG OffsetInOldFile; @@ -41,16 +64,66 @@ typedef struct _PATCH_RETAIN_RANGE ULONG OffsetInNewFile; } PATCH_RETAIN_RANGE, *PPATCH_RETAIN_RANGE; +typedef struct _PATCH_INTERLEAVE_MAP { + ULONG CountRanges; + struct { + ULONG OldOffset; + ULONG OldLength; + ULONG NewLength; + } Range[1]; +} PATCH_INTERLEAVE_MAP, *PPATCH_INTERLEAVE_MAP; + +typedef BOOL(CALLBACK PATCH_SYMLOAD_CALLBACK)(ULONG, LPCSTR, ULONG, ULONG, ULONG, ULONG, ULONG, PVOID); + +typedef PATCH_SYMLOAD_CALLBACK *PPATCH_SYMLOAD_CALLBACK; + +typedef struct _PATCH_OPTION_DATA { + ULONG SizeOfThisStruct; + ULONG SymbolOptionFlags; + LPCSTR NewFileSymbolPath; + LPCSTR *OldFileSymbolPathArray; + ULONG ExtendedOptionFlags; + PPATCH_SYMLOAD_CALLBACK SymLoadCallback; + PVOID SymLoadContext; + PPATCH_INTERLEAVE_MAP* InterleaveMapArray; + ULONG MaxLzxWindowSize; +} PATCH_OPTION_DATA, *PPATCH_OPTION_DATA; + +typedef BOOL (CALLBACK PATCH_PROGRESS_CALLBACK)(PVOID, ULONG, ULONG); + +typedef PATCH_PROGRESS_CALLBACK *PPATCH_PROGRESS_CALLBACK; + BOOL WINAPI ApplyPatchToFileA(LPCSTR,LPCSTR,LPCSTR,ULONG); BOOL WINAPI ApplyPatchToFileW(LPCWSTR,LPCWSTR,LPCWSTR,ULONG); #define ApplyPatchToFile WINELIB_NAME_AW(ApplyPatchToFile) +BOOL WINAPI ApplyPatchToFileByHandles(HANDLE, HANDLE, HANDLE, ULONG); +BOOL WINAPI ApplyPatchToFileExA(LPCSTR, LPCSTR, LPCSTR, ULONG, PPATCH_PROGRESS_CALLBACK, PVOID); +BOOL WINAPI ApplyPatchToFileExW(LPCWSTR, LPCWSTR, LPCWSTR, ULONG, PPATCH_PROGRESS_CALLBACK, PVOID); +#define ApplyPatchToFileEx WINELIB_NAME_AW(ApplyPatchToFileEx) +BOOL WINAPI ApplyPatchToFileByHandlesEx(HANDLE, HANDLE, HANDLE, ULONG, PPATCH_PROGRESS_CALLBACK, PVOID); +BOOL WINAPI ApplyPatchToFileByBuffers(PBYTE, ULONG, PBYTE, ULONG, PBYTE*, ULONG, ULONG*, FILETIME*, ULONG, + PPATCH_PROGRESS_CALLBACK, PVOID); + +BOOL WINAPI TestApplyPatchToFileA(LPCSTR, LPCSTR, ULONG); +BOOL WINAPI TestApplyPatchToFileW(LPCWSTR, LPCWSTR, ULONG); +#define TestApplyPatchToFile WINELIB_NAME_AW(TestApplyPatchToFile) +BOOL WINAPI TestApplyPatchToFileByHandles(HANDLE, HANDLE, ULONG); +BOOL WINAPI TestApplyPatchToFileByBuffers(PBYTE, ULONG, PBYTE, ULONG, ULONG*, ULONG); + BOOL WINAPI GetFilePatchSignatureA(LPCSTR, ULONG, PVOID, ULONG, PPATCH_IGNORE_RANGE, ULONG, PPATCH_RETAIN_RANGE, ULONG, LPSTR); BOOL WINAPI GetFilePatchSignatureW(LPCWSTR, ULONG, PVOID, ULONG, PPATCH_IGNORE_RANGE, ULONG, PPATCH_RETAIN_RANGE, ULONG, LPWSTR); #define GetFilePatchSignature WINELIB_NAME_AW(GetFilePatchSignature) +BOOL WINAPI GetFilePatchSignatureByHandle(HANDLE, ULONG, PVOID, ULONG, PPATCH_IGNORE_RANGE, + ULONG, PPATCH_RETAIN_RANGE, ULONG, LPSTR); +BOOL WINAPI GetFilePatchSignatureByBuffer(PBYTE, ULONG, ULONG, PVOID, ULONG, PPATCH_IGNORE_RANGE, ULONG, + PPATCH_RETAIN_RANGE, ULONG, LPSTR); +INT WINAPI NormalizeFileForPatchSignature(PVOID, ULONG, ULONG, PATCH_OPTION_DATA*, ULONG, + ULONG, ULONG, PPATCH_IGNORE_RANGE, ULONG, PPATCH_RETAIN_RANGE); + #ifdef __cplusplus } #endif -- 2.7.4

3 4

[PATCH 6/6] wined3d: Pass a wined3d_context_gl structure to context_bind_texture().
by Henri Verbeet 07 May '19

07 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 28 ++++++++++++++-------------- dlls/wined3d/state.c | 3 ++- dlls/wined3d/surface.c | 18 +++++++++++------- dlls/wined3d/texture.c | 5 +++-- dlls/wined3d/view.c | 16 +++++++++++----- dlls/wined3d/wined3d_private.h | 3 ++- 6 files changed, 43 insertions(+), 30 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 5cc0c57a514..9aa78f591a7 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -2528,22 +2528,20 @@ void context_bind_bo(struct wined3d_context *context, GLenum binding, GLuint nam GL_EXTCALL(glBindBuffer(binding, name)); } -void context_bind_texture(struct wined3d_context *context, GLenum target, GLuint name) +void wined3d_context_gl_bind_texture(struct wined3d_context_gl *context_gl, GLenum target, GLuint name) { - const struct wined3d_dummy_textures *textures = &wined3d_device_gl(context->device)->dummy_textures; - const struct wined3d_gl_info *gl_info = context->gl_info; - DWORD unit = context->active_texture; - DWORD old_texture_type = context->texture_type[unit]; + const struct wined3d_dummy_textures *textures = &wined3d_device_gl(context_gl->c.device)->dummy_textures; + const struct wined3d_gl_info *gl_info = context_gl->c.gl_info; + GLenum old_texture_type; + unsigned int unit; if (name) - { gl_info->gl_ops.gl.p_glBindTexture(target, name); - } else - { target = GL_NONE; - } + unit = context_gl->c.active_texture; + old_texture_type = context_gl->c.texture_type[unit]; if (old_texture_type != target) { switch (old_texture_type) @@ -2588,7 +2586,7 @@ void context_bind_texture(struct wined3d_context *context, GLenum target, GLuint ERR("Unexpected texture target %#x.\n", old_texture_type); } - context->texture_type[unit] = target; + context_gl->c.texture_type[unit] = target; } checkGLcall("bind texture"); @@ -5558,6 +5556,7 @@ void context_draw_shaded_quad(struct wined3d_context *context, struct wined3d_te unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect, enum wined3d_texture_filter_type filter) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_gl_info *gl_info = context->gl_info; struct wined3d_blt_info info; unsigned int level, w, h, i; @@ -5572,7 +5571,7 @@ void context_draw_shaded_quad(struct wined3d_context *context, struct wined3d_te texture2d_get_blt_info(texture_gl, sub_resource_idx, src_rect, &info); level = sub_resource_idx % texture_gl->t.level_count; - context_bind_texture(context, info.bind_target, texture_gl->texture_rgb.name); + wined3d_context_gl_bind_texture(context_gl, info.bind_target, texture_gl->texture_rgb.name); apply_texture_blit_state(gl_info, &texture_gl->texture_rgb, info.bind_target, level, filter); gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, level); @@ -5635,7 +5634,7 @@ void context_draw_shaded_quad(struct wined3d_context *context, struct wined3d_te checkGLcall("draw"); gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, texture_gl->t.level_count - 1); - context_bind_texture(context, info.bind_target, 0); + wined3d_context_gl_bind_texture(context_gl, info.bind_target, 0); } /* Context activation is done by the caller. */ @@ -5643,6 +5642,7 @@ void context_draw_textured_quad(struct wined3d_context *context, struct wined3d_ unsigned int sub_resource_idx, const RECT *src_rect, const RECT *dst_rect, enum wined3d_texture_filter_type filter) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_gl_info *gl_info = context->gl_info; struct wined3d_blt_info info; unsigned int level; @@ -5653,7 +5653,7 @@ void context_draw_textured_quad(struct wined3d_context *context, struct wined3d_ checkGLcall("glEnable(bind_target)"); level = sub_resource_idx % texture_gl->t.level_count; - context_bind_texture(context, info.bind_target, texture_gl->texture_rgb.name); + wined3d_context_gl_bind_texture(context_gl, info.bind_target, texture_gl->texture_rgb.name); apply_texture_blit_state(gl_info, &texture_gl->texture_rgb, info.bind_target, level, filter); gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, level); gl_info->gl_ops.gl.p_glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); @@ -5675,5 +5675,5 @@ void context_draw_textured_quad(struct wined3d_context *context, struct wined3d_ gl_info->gl_ops.gl.p_glEnd(); gl_info->gl_ops.gl.p_glTexParameteri(info.bind_target, GL_TEXTURE_MAX_LEVEL, texture_gl->t.level_count - 1); - context_bind_texture(context, info.bind_target, 0); + wined3d_context_gl_bind_texture(context_gl, info.bind_target, 0); } diff --git a/dlls/wined3d/state.c b/dlls/wined3d/state.c index d995fe89b0a..f2ae39e565b 100644 --- a/dlls/wined3d/state.c +++ b/dlls/wined3d/state.c @@ -3596,6 +3596,7 @@ static void wined3d_sampler_desc_from_sampler_states(struct wined3d_sampler_desc * texture states. */ static void sampler(struct wined3d_context *context, const struct wined3d_state *state, DWORD state_id) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); DWORD sampler_idx = state_id - STATE_SAMPLER(0); DWORD mapped_stage = context->tex_unit_map[sampler_idx]; const struct wined3d_gl_info *gl_info = context->gl_info; @@ -3653,7 +3654,7 @@ static void sampler(struct wined3d_context *context, const struct wined3d_state } else { - context_bind_texture(context, GL_NONE, 0); + wined3d_context_gl_bind_texture(context_gl, GL_NONE, 0); if (gl_info->supported[ARB_SAMPLER_OBJECTS]) { GL_EXTCALL(glBindSampler(mapped_stage, 0)); diff --git a/dlls/wined3d/surface.c b/dlls/wined3d/surface.c index 48ca35bb3b3..2c5ea75ebbb 100644 --- a/dlls/wined3d/surface.c +++ b/dlls/wined3d/surface.c @@ -888,6 +888,7 @@ static void fb_copy_to_texture_direct(struct wined3d_texture_gl *dst_texture, un struct wined3d_device *device = dst_texture->t.resource.device; unsigned int src_height, src_level, dst_level; const struct wined3d_gl_info *gl_info; + struct wined3d_context_gl *context_gl; float xrel, yrel; struct wined3d_context *context; BOOL upsidedown = FALSE; @@ -905,12 +906,13 @@ static void fb_copy_to_texture_direct(struct wined3d_texture_gl *dst_texture, un } context = context_acquire(device, &src_texture->t, src_sub_resource_idx); + context_gl = wined3d_context_gl(context); gl_info = context->gl_info; context_apply_blit_state(context, device); wined3d_texture_load(&dst_texture->t, context, FALSE); /* Bind the target texture */ - context_bind_texture(context, dst_texture->target, dst_texture->texture_rgb.name); + wined3d_context_gl_bind_texture(context_gl, dst_texture->target, dst_texture->texture_rgb.name); if (wined3d_resource_is_offscreen(&src_texture->t.resource)) { TRACE("Reading from an offscreen target\n"); @@ -1008,6 +1010,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, GLuint src, backup = 0; float left, right, top, bottom; /* Texture coordinates */ const struct wined3d_gl_info *gl_info; + struct wined3d_context_gl *context_gl; struct wined3d_context *context; GLenum drawBuffer = GL_BACK; GLenum offscreen_buffer; @@ -1023,6 +1026,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, /* Activate the Proper context for reading from the source surface, set it up for blitting */ context = context_acquire(device, &src_texture->t, src_sub_resource_idx); + context_gl = wined3d_context_gl(context); gl_info = context->gl_info; context_apply_ffp_blit_state(context, device); wined3d_texture_load(&dst_texture->t, context, FALSE); @@ -1060,7 +1064,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, { gl_info->gl_ops.gl.p_glGenTextures(1, &backup); checkGLcall("glGenTextures"); - context_bind_texture(context, GL_TEXTURE_2D, backup); + wined3d_context_gl_bind_texture(context_gl, GL_TEXTURE_2D, backup); texture_target = GL_TEXTURE_2D; } else @@ -1069,7 +1073,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, * we are reading from the back buffer, the backup can be used as source texture */ texture_target = src_target; - context_bind_texture(context, texture_target, src_texture->texture_rgb.name); + wined3d_context_gl_bind_texture(context_gl, texture_target, src_texture->texture_rgb.name); gl_info->gl_ops.gl.p_glEnable(texture_target); checkGLcall("glEnable(texture_target)"); @@ -1121,7 +1125,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, gl_info->gl_ops.gl.p_glGenTextures(1, &src); checkGLcall("glGenTextures(1, &src)"); - context_bind_texture(context, GL_TEXTURE_2D, src); + wined3d_context_gl_bind_texture(context_gl, GL_TEXTURE_2D, src); /* TODO: Only copy the part that will be read. Use src_rect->left, * src_rect->bottom as origin, but with the width watch out for power @@ -1204,7 +1208,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, } /* Now read the stretched and upside down image into the destination texture */ - context_bind_texture(context, texture_target, dst_texture->texture_rgb.name); + wined3d_context_gl_bind_texture(context_gl, texture_target, dst_texture->texture_rgb.name); gl_info->gl_ops.gl.p_glCopyTexSubImage2D(texture_target, 0, dst_rect.left, dst_rect.top, /* xoffset, yoffset */ @@ -1223,7 +1227,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, gl_info->gl_ops.gl.p_glEnable(GL_TEXTURE_2D); texture_target = GL_TEXTURE_2D; } - context_bind_texture(context, GL_TEXTURE_2D, backup); + wined3d_context_gl_bind_texture(context_gl, GL_TEXTURE_2D, backup); } else { @@ -1233,7 +1237,7 @@ static void fb_copy_to_texture_hwstretch(struct wined3d_texture_gl *dst_texture, gl_info->gl_ops.gl.p_glEnable(src_target); texture_target = src_target; } - context_bind_texture(context, src_target, src_texture->texture_rgb.name); + wined3d_context_gl_bind_texture(context_gl, src_target, src_texture->texture_rgb.name); } gl_info->gl_ops.gl.p_glBegin(GL_QUADS); diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 949492063d2..b72b8415388 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -928,6 +928,7 @@ void wined3d_gl_texture_swizzle_from_color_fixup(GLint swizzle[4], struct color_ void wined3d_texture_gl_bind(struct wined3d_texture_gl *texture_gl, struct wined3d_context *context, BOOL srgb) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_format *format = texture_gl->t.resource.format; const struct color_fixup_desc fixup = format->color_fixup; const struct wined3d_gl_info *gl_info = context->gl_info; @@ -950,7 +951,7 @@ void wined3d_texture_gl_bind(struct wined3d_texture_gl *texture_gl, if (gl_tex->name) { - context_bind_texture(context, target, gl_tex->name); + wined3d_context_gl_bind_texture(context_gl, target, gl_tex->name); return; } @@ -986,7 +987,7 @@ void wined3d_texture_gl_bind(struct wined3d_texture_gl *texture_gl, gl_tex->base_level = 0; wined3d_texture_set_dirty(&texture_gl->t); - context_bind_texture(context, target, gl_tex->name); + wined3d_context_gl_bind_texture(context_gl, target, gl_tex->name); /* For a new texture we have to set the texture levels after binding the * texture. Beware that texture rectangles do not support mipmapping, but diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index 0cfadf7329b..7815e3963a1 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -172,6 +172,7 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target const struct wined3d_format_gl *view_format_gl; unsigned int level_idx, layer_idx, layer_count; const struct wined3d_gl_info *gl_info; + struct wined3d_context_gl *context_gl; struct wined3d_context *context; GLuint texture_name; @@ -179,6 +180,7 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target view->target = view_target; context = context_acquire(texture_gl->t.resource.device, NULL, 0); + context_gl = wined3d_context_gl(context); gl_info = context->gl_info; if (!gl_info->supported[ARB_TEXTURE_VIEW]) @@ -218,7 +220,7 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target return; } - context_bind_texture(context, view->target, view->name); + wined3d_context_gl_bind_texture(context_gl, view->target, view->name); gl_info->gl_ops.gl.p_glTexParameteriv(view->target, GL_TEXTURE_SWIZZLE_RGBA, swizzle); gl_info->gl_ops.gl.p_glTexParameteri(view->target, GL_DEPTH_STENCIL_TEXTURE_MODE, GL_STENCIL_INDEX); checkGLcall("initialize stencil view"); @@ -230,7 +232,7 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target { GLint swizzle[4]; - context_bind_texture(context, view->target, view->name); + wined3d_context_gl_bind_texture(context_gl, view->target, view->name); wined3d_gl_texture_swizzle_from_color_fixup(swizzle, view_format->color_fixup); gl_info->gl_ops.gl.p_glTexParameteriv(view->target, GL_TEXTURE_SWIZZLE_RGBA, swizzle); checkGLcall("set format swizzle"); @@ -246,6 +248,7 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c struct wined3d_buffer *buffer, const struct wined3d_format *view_format, unsigned int offset, unsigned int size) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_gl_info *gl_info = context->gl_info; const struct wined3d_format_gl *view_format_gl; @@ -268,7 +271,7 @@ static void create_buffer_texture(struct wined3d_gl_view *view, struct wined3d_c view->target = GL_TEXTURE_BUFFER; gl_info->gl_ops.gl.p_glGenTextures(1, &view->name); - context_bind_texture(context, GL_TEXTURE_BUFFER, view->name); + wined3d_context_gl_bind_texture(context_gl, GL_TEXTURE_BUFFER, view->name); if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE]) { GL_EXTCALL(glTexBufferRange(GL_TEXTURE_BUFFER, view_format_gl->internal, @@ -827,6 +830,7 @@ HRESULT CDECL wined3d_shader_resource_view_create(const struct wined3d_view_desc void wined3d_shader_resource_view_gl_bind(struct wined3d_shader_resource_view_gl *view_gl, unsigned int unit, struct wined3d_sampler *sampler, struct wined3d_context *context) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); const struct wined3d_gl_info *gl_info = context->gl_info; struct wined3d_texture_gl *texture_gl; @@ -834,7 +838,7 @@ void wined3d_shader_resource_view_gl_bind(struct wined3d_shader_resource_view_gl if (view_gl->gl_view.name) { - context_bind_texture(context, view_gl->gl_view.target, view_gl->gl_view.name); + wined3d_context_gl_bind_texture(context_gl, view_gl->gl_view.target, view_gl->gl_view.name); wined3d_sampler_bind(sampler, unit, NULL, context); return; } @@ -854,6 +858,8 @@ void wined3d_shader_resource_view_gl_bind(struct wined3d_shader_resource_view_gl static void shader_resource_view_gl_bind_and_dirtify(struct wined3d_shader_resource_view_gl *view_gl, struct wined3d_context *context) { + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); + if (context->active_texture < ARRAY_SIZE(context->rev_tex_unit_map)) { DWORD active_sampler = context->rev_tex_unit_map[context->active_texture]; @@ -865,7 +871,7 @@ static void shader_resource_view_gl_bind_and_dirtify(struct wined3d_shader_resou context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING); context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING); - context_bind_texture(context, view_gl->gl_view.target, view_gl->gl_view.name); + wined3d_context_gl_bind_texture(context_gl, view_gl->gl_view.target, view_gl->gl_view.name); } void shader_resource_view_generate_mipmaps(struct wined3d_shader_resource_view *view) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 3934fba4acd..5151a684706 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2044,6 +2044,8 @@ static inline struct wined3d_context_gl *wined3d_context_gl(struct wined3d_conte return CONTAINING_RECORD(context, struct wined3d_context_gl, c); } +void wined3d_context_gl_bind_texture(struct wined3d_context_gl *context_gl, + GLenum target, GLuint name) DECLSPEC_HIDDEN; void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) DECLSPEC_HIDDEN; HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; @@ -2203,7 +2205,6 @@ void context_active_texture(struct wined3d_context *context, const struct wined3 unsigned int unit) DECLSPEC_HIDDEN; void context_bind_bo(struct wined3d_context *context, GLenum binding, GLuint name) DECLSPEC_HIDDEN; void context_bind_dummy_textures(const struct wined3d_context *context) DECLSPEC_HIDDEN; -void context_bind_texture(struct wined3d_context *context, GLenum target, GLuint name) DECLSPEC_HIDDEN; void context_check_fbo_status(const struct wined3d_context *context, GLenum target) DECLSPEC_HIDDEN; void context_copy_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *dst, GLenum dst_binding, -- 2.11.0

1 0

[PATCH 5/6] wined3d: Make the adapter responsible for context destruction and allocation.
by Henri Verbeet 07 May '19

07 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 48 ++++++++++++++- dlls/wined3d/adapter_vk.c | 28 ++++++++- dlls/wined3d/context.c | 132 +++++++++++++++++++---------------------- dlls/wined3d/directx.c | 30 +++++++++- dlls/wined3d/wined3d_private.h | 16 ++++- 5 files changed, 176 insertions(+), 78 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 972d051a6b2..be21fd8f349 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4273,6 +4273,51 @@ static void adapter_gl_destroy_device(struct wined3d_device *device) heap_free(device_gl); } +static HRESULT adapter_gl_create_context(struct wined3d_swapchain *swapchain, struct wined3d_context **context) +{ + struct wined3d_context_gl *context_gl; + + TRACE("swapchain %p, context %p.\n", swapchain, context); + + if (!(context_gl = heap_alloc_zero(sizeof(*context_gl)))) + return E_OUTOFMEMORY; + + if (FAILED(wined3d_context_gl_init(context_gl, swapchain))) + { + WARN("Failed to initialise context.\n"); + heap_free(context_gl); + return E_FAIL; + } + + TRACE("Created context %p.\n", context_gl); + *context = &context_gl->c; + + return WINED3D_OK; +} + +static void adapter_gl_destroy_context(struct wined3d_context *context) +{ + struct wined3d_context_gl *context_gl = wined3d_context_gl(context); + + if (context_gl->c.current && context_gl->c.tid != GetCurrentThreadId()) + { + struct wined3d_gl_info *gl_info; + + /* Make a copy of gl_info for wined3d_context_gl_cleanup() use, the + * one in wined3d_adapter may go away in the meantime. */ + gl_info = heap_alloc(sizeof(*gl_info)); + *gl_info = *context_gl->c.gl_info; + context_gl->c.gl_info = gl_info; + context_gl->c.destroyed = 1; + + return; + } + + wined3d_context_gl_cleanup(context_gl); + TlsSetValue(context_get_tls_idx(), NULL); + heap_free(context_gl); +} + static void adapter_gl_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps) { const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; @@ -4558,7 +4603,8 @@ static const struct wined3d_adapter_ops wined3d_adapter_gl_ops = adapter_gl_destroy, adapter_gl_create_device, adapter_gl_destroy_device, - wined3d_adapter_gl_create_context, + adapter_gl_create_context, + adapter_gl_destroy_context, adapter_gl_get_wined3d_caps, adapter_gl_check_format, adapter_gl_init_3d, diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index d6438945361..4ef142384cd 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -288,9 +288,32 @@ static void adapter_vk_destroy_device(struct wined3d_device *device) heap_free(device_vk); } -static BOOL adapter_vk_create_context(struct wined3d_context *context) +static HRESULT adapter_vk_create_context(struct wined3d_swapchain *swapchain, struct wined3d_context **context) { - return TRUE; + struct wined3d_context *context_vk; + + TRACE("swapchain %p, context %p.\n", swapchain, context); + + if (!(context_vk = heap_alloc_zero(sizeof(*context_vk)))) + return E_OUTOFMEMORY; + + if (FAILED(wined3d_context_vk_init(context_vk, swapchain))) + { + WARN("Failed to initialise context.\n"); + heap_free(context_vk); + return E_FAIL; + } + + TRACE("Created context %p.\n", context_vk); + *context = context_vk; + + return WINED3D_OK; +} + +static void adapter_vk_destroy_context(struct wined3d_context *context) +{ + wined3d_context_cleanup(context); + heap_free(context); } static void adapter_vk_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps) @@ -416,6 +439,7 @@ static const struct wined3d_adapter_ops wined3d_adapter_vk_ops = adapter_vk_create_device, adapter_vk_destroy_device, adapter_vk_create_context, + adapter_vk_destroy_context, adapter_vk_get_wined3d_caps, adapter_vk_check_format, adapter_vk_init_3d, diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index fdf7f9ccc65..5cc0c57a514 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1312,7 +1312,7 @@ static void context_update_window(struct wined3d_context *context) } } -static void wined3d_context_cleanup(struct wined3d_context *context) +void wined3d_context_cleanup(struct wined3d_context *context) { struct wined3d_pipeline_statistics_query *pipeline_statistics_query; const struct wined3d_gl_info *gl_info = context->gl_info; @@ -1482,32 +1482,11 @@ static void wined3d_context_cleanup(struct wined3d_context *context) heap_free(context->texture_type); } -static void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) +void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) { wined3d_context_cleanup(&context_gl->c); } -static void wined3d_context_gl_destroy(struct wined3d_context_gl *context_gl) -{ - if (context_gl->c.current && context_gl->c.tid != GetCurrentThreadId()) - { - struct wined3d_gl_info *gl_info; - - /* Make a copy of gl_info for wined3d_context_gl_cleanup() use, the - * one in wined3d_adapter may go away in the meantime. */ - gl_info = heap_alloc(sizeof(*gl_info)); - *gl_info = *context_gl->c.gl_info; - context_gl->c.gl_info = gl_info; - context_gl->c.destroyed = 1; - - return; - } - - wined3d_context_gl_cleanup(context_gl); - TlsSetValue(wined3d_context_tls_idx, NULL); - heap_free(context_gl); -} - DWORD context_get_tls_idx(void) { return wined3d_context_tls_idx; @@ -1965,56 +1944,34 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d return TRUE; } -struct wined3d_context *context_create(struct wined3d_swapchain *swapchain) +HRESULT wined3d_context_no3d_init(struct wined3d_context *context_no3d, struct wined3d_swapchain *swapchain) { - struct wined3d_device *device = swapchain->device; - struct wined3d_context_gl *context_gl; - struct wined3d_context *context; - - TRACE("swapchain %p.\n", swapchain); - - wined3d_from_cs(device->cs); - - if (!(context_gl = heap_alloc_zero(sizeof(*context_gl)))) - return NULL; - context = &context_gl->c; + TRACE("context_no3d %p, swapchain %p.\n", context_no3d, swapchain); - if (!(wined3d_context_init(context, swapchain))) - { - heap_free(context_gl); - return NULL; - } - if (!(device->adapter->adapter_ops->adapter_create_context(context))) - { - wined3d_release_dc(context->win_handle, context->hdc); - heap_free(context_gl); - return NULL; - } - - if (!device_context_add(device, context)) - { - ERR("Failed to add the newly created context to the context list\n"); - wined3d_context_gl_destroy(context_gl); - return NULL; - } - - TRACE("Created context %p.\n", context); + if (!wined3d_context_init(context_no3d, swapchain)) + return E_FAIL; - return context; + return WINED3D_OK; } -BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) +HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, struct wined3d_swapchain *swapchain) { - struct wined3d_swapchain *swapchain = context->swapchain; const struct wined3d_format *color_format, *ds_format; - struct wined3d_device *device = context->device; + struct wined3d_context *context = &context_gl->c; const struct wined3d_d3d_info *d3d_info; const struct wined3d_gl_info *gl_info; struct wined3d_resource *target; unsigned int target_bind_flags; + struct wined3d_device *device; HGLRC ctx, share_ctx; unsigned int i; + TRACE("context_gl %p, swapchain %p.\n", context_gl, swapchain); + + if (!wined3d_context_init(&context_gl->c, swapchain)) + return E_FAIL; + + device = context->device; gl_info = context->gl_info; d3d_info = context->d3d_info; @@ -2031,7 +1988,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) if (base + WINED3D_MAX_FRAGMENT_SAMPLERS > ARRAY_SIZE(context->rev_tex_unit_map)) { ERR("Unexpected texture unit base index %u.\n", base); - return FALSE; + return E_FAIL; } for (i = 0; i < min(count, WINED3D_MAX_FRAGMENT_SAMPLERS); ++i) { @@ -2043,7 +2000,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) if (base + WINED3D_MAX_VERTEX_SAMPLERS > ARRAY_SIZE(context->rev_tex_unit_map)) { ERR("Unexpected texture unit base index %u.\n", base); - return FALSE; + return E_FAIL; } for (i = 0; i < min(count, WINED3D_MAX_VERTEX_SAMPLERS); ++i) { @@ -2054,7 +2011,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) if (!(context->texture_type = heap_calloc(gl_info->limits.combined_samplers, sizeof(*context->texture_type)))) - return FALSE; + return E_FAIL; target = &context->current_rt.texture->resource; target_bind_flags = target->bind_flags; @@ -2128,7 +2085,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) } if (!context->pixel_format) - return FALSE; + return E_FAIL; context_enter(context); @@ -2137,7 +2094,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) ERR("Failed to set pixel format %d on device context %p.\n", context->pixel_format, context->hdc); context_release(context); heap_free(context->texture_type); - return FALSE; + return E_FAIL; } share_ctx = device->context_count ? device->contexts[0]->glCtx : NULL; @@ -2147,7 +2104,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) { context_release(context); heap_free(context->texture_type); - return FALSE; + return E_FAIL; } } else @@ -2157,7 +2114,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) ERR("Failed to create a WGL context.\n"); context_release(context); heap_free(context->texture_type); - return FALSE; + return E_FAIL; } if (share_ctx && !wglShareLists(share_ctx, ctx)) @@ -2167,7 +2124,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) if (!wglDeleteContext(ctx)) ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx, GetLastError()); heap_free(context->texture_type); - return FALSE; + return E_FAIL; } } @@ -2187,7 +2144,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) if (!wglDeleteContext(ctx)) ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx, GetLastError()); heap_free(context->texture_type); - return FALSE; + return E_FAIL; } if (context_debug_output_enabled(gl_info)) @@ -2330,7 +2287,42 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) gl_info->gl_ops.gl.p_glScissor(0, 0, 0, 0); checkGLcall("glScissor"); - return TRUE; + return WINED3D_OK; +} + +HRESULT wined3d_context_vk_init(struct wined3d_context *context_vk, struct wined3d_swapchain *swapchain) +{ + TRACE("context_vk %p, swapchain %p.\n", context_vk, swapchain); + + if (!wined3d_context_init(context_vk, swapchain)) + return E_FAIL; + + return WINED3D_OK; +} + +struct wined3d_context *context_create(struct wined3d_swapchain *swapchain) +{ + struct wined3d_device *device = swapchain->device; + struct wined3d_context *context; + HRESULT hr; + + TRACE("swapchain %p.\n", swapchain); + + wined3d_from_cs(device->cs); + + if (FAILED(hr = device->adapter->adapter_ops->adapter_create_context(swapchain, &context))) + return NULL; + + if (!device_context_add(device, context)) + { + ERR("Failed to add the newly created context to the context list.\n"); + device->adapter->adapter_ops->adapter_destroy_context(context); + return NULL; + } + + TRACE("Created context %p.\n", context); + + return context; } void wined3d_context_destroy(struct wined3d_context *context) @@ -2355,7 +2347,7 @@ void wined3d_context_destroy(struct wined3d_context *context) device_context_remove(device, context); - wined3d_context_gl_destroy(wined3d_context_gl(context)); + device->adapter->adapter_ops->adapter_destroy_context(context); } const DWORD *context_get_tex_unit_mapping(const struct wined3d_context *context, diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 7e6ac823e5a..6fc5c7bf8bf 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2255,9 +2255,32 @@ static void adapter_no3d_destroy_device(struct wined3d_device *device) heap_free(device); } -static BOOL wined3d_adapter_no3d_create_context(struct wined3d_context *context) +static HRESULT adapter_no3d_create_context(struct wined3d_swapchain *swapchain, struct wined3d_context **context) { - return TRUE; + struct wined3d_context *context_no3d; + + TRACE("swapchain %p, context %p.\n", swapchain, context); + + if (!(context_no3d = heap_alloc_zero(sizeof(*context_no3d)))) + return E_OUTOFMEMORY; + + if (FAILED(wined3d_context_no3d_init(context_no3d, swapchain))) + { + WARN("Failed to initialise context.\n"); + heap_free(context_no3d); + return E_FAIL; + } + + TRACE("Created context %p.\n", context_no3d); + *context = context_no3d; + + return WINED3D_OK; +} + +static void adapter_no3d_destroy_context(struct wined3d_context *context) +{ + wined3d_context_cleanup(context); + heap_free(context); } static void adapter_no3d_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps) @@ -2296,7 +2319,8 @@ static const struct wined3d_adapter_ops wined3d_adapter_no3d_ops = adapter_no3d_destroy, adapter_no3d_create_device, adapter_no3d_destroy_device, - wined3d_adapter_no3d_create_context, + adapter_no3d_create_context, + adapter_no3d_destroy_context, adapter_no3d_get_wined3d_caps, adapter_no3d_check_format, adapter_no3d_init_3d, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 1eec960c045..3934fba4acd 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2029,6 +2029,11 @@ struct wined3d_context unsigned int scissor_rect_count; }; +void wined3d_context_cleanup(struct wined3d_context *context) DECLSPEC_HIDDEN; + +HRESULT wined3d_context_no3d_init(struct wined3d_context *context_no3d, + struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; + struct wined3d_context_gl { struct wined3d_context c; @@ -2039,12 +2044,19 @@ static inline struct wined3d_context_gl *wined3d_context_gl(struct wined3d_conte return CONTAINING_RECORD(context, struct wined3d_context_gl, c); } +void wined3d_context_gl_cleanup(struct wined3d_context_gl *context_gl) DECLSPEC_HIDDEN; +HRESULT wined3d_context_gl_init(struct wined3d_context_gl *context_gl, + struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; + struct wined3d_fb_state { struct wined3d_rendertarget_view *render_targets[MAX_RENDER_TARGET_VIEWS]; struct wined3d_rendertarget_view *depth_stencil; }; +HRESULT wined3d_context_vk_init(struct wined3d_context *context_vk, + struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; + typedef void (*APPLYSTATEFUNC)(struct wined3d_context *ctx, const struct wined3d_state *state, DWORD state_id); struct wined3d_state_entry @@ -2710,7 +2722,8 @@ struct wined3d_adapter_ops BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, struct wined3d_device_parent *device_parent, struct wined3d_device **device); void (*adapter_destroy_device)(struct wined3d_device *device); - BOOL (*adapter_create_context)(struct wined3d_context *context); + HRESULT (*adapter_create_context)(struct wined3d_swapchain *swapchain, struct wined3d_context **context); + void (*adapter_destroy_context)(struct wined3d_context *context); void (*adapter_get_wined3d_caps)(const struct wined3d_adapter *adapter, struct wined3d_caps *caps); BOOL (*adapter_check_format)(const struct wined3d_adapter *adapter, const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format, @@ -2769,7 +2782,6 @@ static inline const struct wined3d_adapter_gl *wined3d_adapter_gl_const(const st struct wined3d_adapter *wined3d_adapter_gl_create(unsigned int ordinal, unsigned int wined3d_creation_flags) DECLSPEC_HIDDEN; -BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) DECLSPEC_HIDDEN; struct wined3d_adapter_vk { -- 2.11.0

1 0

[PATCH 4/6] wined3d: Determine the ORM_BACKBUFFER depth/stencil format in wined3d_adapter_gl_create_context().
by Henri Verbeet 07 May '19

07 May '19

Instead of in wined3d_swapchain_cs_init(). Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 2 +- dlls/wined3d/context.c | 90 ++++++++++++++++++++++++++++-------------- dlls/wined3d/directx.c | 3 +- dlls/wined3d/swapchain.c | 27 +------------ dlls/wined3d/wined3d_private.h | 8 ++-- 5 files changed, 67 insertions(+), 63 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 7177e384fa2..d6438945361 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -288,7 +288,7 @@ static void adapter_vk_destroy_device(struct wined3d_device *device) heap_free(device_vk); } -static BOOL adapter_vk_create_context(struct wined3d_context *context, const struct wined3d_format *ds_format) +static BOOL adapter_vk_create_context(struct wined3d_context *context) { return TRUE; } diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 0defbcc25a9..fdf7f9ccc65 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1965,7 +1965,7 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d return TRUE; } -struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, const struct wined3d_format *ds_format) +struct wined3d_context *context_create(struct wined3d_swapchain *swapchain) { struct wined3d_device *device = swapchain->device; struct wined3d_context_gl *context_gl; @@ -1984,7 +1984,7 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, cons heap_free(context_gl); return NULL; } - if (!(device->adapter->adapter_ops->adapter_create_context(context, ds_format))) + if (!(device->adapter->adapter_ops->adapter_create_context(context))) { wined3d_release_dc(context->win_handle, context->hdc); heap_free(context_gl); @@ -2003,15 +2003,15 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, cons return context; } -BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, const struct wined3d_format *ds_format) +BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) { + struct wined3d_swapchain *swapchain = context->swapchain; + const struct wined3d_format *color_format, *ds_format; struct wined3d_device *device = context->device; - const struct wined3d_format *color_format; const struct wined3d_d3d_info *d3d_info; const struct wined3d_gl_info *gl_info; struct wined3d_resource *target; unsigned int target_bind_flags; - BOOL aux_buffers = FALSE; HGLRC ctx, share_ctx; unsigned int i; @@ -2057,47 +2057,77 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, const st return FALSE; target = &context->current_rt.texture->resource; - color_format = target->format; target_bind_flags = target->bind_flags; - /* In case of ORM_BACKBUFFER, make sure to request an alpha component for - * X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */ if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) { - aux_buffers = TRUE; + static const enum wined3d_format_id ds_formats[] = + { + WINED3DFMT_D24_UNORM_S8_UINT, + WINED3DFMT_D32_UNORM, + WINED3DFMT_R24_UNORM_X8_TYPELESS, + WINED3DFMT_D16_UNORM, + WINED3DFMT_S1_UINT_D15_UNORM, + }; + + color_format = target->format; + /* In case of ORM_BACKBUFFER, make sure to request an alpha component for + * X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */ if (color_format->id == WINED3DFMT_B4G4R4X4_UNORM) color_format = wined3d_get_format(device->adapter, WINED3DFMT_B4G4R4A4_UNORM, target_bind_flags); else if (color_format->id == WINED3DFMT_B8G8R8X8_UNORM) color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags); - } - /* DirectDraw supports 8bit paletted render targets and these are used by - * old games like StarCraft and C&C. Most modern hardware doesn't support - * 8bit natively so we perform some form of 8bit -> 32bit conversion. The - * conversion (ab)uses the alpha component for storing the palette index. - * For this reason we require a format with 8bit alpha, so request - * A8R8G8B8. */ - if (color_format->id == WINED3DFMT_P8_UINT) - color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags); + /* DirectDraw supports 8bit paletted render targets and these are used by + * old games like StarCraft and C&C. Most modern hardware doesn't support + * 8bit natively so we perform some form of 8bit -> 32bit conversion. The + * conversion (ab)uses the alpha component for storing the palette index. + * For this reason we require a format with 8bit alpha, so request + * A8R8G8B8. */ + if (color_format->id == WINED3DFMT_P8_UINT) + color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags); + + /* Try to find a pixel format which matches our requirements. */ + if (!swapchain->ds_format) + { + for (i = 0; i < ARRAY_SIZE(ds_formats); ++i) + { + ds_format = wined3d_get_format(device->adapter, ds_formats[i], WINED3D_BIND_DEPTH_STENCIL); + if ((context->pixel_format = context_choose_pixel_format(device, + context->hdc, color_format, ds_format, TRUE))) + { + swapchain->ds_format = ds_format; + break; + } - /* When using FBOs for off-screen rendering, we only use the drawable for - * presentation blits, and don't do any rendering to it. That means we - * don't need depth or stencil buffers, and can mostly ignore the render - * target format. This wouldn't necessarily be quite correct for 10bpc - * display modes, but we don't currently support those. - * Using the same format regardless of the color/depth/stencil targets - * makes it much less likely that different wined3d instances will set - * conflicting pixel formats. */ - if (wined3d_settings.offscreen_rendering_mode != ORM_BACKBUFFER) + TRACE("Depth stencil format %s is not supported, trying next format.\n", + debug_d3dformat(ds_format->id)); + } + } + else + { + context->pixel_format = context_choose_pixel_format(device, + context->hdc, color_format, swapchain->ds_format, TRUE); + } + } + else { + /* When using FBOs for off-screen rendering, we only use the drawable for + * presentation blits, and don't do any rendering to it. That means we + * don't need depth or stencil buffers, and can mostly ignore the render + * target format. This wouldn't necessarily be quite correct for 10bpc + * display modes, but we don't currently support those. + * Using the same format regardless of the color/depth/stencil targets + * makes it much less likely that different wined3d instances will set + * conflicting pixel formats. */ color_format = wined3d_get_format(device->adapter, WINED3DFMT_B8G8R8A8_UNORM, target_bind_flags); ds_format = wined3d_get_format(device->adapter, WINED3DFMT_UNKNOWN, WINED3D_BIND_DEPTH_STENCIL); + context->pixel_format = context_choose_pixel_format(device, + context->hdc, color_format, ds_format, FALSE); } - /* Try to find a pixel format which matches our requirements. */ - if (!(context->pixel_format = context_choose_pixel_format(device, - context->hdc, color_format, ds_format, aux_buffers))) + if (!context->pixel_format) return FALSE; context_enter(context); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index d4aefadc29e..7e6ac823e5a 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2255,8 +2255,7 @@ static void adapter_no3d_destroy_device(struct wined3d_device *device) heap_free(device); } -static BOOL wined3d_adapter_no3d_create_context(struct wined3d_context *context, - const struct wined3d_format *ds_format) +static BOOL wined3d_adapter_no3d_create_context(struct wined3d_context *context) { return TRUE; } diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index 7210682c45f..f47c1a44297 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -720,31 +720,8 @@ static void wined3d_swapchain_apply_sample_count_override(const struct wined3d_s static void wined3d_swapchain_cs_init(void *object) { struct wined3d_swapchain *swapchain = object; - const struct wined3d_adapter *adapter; - unsigned int i; - - static const enum wined3d_format_id formats[] = - { - WINED3DFMT_D24_UNORM_S8_UINT, - WINED3DFMT_D32_UNORM, - WINED3DFMT_R24_UNORM_X8_TYPELESS, - WINED3DFMT_D16_UNORM, - WINED3DFMT_S1_UINT_D15_UNORM, - }; - - adapter = swapchain->device->adapter; - - /* Without ORM_FBO, switching the depth/stencil format is hard. Always - * request a depth/stencil buffer in the likely case it's needed later. */ - for (i = 0; i < ARRAY_SIZE(formats); ++i) - { - swapchain->ds_format = wined3d_get_format(adapter, formats[i], WINED3D_BIND_DEPTH_STENCIL); - if ((swapchain->context[0] = context_create(swapchain, swapchain->ds_format))) - break; - TRACE("Depth stencil format %s is not supported, trying next format.\n", debug_d3dformat(formats[i])); - } - if (!swapchain->context[0]) + if (!(swapchain->context[0] = context_create(swapchain))) { WARN("Failed to create context.\n"); return; @@ -1085,7 +1062,7 @@ static struct wined3d_context *swapchain_create_context(struct wined3d_swapchain TRACE("Creating a new context for swapchain %p, thread %u.\n", swapchain, GetCurrentThreadId()); - if (!(ctx = context_create(swapchain, swapchain->ds_format))) + if (!(ctx = context_create(swapchain))) { ERR("Failed to create a new context for the swapchain\n"); return NULL; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index ddd5b8d0951..1eec960c045 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2196,8 +2196,7 @@ void context_check_fbo_status(const struct wined3d_context *context, GLenum targ void context_copy_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *dst, GLenum dst_binding, const struct wined3d_bo_address *src, GLenum src_binding, size_t size) DECLSPEC_HIDDEN; -struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, - const struct wined3d_format *ds_format) DECLSPEC_HIDDEN; +struct wined3d_context *context_create(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN; HGLRC context_create_wgl_attribs(const struct wined3d_gl_info *gl_info, HDC hdc, HGLRC share_ctx) DECLSPEC_HIDDEN; void wined3d_context_destroy(struct wined3d_context *context) DECLSPEC_HIDDEN; void context_draw_shaded_quad(struct wined3d_context *context, struct wined3d_texture_gl *texture_gl, @@ -2711,7 +2710,7 @@ struct wined3d_adapter_ops BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, struct wined3d_device_parent *device_parent, struct wined3d_device **device); void (*adapter_destroy_device)(struct wined3d_device *device); - BOOL (*adapter_create_context)(struct wined3d_context *context, const struct wined3d_format *ds_format); + BOOL (*adapter_create_context)(struct wined3d_context *context); void (*adapter_get_wined3d_caps)(const struct wined3d_adapter *adapter, struct wined3d_caps *caps); BOOL (*adapter_check_format)(const struct wined3d_adapter *adapter, const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format, @@ -2770,8 +2769,7 @@ static inline const struct wined3d_adapter_gl *wined3d_adapter_gl_const(const st struct wined3d_adapter *wined3d_adapter_gl_create(unsigned int ordinal, unsigned int wined3d_creation_flags) DECLSPEC_HIDDEN; -BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, - const struct wined3d_format *ds_format) DECLSPEC_HIDDEN; +BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context) DECLSPEC_HIDDEN; struct wined3d_adapter_vk { -- 2.11.0

1 0

[PATCH 3/6] wined3d: Make the adapter responsible for initialising and de-initialising 3D.
by Henri Verbeet 07 May '19

07 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 34 ++++++++++++++++++++++---- dlls/wined3d/adapter_vk.c | 14 +++++++++++ dlls/wined3d/device.c | 54 +++++++----------------------------------- dlls/wined3d/directx.c | 22 +++++++++++++++++ dlls/wined3d/wined3d_private.h | 4 ++++ 5 files changed, 77 insertions(+), 51 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index cedd012c89d..972d051a6b2 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4233,6 +4233,15 @@ static void wined3d_adapter_init_fb_cfgs(struct wined3d_adapter_gl *adapter_gl, } } +static void adapter_gl_destroy(struct wined3d_adapter *adapter) +{ + struct wined3d_adapter_gl *adapter_gl = wined3d_adapter_gl(adapter); + + heap_free(adapter_gl->pixel_formats); + wined3d_adapter_cleanup(adapter); + heap_free(adapter_gl); +} + static HRESULT adapter_gl_create_device(struct wined3d *wined3d, const struct wined3d_adapter *adapter, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, @@ -4522,13 +4531,26 @@ static BOOL adapter_gl_check_format(const struct wined3d_adapter *adapter, return FALSE; } -static void adapter_gl_destroy(struct wined3d_adapter *adapter) +static HRESULT adapter_gl_init_3d(struct wined3d_device *device) { - struct wined3d_adapter_gl *adapter_gl = wined3d_adapter_gl(adapter); + TRACE("device %p.\n", device); - heap_free(adapter_gl->pixel_formats); - wined3d_adapter_cleanup(adapter); - heap_free(adapter_gl); + wined3d_cs_init_object(device->cs, wined3d_device_create_primary_opengl_context_cs, device); + wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT); + if (!device->swapchains[0]->num_contexts) + return E_FAIL; + + device->d3d_initialized = TRUE; + + return WINED3D_OK; +} + +static void adapter_gl_uninit_3d(struct wined3d_device *device) +{ + TRACE("device %p.\n", device); + + wined3d_cs_destroy_object(device->cs, wined3d_device_delete_opengl_contexts_cs, device); + wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT); } static const struct wined3d_adapter_ops wined3d_adapter_gl_ops = @@ -4539,6 +4561,8 @@ static const struct wined3d_adapter_ops wined3d_adapter_gl_ops = wined3d_adapter_gl_create_context, adapter_gl_get_wined3d_caps, adapter_gl_check_format, + adapter_gl_init_3d, + adapter_gl_uninit_3d, }; static BOOL wined3d_adapter_gl_init(struct wined3d_adapter_gl *adapter_gl, diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index da53edd953a..7177e384fa2 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -398,6 +398,18 @@ static BOOL adapter_vk_check_format(const struct wined3d_adapter *adapter, return TRUE; } +static HRESULT adapter_vk_init_3d(struct wined3d_device *device) +{ + TRACE("device %p.\n", device); + + return WINED3D_OK; +} + +static void adapter_vk_uninit_3d(struct wined3d_device *device) +{ + TRACE("device %p.\n", device); +} + static const struct wined3d_adapter_ops wined3d_adapter_vk_ops = { adapter_vk_destroy, @@ -406,6 +418,8 @@ static const struct wined3d_adapter_ops wined3d_adapter_vk_ops = adapter_vk_create_context, adapter_vk_get_wined3d_caps, adapter_vk_check_format, + adapter_vk_init_3d, + adapter_vk_uninit_3d, }; static unsigned int wined3d_get_wine_vk_version(void) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index dcf05f054f5..eac6442804f 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1009,7 +1009,7 @@ static void device_init_swapchain_state(struct wined3d_device *device, struct wi wined3d_device_set_depth_stencil_view(device, ds_enable ? device->auto_depth_stencil_view : NULL); } -static void wined3d_device_delete_opengl_contexts_cs(void *object) +void wined3d_device_delete_opengl_contexts_cs(void *object) { struct wined3d_resource *resource, *cursor; struct wined3d_device *device = object; @@ -1043,13 +1043,7 @@ static void wined3d_device_delete_opengl_contexts_cs(void *object) } } -static void wined3d_device_delete_opengl_contexts(struct wined3d_device *device) -{ - wined3d_cs_destroy_object(device->cs, wined3d_device_delete_opengl_contexts_cs, device); - wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT); -} - -static void wined3d_device_create_primary_opengl_context_cs(void *object) +void wined3d_device_create_primary_opengl_context_cs(void *object) { struct wined3d_device *device = object; struct wined3d_swapchain *swapchain; @@ -1084,16 +1078,6 @@ static void wined3d_device_create_primary_opengl_context_cs(void *object) context_release(context); } -static HRESULT wined3d_device_create_primary_opengl_context(struct wined3d_device *device) -{ - wined3d_cs_init_object(device->cs, wined3d_device_create_primary_opengl_context_cs, device); - wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT); - if (!device->swapchains[0]->num_contexts) - return E_FAIL; - - return WINED3D_OK; -} - HRESULT wined3d_device_set_implicit_swapchain(struct wined3d_device *device, struct wined3d_swapchain *swapchain) { static const struct wined3d_color black = {0.0f, 0.0f, 0.0f, 0.0f}; @@ -1136,24 +1120,8 @@ HRESULT wined3d_device_set_implicit_swapchain(struct wined3d_device *device, str device->swapchains[0] = swapchain; memset(device->fb.render_targets, 0, sizeof(device->fb.render_targets)); - if (device->wined3d->flags & WINED3D_NO3D) - { - if (!(device->blitter = wined3d_cpu_blitter_create())) - { - ERR("Failed to create CPU blitter.\n"); - heap_free(device->swapchains); - device->swapchain_count = 0; - hr = E_FAIL; - goto err_out; - } - } - else - { - if (FAILED(hr = wined3d_device_create_primary_opengl_context(device))) - goto err_out; - - device->d3d_initialized = TRUE; - } + if (FAILED(hr = device->adapter->adapter_ops->adapter_init_3d(device))) + goto err_out; device_init_swapchain_state(device, swapchain); @@ -1231,10 +1199,7 @@ void wined3d_device_uninit_3d(struct wined3d_device *device) wine_rb_clear(&device->samplers, device_free_sampler, NULL); - if (no3d) - device->blitter->ops->blitter_destroy(device->blitter, NULL); - else - wined3d_device_delete_opengl_contexts(device); + device->adapter->adapter_ops->adapter_uninit_3d(device); if ((view = device->fb.depth_stencil)) { @@ -5066,7 +5031,7 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device, state_cleanup(&device->state); if (device->d3d_initialized) - wined3d_device_delete_opengl_contexts(device); + device->adapter->adapter_ops->adapter_uninit_3d(device); memset(&device->state, 0, sizeof(device->state)); state_init(&device->state, &device->fb, &device->adapter->d3d_info, WINED3D_STATE_INIT_DEFAULT); @@ -5097,11 +5062,8 @@ HRESULT CDECL wined3d_device_reset(struct wined3d_device *device, wined3d_cs_emit_set_scissor_rects(device->cs, 1, state->scissor_rects); } - if (device->d3d_initialized) - { - if (reset_state) - hr = wined3d_device_create_primary_opengl_context(device); - } + if (device->d3d_initialized && reset_state) + hr = device->adapter->adapter_ops->adapter_init_3d(device); /* All done. There is no need to reload resources or shaders, this will happen automatically on the * first use diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index c909e5185a1..d4aefadc29e 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2272,6 +2272,26 @@ static BOOL adapter_no3d_check_format(const struct wined3d_adapter *adapter, return TRUE; } +static HRESULT adapter_no3d_init_3d(struct wined3d_device *device) +{ + TRACE("device %p.\n", device); + + if (!(device->blitter = wined3d_cpu_blitter_create())) + { + ERR("Failed to create CPU blitter.\n"); + return E_FAIL; + } + + return WINED3D_OK; +} + +static void adapter_no3d_uninit_3d(struct wined3d_device *device) +{ + TRACE("device %p.\n", device); + + device->blitter->ops->blitter_destroy(device->blitter, NULL); +} + static const struct wined3d_adapter_ops wined3d_adapter_no3d_ops = { adapter_no3d_destroy, @@ -2280,6 +2300,8 @@ static const struct wined3d_adapter_ops wined3d_adapter_no3d_ops = wined3d_adapter_no3d_create_context, adapter_no3d_get_wined3d_caps, adapter_no3d_check_format, + adapter_no3d_init_3d, + adapter_no3d_uninit_3d, }; static void wined3d_adapter_no3d_init_d3d_info(struct wined3d_adapter *adapter, unsigned int wined3d_creation_flags) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fbcda94537e..ddd5b8d0951 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2716,6 +2716,8 @@ struct wined3d_adapter_ops BOOL (*adapter_check_format)(const struct wined3d_adapter *adapter, const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format, const struct wined3d_format *ds_format); + HRESULT (*adapter_init_3d)(struct wined3d_device *device); + void (*adapter_uninit_3d)(struct wined3d_device *device); }; /* The adapter structure */ @@ -3190,6 +3192,8 @@ void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, c const struct wined3d_color *color, float depth, DWORD stencil) DECLSPEC_HIDDEN; BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN; void device_context_remove(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN; +void wined3d_device_create_primary_opengl_context_cs(void *object) DECLSPEC_HIDDEN; +void wined3d_device_delete_opengl_contexts_cs(void *object) DECLSPEC_HIDDEN; HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined3d, unsigned int adapter_idx, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, -- 2.11.0

1 0

[PATCH 2/6] wined3d: Share more swapchain setup with the "no3d" adapter in wined3d_device_set_implicit_swapchain().
by Henri Verbeet 07 May '19

07 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/device.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index b2dbb403932..dcf05f054f5 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1151,23 +1151,24 @@ HRESULT wined3d_device_set_implicit_swapchain(struct wined3d_device *device, str { if (FAILED(hr = wined3d_device_create_primary_opengl_context(device))) goto err_out; - device_init_swapchain_state(device, swapchain); - TRACE("All defaults now set up.\n"); + device->d3d_initialized = TRUE; + } - /* Clear the screen */ - if (device->back_buffer_view) - clear_flags |= WINED3DCLEAR_TARGET; - if (swapchain_desc->enable_auto_depth_stencil) - clear_flags |= WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL; - if (clear_flags) - wined3d_device_clear(device, 0, NULL, clear_flags, &black, 1.0f, 0); + device_init_swapchain_state(device, swapchain); - device->d3d_initialized = TRUE; + TRACE("All defaults now set up.\n"); - if (wined3d_settings.logo) - device_load_logo(device, wined3d_settings.logo); - } + /* Clear the screen. */ + if (device->back_buffer_view) + clear_flags |= WINED3DCLEAR_TARGET; + if (swapchain_desc->enable_auto_depth_stencil) + clear_flags |= WINED3DCLEAR_ZBUFFER | WINED3DCLEAR_STENCIL; + if (clear_flags) + wined3d_device_clear(device, 0, NULL, clear_flags, &black, 1.0f, 0); + + if (wined3d_settings.logo) + device_load_logo(device, wined3d_settings.logo); return WINED3D_OK; -- 2.11.0

1 0

[PATCH 1/6] wined3d: Get rid of a redundant initialisation in wined3d_device_set_implicit_swapchain().
by Henri Verbeet 07 May '19

07 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/device.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index a27251c86e3..b2dbb403932 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -1153,8 +1153,6 @@ HRESULT wined3d_device_set_implicit_swapchain(struct wined3d_device *device, str goto err_out; device_init_swapchain_state(device, swapchain); - device->contexts[0]->last_was_rhw = 0; - TRACE("All defaults now set up.\n"); /* Clear the screen */ -- 2.11.0

1 0

[PATCH 4/4] d3d11: Report format support more accurately based on feature level.
by Józef Kucia 07 May '19

07 May '19

Our partial stub for CheckFormatSupport() is still quite inaccurate. For example, we might report SHADER_SAMPLE support for UINT formats. In the long term, wined3d should probably return the format support flags directly. Unfortunately, the current wined3d interface shared with d3d9 isn't well suited for returning fine-grained format support flags. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d10core/tests/d3d10core.c | 20 ++++++++++++++++-- dlls/d3d11/device.c | 13 +++++++++--- dlls/d3d11/tests/d3d11.c | 35 ++++++++++++++++++++++++++++++-- 3 files changed, 61 insertions(+), 7 deletions(-) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index 32f943704af8..ecf1f3814726 100644 --- a/dlls/d3d10core/tests/d3d10core.c +++ b/dlls/d3d10core/tests/d3d10core.c @@ -13390,7 +13390,7 @@ static void check_format_support(const unsigned int *format_support, } } -static void test_required_format_support(void) +static void test_format_support(void) { unsigned int format_support[DXGI_FORMAT_B4G4R4A4_UNORM + 1]; ID3D10Device *device; @@ -13425,6 +13425,22 @@ static void test_required_format_support(void) format, hr, format_support[format]); } + for (format = DXGI_FORMAT_UNKNOWN; format <= DXGI_FORMAT_B4G4R4A4_UNORM; ++format) + { + ok(!(format_support[format] & D3D10_FORMAT_SUPPORT_SHADER_GATHER), + "Unexpected SHADER_GATHER for format %#x.\n", format); + ok(!(format_support[format] & D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON), + "Unexpected SHADER_GATHER_COMPARISON for format %#x.\n", format); + } + + ok(format_support[DXGI_FORMAT_R8G8B8A8_UNORM] & D3D10_FORMAT_SUPPORT_SHADER_SAMPLE, + "SHADER_SAMPLE is not supported for R8G8B8A8_UNORM.\n"); + todo_wine + ok(!(format_support[DXGI_FORMAT_R32G32B32A32_UINT] & D3D10_FORMAT_SUPPORT_SHADER_SAMPLE), + "SHADER_SAMPLE is supported for R32G32B32A32_UINT.\n"); + ok(format_support[DXGI_FORMAT_R32G32B32A32_UINT] & D3D10_FORMAT_SUPPORT_SHADER_LOAD, + "SHADER_LOAD is not supported for R32G32B32A32_UINT.\n"); + check_format_support(format_support, index_buffers, ARRAY_SIZE(index_buffers), D3D10_FORMAT_SUPPORT_IA_INDEX_BUFFER, "index buffer"); @@ -18057,7 +18073,7 @@ START_TEST(d3d10core) queue_test(test_index_buffer_offset); queue_test(test_face_culling); queue_test(test_line_antialiasing_blending); - queue_test(test_required_format_support); + queue_test(test_format_support); queue_test(test_ddy); queue_test(test_shader_input_registers_limits); queue_test(test_unbind_shader_resource_view); diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index 751afc132112..31292e9ddff8 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -3378,6 +3378,7 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device2 * struct d3d_device *device = impl_from_ID3D11Device2(iface); struct wined3d_device_creation_parameters params; enum wined3d_format_id wined3d_format; + D3D_FEATURE_LEVEL feature_level; struct wined3d *wined3d; unsigned int i; @@ -3410,6 +3411,7 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device2 * *format_support = 0; wined3d_mutex_lock(); + feature_level = device->feature_level; wined3d = wined3d_device_get_wined3d(device->wined3d_device); wined3d_device_get_creation_parameters(device->wined3d_device, &params); for (i = 0; i < ARRAY_SIZE(flag_mapping); ++i) @@ -3434,12 +3436,17 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device2 * { *format_support |= D3D11_FORMAT_SUPPORT_SHADER_LOAD; *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE; - *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER; + + if (feature_level >= D3D_FEATURE_LEVEL_10_1) + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER; if (*format_support & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL) { - *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON; - *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON; + if (feature_level >= D3D_FEATURE_LEVEL_10_0) + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON; + + if (feature_level >= D3D_FEATURE_LEVEL_10_1) + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON; } } diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 5b56a04c54bb..e8c2f649f80b 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -18425,7 +18425,7 @@ static void check_format_support(const unsigned int *format_support, D3D_FEATURE } } -static void test_required_format_support(const D3D_FEATURE_LEVEL feature_level) +static void test_format_support(const D3D_FEATURE_LEVEL feature_level) { unsigned int format_support[DXGI_FORMAT_B4G4R4A4_UNORM + 1]; struct device_desc device_desc; @@ -18463,6 +18463,37 @@ static void test_required_format_support(const D3D_FEATURE_LEVEL feature_level) format, hr, format_support[format]); } + for (format = DXGI_FORMAT_UNKNOWN; format <= DXGI_FORMAT_B4G4R4A4_UNORM; ++format) + { + if (feature_level < D3D_FEATURE_LEVEL_10_0) + { + /* SHADER_SAMPLE_COMPARISON is never advertised as supported on feature level 9. */ + ok(!(format_support[format] & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON), + "Unexpected SHADER_SAMPLE_COMPARISON for format %#x, feature level %#x.\n", + format, feature_level); + } + if (feature_level < D3D_FEATURE_LEVEL_10_1) + { + ok(!(format_support[format] & D3D11_FORMAT_SUPPORT_SHADER_GATHER), + "Unexpected SHADER_GATHER for format %#x, feature level %#x.\n", + format, feature_level); + ok(!(format_support[format] & D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON), + "Unexpected SHADER_GATHER_COMPARISON for format %#x, feature level %#x.\n", + format, feature_level); + } + } + + ok(format_support[DXGI_FORMAT_R8G8B8A8_UNORM] & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE, + "SHADER_SAMPLE is not supported for R8G8B8A8_UNORM.\n"); + todo_wine + ok(!(format_support[DXGI_FORMAT_R32G32B32A32_UINT] & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE), + "SHADER_SAMPLE is supported for R32G32B32A32_UINT.\n"); + if (feature_level >= D3D_FEATURE_LEVEL_10_0) + { + ok(format_support[DXGI_FORMAT_R32G32B32A32_UINT] & D3D11_FORMAT_SUPPORT_SHADER_LOAD, + "SHADER_LOAD is not supported for R32G32B32A32_UINT.\n"); + } + check_format_support(format_support, feature_level, index_buffers, ARRAY_SIZE(index_buffers), D3D11_FORMAT_SUPPORT_IA_INDEX_BUFFER, "index buffer"); @@ -29365,7 +29396,7 @@ START_TEST(d3d11) queue_test(test_index_buffer_offset); queue_test(test_face_culling); queue_test(test_line_antialiasing_blending); - queue_for_each_feature_level(test_required_format_support); + queue_for_each_feature_level(test_format_support); queue_for_each_9_x_feature_level(test_fl9_draw); queue_test(test_ddy); queue_test(test_shader_input_registers_limits); -- 2.21.0

3 2

[PATCH 3/4] wined3d: Store texture swizzle capability in struct wined3d_d3d_info.
by Józef Kucia 07 May '19

07 May '19

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 1 + dlls/wined3d/adapter_vk.c | 1 + dlls/wined3d/cs.c | 3 +-- dlls/wined3d/shader.c | 2 +- dlls/wined3d/texture.c | 2 +- dlls/wined3d/utils.c | 2 +- dlls/wined3d/view.c | 2 +- dlls/wined3d/wined3d_private.h | 6 +++--- 8 files changed, 10 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 866cfecbe1f2..1555ba4aaa38 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -3729,6 +3729,7 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, d3d_info->draw_base_vertex_offset = !!gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX]; d3d_info->vertex_bgra = !!gl_info->supported[ARB_VERTEX_ARRAY_BGRA]; + d3d_info->texture_swizzle = !!gl_info->supported[ARB_TEXTURE_SWIZZLE]; if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE]) d3d_info->multisample_draw_location = WINED3D_LOCATION_TEXTURE_RGB; diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 0d5e2f59348c..87a111274fe4 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -729,6 +729,7 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, adapter->shader_backend = &none_shader_backend; adapter->d3d_info.wined3d_creation_flags = wined3d_creation_flags; + adapter->d3d_info.texture_swizzle = TRUE; return TRUE; diff --git a/dlls/wined3d/cs.c b/dlls/wined3d/cs.c index 9960d06cea72..b2a2b1ad4ffd 100644 --- a/dlls/wined3d/cs.c +++ b/dlls/wined3d/cs.c @@ -1348,7 +1348,6 @@ void wined3d_cs_emit_set_constant_buffer(struct wined3d_cs *cs, enum wined3d_sha static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data) { - const struct wined3d_gl_info *gl_info = &cs->device->adapter->gl_info; const struct wined3d_d3d_info *d3d_info = &cs->device->adapter->d3d_info; const struct wined3d_cs_set_texture *op = data; struct wined3d_texture *prev; @@ -1369,7 +1368,7 @@ static void wined3d_cs_exec_set_texture(struct wined3d_cs *cs, const void *data) if (!prev || wined3d_texture_gl(op->texture)->target != wined3d_texture_gl(prev)->target || (!is_same_fixup(new_format->color_fixup, old_format->color_fixup) - && !(can_use_texture_swizzle(gl_info, new_format) && can_use_texture_swizzle(gl_info, old_format))) + && !(can_use_texture_swizzle(d3d_info, new_format) && can_use_texture_swizzle(d3d_info, old_format))) || (new_fmt_flags & WINED3DFMT_FLAG_SHADOW) != (old_fmt_flags & WINED3DFMT_FLAG_SHADOW)) device_invalidate_state(cs->device, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL)); diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 7ebfd4dee16b..609b574d461c 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -4025,7 +4025,7 @@ void find_ps_compile_args(const struct wined3d_state *state, const struct wined3 args->color_fixup[i] = COLOR_FIXUP_IDENTITY; continue; } - if (can_use_texture_swizzle(gl_info, texture->resource.format)) + if (can_use_texture_swizzle(d3d_info, texture->resource.format)) args->color_fixup[i] = COLOR_FIXUP_IDENTITY; else args->color_fixup[i] = texture->resource.format->color_fixup; diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index 949492063d2c..664f8a902053 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -1037,7 +1037,7 @@ void wined3d_texture_gl_bind(struct wined3d_texture_gl *texture_gl, checkGLcall("glTexParameteri(GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY)"); } - if (!is_identity_fixup(fixup) && can_use_texture_swizzle(gl_info, format)) + if (!is_identity_fixup(fixup) && can_use_texture_swizzle(context->d3d_info, format)) { GLint swizzle[4]; diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index e54eec241ea4..2ec3546125bb 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -5988,7 +5988,7 @@ void gen_ffp_frag_op(const struct wined3d_context *context, const struct wined3d if ((texture = state->textures[i])) { - if (can_use_texture_swizzle(gl_info, texture->resource.format)) + if (can_use_texture_swizzle(d3d_info, texture->resource.format)) settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY; else settings->op[i].color_fixup = texture->resource.format->color_fixup; diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index 0cfadf7329b9..ec9df71380cd 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -226,7 +226,7 @@ static void create_texture_view(struct wined3d_gl_view *view, GLenum view_target context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING); context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING); } - else if (!is_identity_fixup(view_format->color_fixup) && can_use_texture_swizzle(gl_info, view_format)) + else if (!is_identity_fixup(view_format->color_fixup) && can_use_texture_swizzle(context->d3d_info, view_format)) { GLint swizzle[4]; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 221ca6e04f46..875c33bd0b40 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -209,6 +209,7 @@ struct wined3d_d3d_info unsigned int texture_npot_conditional : 1; unsigned int draw_base_vertex_offset : 1; unsigned int vertex_bgra : 1; + unsigned int texture_swizzle : 1; enum wined3d_feature_level feature_level; DWORD multisample_draw_location; @@ -4739,10 +4740,9 @@ static inline GLuint wined3d_texture_gl_get_texture_name(const struct wined3d_te ? texture_gl->texture_srgb.name : texture_gl->texture_rgb.name; } -static inline BOOL can_use_texture_swizzle(const struct wined3d_gl_info *gl_info, const struct wined3d_format *format) +static inline BOOL can_use_texture_swizzle(const struct wined3d_d3d_info *d3d_info, const struct wined3d_format *format) { - return gl_info->supported[ARB_TEXTURE_SWIZZLE] && !is_complex_fixup(format->color_fixup) - && !is_scaling_fixup(format->color_fixup); + return d3d_info->texture_swizzle && !is_complex_fixup(format->color_fixup) && !is_scaling_fixup(format->color_fixup); } static inline BOOL needs_interpolation_qualifiers_for_shader_outputs(const struct wined3d_gl_info *gl_info) -- 2.21.0

2 1

[PATCH 2/4] wined3d: Query Vulkan shared system memory.
by Józef Kucia 07 May '19

07 May '19

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 2 +- dlls/wined3d/adapter_vk.c | 9 ++++++--- dlls/wined3d/directx.c | 19 +++++++++++-------- dlls/wined3d/wined3d_private.h | 3 ++- 4 files changed, 20 insertions(+), 13 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index cedd012c89d1..866cfecbe1f2 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -3855,7 +3855,7 @@ static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, } fixup_extensions(gl_info, caps_gl_ctx, gl_renderer_str, gl_vendor, gpu_description->vendor, gpu_description->device); - wined3d_driver_info_init(driver_info, gpu_description, vram_bytes); + wined3d_driver_info_init(driver_info, gpu_description, vram_bytes, 0); TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n", driver_info->version_high, driver_info->version_low); diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 8fd9adf31909..0d5e2f59348c 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -635,8 +635,8 @@ static void adapter_vk_init_driver_info(struct wined3d_adapter *adapter, { const struct wined3d_gpu_description *gpu_description; struct wined3d_gpu_description description; + UINT64 vram_bytes, sysmem_bytes; const VkMemoryHeap *heap; - UINT64 vram_bytes; unsigned int i; TRACE("Device name: %s.\n", debugstr_a(properties->deviceName)); @@ -644,15 +644,18 @@ static void adapter_vk_init_driver_info(struct wined3d_adapter *adapter, TRACE("Driver version: %#x.\n", properties->driverVersion); TRACE("API version: %s.\n", debug_vk_version(properties->apiVersion)); - for (i = 0, vram_bytes = 0; i < memory_properties->memoryHeapCount; ++i) + for (i = 0, vram_bytes = 0, sysmem_bytes = 0; i < memory_properties->memoryHeapCount; ++i) { heap = &memory_properties->memoryHeaps[i]; TRACE("Memory heap [%u]: flags %#x, size 0x%s.\n", i, heap->flags, wine_dbgstr_longlong(heap->size)); if (heap->flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) vram_bytes += heap->size; + else + sysmem_bytes += heap->size; } TRACE("Total device memory: 0x%s.\n", wine_dbgstr_longlong(vram_bytes)); + TRACE("Total shared system memory: 0x%s.\n", wine_dbgstr_longlong(sysmem_bytes)); if (!(gpu_description = wined3d_get_user_override_gpu_description(properties->vendorID, properties->deviceID))) gpu_description = wined3d_get_gpu_description(properties->vendorID, properties->deviceID); @@ -671,7 +674,7 @@ static void adapter_vk_init_driver_info(struct wined3d_adapter *adapter, gpu_description = &description; } - wined3d_driver_info_init(&adapter->driver_info, gpu_description, vram_bytes); + wined3d_driver_info_init(&adapter->driver_info, gpu_description, vram_bytes, sysmem_bytes); } static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index c909e5185a1d..be7e8182ec2a 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -541,7 +541,7 @@ static void wined3d_copy_name(char *dst, const char *src, unsigned int dst_size) } void wined3d_driver_info_init(struct wined3d_driver_info *driver_info, - const struct wined3d_gpu_description *gpu_desc, UINT64 vram_bytes) + const struct wined3d_gpu_description *gpu_desc, UINT64 vram_bytes, UINT64 sysmem_bytes) { const struct driver_version_information *version_info; enum wined3d_driver_model driver_model; @@ -637,12 +637,15 @@ void wined3d_driver_info_init(struct wined3d_driver_info *driver_info, driver_info->vram_bytes = LONG_MAX; } - driver_info->sysmem_bytes = 64 * 1024 * 1024; - memory_status.dwLength = sizeof(memory_status); - if (GlobalMemoryStatusEx(&memory_status)) - driver_info->sysmem_bytes = max(memory_status.ullTotalPhys / 2, driver_info->sysmem_bytes); - else - ERR("Failed to get global memory status.\n"); + if (!(driver_info->sysmem_bytes = sysmem_bytes)) + { + driver_info->sysmem_bytes = 64 * 1024 * 1024; + memory_status.dwLength = sizeof(memory_status); + if (GlobalMemoryStatusEx(&memory_status)) + driver_info->sysmem_bytes = max(memory_status.ullTotalPhys / 2, driver_info->sysmem_bytes); + else + ERR("Failed to get global memory status.\n"); + } /* Try to obtain driver version information for the current Windows version. This fails in * some cases: @@ -2305,7 +2308,7 @@ static struct wined3d_adapter *wined3d_adapter_no3d_create(unsigned int ordinal, if (!(adapter = heap_alloc_zero(sizeof(*adapter)))) return NULL; - wined3d_driver_info_init(&adapter->driver_info, &gpu_description, 0); + wined3d_driver_info_init(&adapter->driver_info, &gpu_description, 0, 0); adapter->vram_bytes_used = 0; TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->driver_info.vram_bytes)); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fbcda94537e6..221ca6e04f46 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2701,7 +2701,8 @@ struct wined3d_driver_info }; void wined3d_driver_info_init(struct wined3d_driver_info *driver_info, - const struct wined3d_gpu_description *gpu_description, UINT64 vram_bytes) DECLSPEC_HIDDEN; + const struct wined3d_gpu_description *gpu_description, + UINT64 vram_bytes, UINT64 sysmem_bytes) DECLSPEC_HIDDEN; struct wined3d_adapter_ops { -- 2.21.0

2 1

[PATCH 1/4] wined3d: Query Vulkan GPU memory.
by Józef Kucia 07 May '19

07 May '19

From: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- [rebased and sligtly modified] --- dlls/wined3d/adapter_vk.c | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index da53edd953a6..8fd9adf31909 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -631,20 +631,32 @@ static enum wined3d_display_driver guess_display_driver(enum wined3d_pci_vendor } static void adapter_vk_init_driver_info(struct wined3d_adapter *adapter, - const VkPhysicalDeviceProperties *properties) + const VkPhysicalDeviceProperties *properties, const VkPhysicalDeviceMemoryProperties *memory_properties) { const struct wined3d_gpu_description *gpu_description; struct wined3d_gpu_description description; + const VkMemoryHeap *heap; + UINT64 vram_bytes; + unsigned int i; TRACE("Device name: %s.\n", debugstr_a(properties->deviceName)); TRACE("Vendor ID: 0x%04x, Device ID: 0x%04x.\n", properties->vendorID, properties->deviceID); TRACE("Driver version: %#x.\n", properties->driverVersion); TRACE("API version: %s.\n", debug_vk_version(properties->apiVersion)); + for (i = 0, vram_bytes = 0; i < memory_properties->memoryHeapCount; ++i) + { + heap = &memory_properties->memoryHeaps[i]; + TRACE("Memory heap [%u]: flags %#x, size 0x%s.\n", + i, heap->flags, wine_dbgstr_longlong(heap->size)); + if (heap->flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) + vram_bytes += heap->size; + } + TRACE("Total device memory: 0x%s.\n", wine_dbgstr_longlong(vram_bytes)); + if (!(gpu_description = wined3d_get_user_override_gpu_description(properties->vendorID, properties->deviceID))) gpu_description = wined3d_get_gpu_description(properties->vendorID, properties->deviceID); - /* FIXME: Get vidmem from Vulkan. */ if (!gpu_description) { FIXME("Failed to retrieve GPU description for device %s %04x:%04x.\n", @@ -654,18 +666,19 @@ static void adapter_vk_init_driver_info(struct wined3d_adapter *adapter, description.device = properties->deviceID; description.description = properties->deviceName; description.driver = guess_display_driver(properties->vendorID); - description.vidmem = 0; + description.vidmem = vram_bytes; gpu_description = &description; } - wined3d_driver_info_init(&adapter->driver_info, gpu_description, wined3d_settings.emulated_textureram); + wined3d_driver_info_init(&adapter->driver_info, gpu_description, vram_bytes); } static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, unsigned int ordinal, unsigned int wined3d_creation_flags) { struct wined3d_vk_info *vk_info = &adapter_vk->vk_info; + VkPhysicalDeviceMemoryProperties memory_properties; struct wined3d_adapter *adapter = &adapter_vk->a; VkPhysicalDeviceIDProperties id_properties; VkPhysicalDeviceProperties2 properties2; @@ -696,7 +709,11 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, VK_CALL(vkGetPhysicalDeviceProperties(adapter_vk->physical_device, &properties2.properties)); adapter_vk->device_limits = properties2.properties.limits; - adapter_vk_init_driver_info(adapter, &properties2.properties); + VK_CALL(vkGetPhysicalDeviceMemoryProperties(adapter_vk->physical_device, &memory_properties)); + + adapter_vk_init_driver_info(adapter, &properties2.properties, &memory_properties); + adapter->vram_bytes_used = 0; + TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->driver_info.vram_bytes)); memcpy(&adapter->driver_uuid, id_properties.driverUUID, sizeof(adapter->driver_uuid)); memcpy(&adapter->device_uuid, id_properties.deviceUUID, sizeof(adapter->device_uuid)); -- 2.21.0

2 1

[PATCH] kernel32: Mark LoadAppInitDlls as stub in spec file
by Louis Lenders 07 May '19

07 May '19

Wine-bug: https://bugs.winehq.org/show_bug.cgi?id=47061 Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- dlls/kernel32/kernel32.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/kernel32/kernel32.spec b/dlls/kernel32/kernel32.spec index 2e2828e58b..989b52387d 100644 --- a/dlls/kernel32/kernel32.spec +++ b/dlls/kernel32/kernel32.spec @@ -1041,7 +1041,7 @@ @ stdcall LZStart() @ stdcall LeaveCriticalSection(ptr) ntdll.RtlLeaveCriticalSection @ stdcall LeaveCriticalSectionWhenCallbackReturns(ptr ptr) ntdll.TpCallbackLeaveCriticalSectionOnCompletion -# @ stub LoadAppInitDlls +@ stub LoadAppInitDlls @ stdcall LoadLibraryA(str) @ stdcall LoadLibraryExA( str long long) @ stdcall LoadLibraryExW(wstr long long) -- 2.20.1

1 0

[PATCH 2/2] dinput: Support DIDEVICEINSTANCE_DX3 for Keyboard GetDeviceInfo
by Alistair Leslie-Hughes 07 May '19

07 May '19

Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/dinput/keyboard.c | 5 ----- dlls/dinput/tests/keyboard.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 30 insertions(+), 5 deletions(-) diff --git a/dlls/dinput/keyboard.c b/dlls/dinput/keyboard.c index 70eb579..8341f7d 100644 --- a/dlls/dinput/keyboard.c +++ b/dlls/dinput/keyboard.c @@ -526,11 +526,6 @@ static HRESULT WINAPI SysKeyboardAImpl_GetDeviceInfo( SysKeyboardImpl *This = impl_from_IDirectInputDevice8A(iface); TRACE("(this=%p,%p)\n", This, pdidi); - if (pdidi->dwSize != sizeof(DIDEVICEINSTANCEA)) { - WARN(" dinput3 not supported yet...\n"); - return DI_OK; - } - fill_keyboard_dideviceinstanceA(pdidi, This->base.dinput->dwVersion, This->subtype); return DI_OK; diff --git a/dlls/dinput/tests/keyboard.c b/dlls/dinput/tests/keyboard.c index e8dfb4f..9254123 100644 --- a/dlls/dinput/tests/keyboard.c +++ b/dlls/dinput/tests/keyboard.c @@ -453,6 +453,35 @@ fail: IUnknown_Release(device); } +static void test_GetDeviceInfo(IDirectInputA *pDI) +{ + HRESULT hr; + IDirectInputDeviceA *pKey = NULL; + DIDEVICEINSTANCEA instA; + DIDEVICEINSTANCE_DX3A inst3A; + + hr = IDirectInput_CreateDevice(pDI, &GUID_SysKeyboard, &pKey, NULL); + ok(SUCCEEDED(hr), "IDirectInput_CreateDevice() failed: %08x\n", hr); + if (FAILED(hr)) return; + + instA.dwSize = sizeof(instA); + hr = IDirectInputDevice_GetDeviceInfo(pKey, &instA); + ok(SUCCEEDED(hr), "got %08x\n", hr); + + inst3A.dwSize = sizeof(inst3A); + hr = IDirectInputDevice_GetDeviceInfo(pKey, (DIDEVICEINSTANCEA *)&inst3A); + ok(SUCCEEDED(hr), "got %08x\n", hr); + + ok(instA.dwSize != inst3A.dwSize, "got %d, %d \n", instA.dwSize, inst3A.dwSize); + ok(IsEqualGUID(&instA.guidInstance, &inst3A.guidInstance), "got %s, %s\n", + wine_dbgstr_guid(&instA.guidInstance), wine_dbgstr_guid(&inst3A.guidInstance) ); + ok(IsEqualGUID(&instA.guidProduct, &inst3A.guidProduct), "got %s, %s\n", + wine_dbgstr_guid(&instA.guidProduct), wine_dbgstr_guid(&inst3A.guidProduct) ); + ok(instA.dwDevType == inst3A.dwDevType, "got %d, %d\n", instA.dwDevType, inst3A.dwDevType); + + if (pKey) IUnknown_Release(pKey); +} + static void keyboard_tests(DWORD version) { HRESULT hr; @@ -483,6 +512,7 @@ static void keyboard_tests(DWORD version) test_set_coop(pDI, hwnd); test_get_prop(pDI, hwnd); test_capabilities(pDI, hwnd); + test_GetDeviceInfo(pDI); test_dik_codes(pDI, hwnd, MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT)); test_dik_codes(pDI, hwnd, MAKELANGID(LANG_FRENCH, SUBLANG_FRENCH)); -- 1.9.1

2 1

[PATCH] kernel32: Add K32GetWsChangesEx stub
by Louis Lenders 07 May '19

07 May '19

Wine-bug: https://bugs.winehq.org/show_bug.cgi?id=47131 The program is happy with just stub entrypoint in kernel32.spec, but i added stub implementation anyway Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- .../api-ms-win-core-psapi-l1-1-0.spec | 2 +- dlls/kernel32/kernel32.spec | 2 +- dlls/kernel32/virtual.c | 11 +++++++++++ dlls/kernelbase/kernelbase.spec | 2 +- dlls/psapi/psapi.spec | 1 + include/psapi.h | 7 +++++++ 6 files changed, 22 insertions(+), 3 deletions(-) diff --git a/dlls/api-ms-win-core-psapi-l1-1-0/api-ms-win-core-psapi-l1-1-0.spec b/dlls/api-ms-win-core-psapi-l1-1-0/api-ms-win-core-psapi-l1-1-0.spec index c966b3ff0d..c54c107784 100644 --- a/dlls/api-ms-win-core-psapi-l1-1-0/api-ms-win-core-psapi-l1-1-0.spec +++ b/dlls/api-ms-win-core-psapi-l1-1-0/api-ms-win-core-psapi-l1-1-0.spec @@ -9,7 +9,7 @@ @ stdcall K32GetProcessImageFileNameW(long ptr long) kernel32.K32GetProcessImageFileNameW @ stdcall K32GetProcessMemoryInfo(long ptr long) kernel32.K32GetProcessMemoryInfo @ stdcall K32GetWsChanges(long ptr long) kernel32.K32GetWsChanges -@ stub K32GetWsChangesEx +@ stdcall K32GetWsChangesEx(long ptr ptr) kernel32.K32GetWsChangesEx @ stdcall K32InitializeProcessForWsWatch(long) kernel32.K32InitializeProcessForWsWatch @ stdcall K32QueryWorkingSet(long ptr long) kernel32.K32QueryWorkingSet @ stdcall K32QueryWorkingSetEx(long ptr long) kernel32.K32QueryWorkingSetEx diff --git a/dlls/kernel32/kernel32.spec b/dlls/kernel32/kernel32.spec index 295a4dbab6..2e2828e58b 100644 --- a/dlls/kernel32/kernel32.spec +++ b/dlls/kernel32/kernel32.spec @@ -1018,7 +1018,7 @@ @ stdcall K32GetProcessImageFileNameW(long ptr long) @ stdcall K32GetProcessMemoryInfo(long ptr long) @ stdcall K32GetWsChanges(long ptr long) -# @ stub K32GetWsChangesEx +@ stdcall K32GetWsChangesEx(long ptr ptr) @ stdcall K32InitializeProcessForWsWatch(long) @ stdcall K32QueryWorkingSet(long ptr long) @ stdcall K32QueryWorkingSetEx(long ptr long) diff --git a/dlls/kernel32/virtual.c b/dlls/kernel32/virtual.c index 59c96bd215..a5a2dfdf27 100644 --- a/dlls/kernel32/virtual.c +++ b/dlls/kernel32/virtual.c @@ -724,6 +724,17 @@ BOOL WINAPI K32GetWsChanges(HANDLE process, PPSAPI_WS_WATCH_INFORMATION watchinf return TRUE; } +/*********************************************************************** + * K32GetWsChangesEx (KERNEL32.@) + */ +BOOL WINAPI K32GetWsChangesEx(HANDLE process, PSAPI_WS_WATCH_INFORMATION_EX *watchinfoex, DWORD *size) +{ + FIXME_(seh)("(%p, %p, %p)\n", process, watchinfoex, size); + + SetLastError(ERROR_CALL_NOT_IMPLEMENTED); + return FALSE; +} + /*********************************************************************** * K32InitializeProcessForWsWatch (KERNEL32.@) */ diff --git a/dlls/kernelbase/kernelbase.spec b/dlls/kernelbase/kernelbase.spec index 22ea65fe1c..9bba9ae545 100644 --- a/dlls/kernelbase/kernelbase.spec +++ b/dlls/kernelbase/kernelbase.spec @@ -908,7 +908,7 @@ @ stdcall K32GetProcessImageFileNameW(long ptr long) kernel32.K32GetProcessImageFileNameW @ stdcall K32GetProcessMemoryInfo(long ptr long) kernel32.K32GetProcessMemoryInfo @ stdcall K32GetWsChanges(long ptr long) kernel32.K32GetWsChanges -# @ stub K32GetWsChangesEx +@ stdcall K32GetWsChangesEx(long ptr ptr) kernel32.K32GetWsChangesEx @ stdcall K32InitializeProcessForWsWatch(long) kernel32.K32InitializeProcessForWsWatch @ stdcall K32QueryWorkingSet(long ptr long) kernel32.K32QueryWorkingSet @ stdcall K32QueryWorkingSetEx(long ptr long) kernel32.K32QueryWorkingSetEx diff --git a/dlls/psapi/psapi.spec b/dlls/psapi/psapi.spec index d6116f8c64..6a7bc14815 100644 --- a/dlls/psapi/psapi.spec +++ b/dlls/psapi/psapi.spec @@ -21,6 +21,7 @@ @ stdcall GetProcessImageFileNameW(long ptr long) kernel32.K32GetProcessImageFileNameW @ stdcall GetProcessMemoryInfo(long ptr long) kernel32.K32GetProcessMemoryInfo @ stdcall GetWsChanges(long ptr long) kernel32.K32GetWsChanges +@ stdcall GetWsChangesEx(long ptr ptr) kernel32.K32GetWsChangesEx @ stdcall InitializeProcessForWsWatch(long) kernel32.K32InitializeProcessForWsWatch @ stdcall QueryWorkingSet(long ptr long) kernel32.K32QueryWorkingSet @ stdcall QueryWorkingSetEx(long ptr long) kernel32.K32QueryWorkingSetEx diff --git a/include/psapi.h b/include/psapi.h index c7663f856d..742bf7b574 100644 --- a/include/psapi.h +++ b/include/psapi.h @@ -50,6 +50,12 @@ typedef struct _PSAPI_WS_WATCH_INFORMATION { LPVOID FaultingVa; } PSAPI_WS_WATCH_INFORMATION, *PPSAPI_WS_WATCH_INFORMATION; +typedef struct _PSAPI_WS_WATCH_INFORMATION_EX { + PSAPI_WS_WATCH_INFORMATION BasicInfo; + ULONG_PTR FaultingThreadId; + ULONG_PTR Flags; +} PSAPI_WS_WATCH_INFORMATION_EX, *PPSAPI_WS_WATCH_INFORMATION_EX; + typedef struct _PERFORMANCE_INFORMATION { DWORD cb; SIZE_T CommitTotal; @@ -128,6 +134,7 @@ BOOL WINAPI QueryWorkingSet(HANDLE, PVOID, DWORD); BOOL WINAPI QueryWorkingSetEx(HANDLE, PVOID, DWORD); BOOL WINAPI InitializeProcessForWsWatch(HANDLE); BOOL WINAPI GetWsChanges(HANDLE, PPSAPI_WS_WATCH_INFORMATION, DWORD); +BOOL WINAPI GetWsChangesEx(HANDLE, PSAPI_WS_WATCH_INFORMATION_EX*, DWORD*); DWORD WINAPI GetMappedFileNameW(HANDLE, LPVOID, LPWSTR, DWORD); DWORD WINAPI GetMappedFileNameA(HANDLE, LPVOID, LPSTR, DWORD); #define GetMappedFileName WINELIB_NAME_AW(GetMappedFileName) -- 2.20.1

2 1

[PATCH V3] server: rewrite to use all attributes for group in create_token
by Vijay Kiran Kamuju 06 May '19

06 May '19

Based on patch from Sebastian Lackner <sebastian(a)fds-team.de> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- server/token.c | 31 ++++++------------------------- 1 file changed, 6 insertions(+), 25 deletions(-) diff --git a/server/token.c b/server/token.c index e0f28c6da6e..9944e3bb69c 100644 --- a/server/token.c +++ b/server/token.c @@ -125,13 +125,7 @@ struct privilege struct group { struct list entry; - unsigned enabled : 1; /* is the sid currently enabled? */ - unsigned def : 1; /* is the sid enabled by default? */ - unsigned logon : 1; /* is this a logon sid? */ - unsigned mandatory: 1; /* is this sid always enabled? */ - unsigned owner : 1; /* can this sid be an owner of an object? */ - unsigned resource : 1; /* is this a domain-local group? */ - unsigned deny_only: 1; /* is this a sid that should be use for denying only? */ + unsigned attributes; SID sid; }; @@ -584,16 +578,10 @@ static struct token *create_token( unsigned primary, const SID *user, return NULL; } memcpy( &group->sid, groups[i].Sid, security_sid_len( groups[i].Sid )); - group->enabled = TRUE; - group->def = TRUE; - group->logon = (groups[i].Attributes & SE_GROUP_LOGON_ID) != 0; - group->mandatory = (groups[i].Attributes & SE_GROUP_MANDATORY) != 0; - group->owner = (groups[i].Attributes & SE_GROUP_OWNER) != 0; - group->resource = FALSE; - group->deny_only = FALSE; + group->attributes = groups[i].Attributes; list_add_tail( &token->groups, &group->entry ); /* Use first owner capable group as owner and primary group */ - if (!token->primary_group && group->owner) + if (!token->primary_group && (group->attributes & SE_GROUP_OWNER)) { token->owner = &group->sid; token->primary_group = &group->sid; @@ -963,8 +951,8 @@ int token_sid_present( struct token *token, const SID *sid, int deny ) LIST_FOR_EACH_ENTRY( group, &token->groups, struct group, entry ) { - if (!group->enabled) continue; - if (group->deny_only && !deny) continue; + if (!(group->attributes & SE_GROUP_ENABLED)) continue; + if ((group->attributes & SE_GROUP_USE_FOR_DENY_ONLY) && !deny) continue; if (security_equal_sid( &group->sid, sid )) return TRUE; } @@ -1498,14 +1486,7 @@ DECL_HANDLER(get_token_groups) LIST_FOR_EACH_ENTRY( group, &token->groups, const struct group, entry ) { - *attr_ptr = 0; - if (group->mandatory) *attr_ptr |= SE_GROUP_MANDATORY; - if (group->def) *attr_ptr |= SE_GROUP_ENABLED_BY_DEFAULT; - if (group->enabled) *attr_ptr |= SE_GROUP_ENABLED; - if (group->owner) *attr_ptr |= SE_GROUP_OWNER; - if (group->deny_only) *attr_ptr |= SE_GROUP_USE_FOR_DENY_ONLY; - if (group->resource) *attr_ptr |= SE_GROUP_RESOURCE; - if (group->logon) *attr_ptr |= SE_GROUP_LOGON_ID; + *attr_ptr = group->attributes; memcpy(sid_ptr, &group->sid, security_sid_len( &group->sid )); -- 2.17.0

1 0

[PATCH] ntoskrnl: Add a macro to declare a static CRITICAL_SECTION
by Michael Stefaniuc 06 May '19

06 May '19

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/ntoskrnl.exe/ntoskrnl.c | 27 +++------------------------ dlls/ntoskrnl.exe/sync.c | 9 +-------- include/winnt.h | 9 +++++++++ 3 files changed, 13 insertions(+), 32 deletions(-) diff --git a/dlls/ntoskrnl.exe/ntoskrnl.c b/dlls/ntoskrnl.exe/ntoskrnl.c index cf5cde9a82..4daacfaad3 100644 --- a/dlls/ntoskrnl.exe/ntoskrnl.c +++ b/dlls/ntoskrnl.exe/ntoskrnl.c @@ -137,14 +137,7 @@ static int interface_rb_compare( const void *key, const struct wine_rb_entry *en static struct wine_rb_tree device_interfaces = { interface_rb_compare }; -static CRITICAL_SECTION drivers_cs; -static CRITICAL_SECTION_DEBUG critsect_debug = -{ - 0, 0, &drivers_cs, - { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": drivers_cs") } -}; -static CRITICAL_SECTION drivers_cs = { &critsect_debug, -1, 0, 0, 0, 0 }; +DECLARE_CRITICAL_SECTION(drivers_cs); static inline LPCSTR debugstr_us( const UNICODE_STRING *us ) { @@ -290,14 +283,7 @@ void *alloc_kernel_object( POBJECT_TYPE type, HANDLE handle, SIZE_T size, LONG r return header + 1; } -static CRITICAL_SECTION obref_cs; -static CRITICAL_SECTION_DEBUG obref_critsect_debug = -{ - 0, 0, &obref_cs, - { &obref_critsect_debug.ProcessLocksList, &obref_critsect_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": obref_cs") } -}; -static CRITICAL_SECTION obref_cs = { &obref_critsect_debug, -1, 0, 0, 0, 0 }; +DECLARE_CRITICAL_SECTION(obref_cs); /*********************************************************************** * ObDereferenceObject (NTOSKRNL.EXE.@) @@ -388,14 +374,7 @@ static const POBJECT_TYPE *known_types[] = &SeTokenObjectType }; -static CRITICAL_SECTION handle_map_cs; -static CRITICAL_SECTION_DEBUG handle_map_critsect_debug = -{ - 0, 0, &handle_map_cs, - { &handle_map_critsect_debug.ProcessLocksList, &handle_map_critsect_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": handle_map_cs") } -}; -static CRITICAL_SECTION handle_map_cs = { &handle_map_critsect_debug, -1, 0, 0, 0, 0 }; +DECLARE_CRITICAL_SECTION(handle_map_cs); NTSTATUS kernel_object_from_handle( HANDLE handle, POBJECT_TYPE type, void **ret ) { diff --git a/dlls/ntoskrnl.exe/sync.c b/dlls/ntoskrnl.exe/sync.c index 8ea103b3a6..bbbeb08c9e 100644 --- a/dlls/ntoskrnl.exe/sync.c +++ b/dlls/ntoskrnl.exe/sync.c @@ -48,14 +48,7 @@ enum object_type TYPE_AUTO_TIMER = 9, }; -static CRITICAL_SECTION sync_cs; -static CRITICAL_SECTION_DEBUG sync_cs_debug = -{ - 0, 0, &sync_cs, - { &sync_cs_debug.ProcessLocksList, &sync_cs_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": sync_cs") } -}; -static CRITICAL_SECTION sync_cs = { &sync_cs_debug, -1, 0, 0, 0, 0 }; +DECLARE_CRITICAL_SECTION(sync_cs); /*********************************************************************** * KeWaitForMultipleObjects (NTOSKRNL.EXE.@) diff --git a/include/winnt.h b/include/winnt.h index d0d3b2c24a..b40d6f8661 100644 --- a/include/winnt.h +++ b/include/winnt.h @@ -5932,6 +5932,15 @@ typedef struct _RTL_CRITICAL_SECTION { #define RTL_CRITICAL_SECTION_ALL_FLAG_BITS 0xFF000000 #define RTL_CRITICAL_SECTION_FLAG_RESERVED (RTL_CRITICAL_SECTION_ALL_FLAG_BITS & ~0x7000000) +#if defined(__WINESRC__) && !defined(RC_INVOKED) +#define DECLARE_CRITICAL_SECTION(cs) \ + static CRITICAL_SECTION cs; \ + static CRITICAL_SECTION_DEBUG cs##_debug = \ + { 0, 0, &cs, { &cs##_debug.ProcessLocksList, &cs##_debug.ProcessLocksList }, \ + 0, 0, { (DWORD_PTR)(__FILE__ ": " # cs) }}; \ + static CRITICAL_SECTION cs = { &cs##_debug, -1, 0, 0, 0, 0 }; +#endif + typedef struct _RTL_SRWLOCK { PVOID Ptr; } RTL_SRWLOCK, *PRTL_SRWLOCK; -- 2.20.1

1 0

[PATCH 1/8] winbase: added missing Process Creation Flags
by romanstingler 06 May '19

06 May '19

Signed-off-by: romanstingler <roman.stingler(a)gmail.com> --- include/winbase.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/include/winbase.h b/include/winbase.h index 314a8b7f60..3fdfec3d57 100644 --- a/include/winbase.h +++ b/include/winbase.h @@ -694,6 +694,11 @@ typedef struct _TIME_ZONE_INFORMATION{ #define PROFILE_USER 0x10000000 #define PROFILE_KERNEL 0x20000000 #define PROFILE_SERVER 0x40000000 +#define CREATE_PROTECTED_PROCESS 0x00040000 +#define CREATE_PRESERVE_CODE_AUTHZ_LEVEL 0x02000000 +#define CREATE_SECURE_PROCESS 0x00400000 +#define EXTENDED_STARTUPINFO_PRESENT 0x00080000 +#define INHERIT_PARENT_AFFINITY 0x00010000 /* File object type definitions -- 2.21.0

1 0

[PATCH] rpcrt4: add NdrServerCallAll stub
by Louis Lenders 06 May '19

06 May '19

Wine-bug: https://bugs.winehq.org/show_bug.cgi?id=47131 The program is happy with just stub entrypoint in rpcrt4.spec, but i added stub implementation anyway Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- dlls/rpcrt4/ndr_stubless.c | 8 ++++++++ dlls/rpcrt4/rpcrt4.spec | 1 + include/rpcndr.h | 2 ++ 3 files changed, 11 insertions(+) diff --git a/dlls/rpcrt4/ndr_stubless.c b/dlls/rpcrt4/ndr_stubless.c index 813d7e83f1..530bd9e5eb 100644 --- a/dlls/rpcrt4/ndr_stubless.c +++ b/dlls/rpcrt4/ndr_stubless.c @@ -1557,6 +1557,14 @@ void WINAPI NdrServerCall( PRPC_MESSAGE msg ) NdrStubCall( NULL, NULL, msg, &phase ); } +/*********************************************************************** + * NdrServerCallAll [RPCRT4.@] + */ +void WINAPI NdrServerCallAll( PRPC_MESSAGE msg ) +{ + FIXME("%p stub\n", msg); +} + struct async_call_data { MIDL_STUB_MESSAGE *pStubMsg; diff --git a/dlls/rpcrt4/rpcrt4.spec b/dlls/rpcrt4/rpcrt4.spec index 79c9645fe1..d8e873d194 100644 --- a/dlls/rpcrt4/rpcrt4.spec +++ b/dlls/rpcrt4/rpcrt4.spec @@ -274,6 +274,7 @@ @ stdcall NdrSendReceive(ptr ptr) @ stdcall NdrServerCall2(ptr) @ stdcall NdrServerCall(ptr) +@ stdcall NdrServerCallAll(ptr) @ stdcall NdrServerContextMarshall(ptr ptr long) @ stdcall NdrServerContextNewMarshall(ptr ptr ptr ptr) # wxp @ stdcall NdrServerContextNewUnmarshall(ptr ptr) # wxp diff --git a/include/rpcndr.h b/include/rpcndr.h index 077e02ab7c..ac9da115ca 100644 --- a/include/rpcndr.h +++ b/include/rpcndr.h @@ -676,6 +676,8 @@ RPCRTAPI void RPC_ENTRY NdrServerCall2( PRPC_MESSAGE pRpcMsg ); RPCRTAPI void RPC_ENTRY NdrServerCall( PRPC_MESSAGE pRpcMsg ); +RPCRTAPI void RPC_ENTRY + NdrServerCallAll( PRPC_MESSAGE pRpcMsg ); RPCRTAPI void RPC_ENTRY NdrAsyncServerCall( PRPC_MESSAGE pRpcMsg ); -- 2.20.1

1 0

[PATCH] advapi32: add InitiateShutdown{A,W} stub
by Louis Lenders 06 May '19

06 May '19

Wine-bug: https://bugs.winehq.org/show_bug.cgi?id=47131 The program is happy with just stub entrypoint in advapi32.spec, but i added stub implementation anyway Signed-off-by: Louis Lenders <xerox.xerox2000x(a)gmail.com> --- dlls/advapi32/advapi.c | 20 +++++++++++++++++++- dlls/advapi32/advapi32.spec | 4 ++-- include/winreg.h | 3 +++ 3 files changed, 24 insertions(+), 3 deletions(-) diff --git a/dlls/advapi32/advapi.c b/dlls/advapi32/advapi.c index 1c528ef741..0d77f20663 100644 --- a/dlls/advapi32/advapi.c +++ b/dlls/advapi32/advapi.c @@ -268,6 +268,24 @@ BOOL WINAPI InitiateSystemShutdownW( LPWSTR lpMachineName, LPWSTR lpMessage, DWO SHTDN_REASON_MAJOR_LEGACY_API ); } +/*********************************************************************** + * InitiateShutdownA [ADVAPI32.@] + */ +DWORD WINAPI InitiateShutdownA(char *name, char *message, DWORD seconds, DWORD flags, DWORD reason) +{ + FIXME("%s, %s, %d, %d, %d stub\n", debugstr_a(name), debugstr_a(message), seconds, flags, reason); + return ERROR_CALL_NOT_IMPLEMENTED; +} + +/*********************************************************************** + * InitiateShutdownW [ADVAPI32.@] + */ +DWORD WINAPI InitiateShutdownW(WCHAR *name, WCHAR *message, DWORD seconds, DWORD flags, DWORD reason) +{ + FIXME("%s, %s, %d, %d, %d stub\n", debugstr_w(name), debugstr_w(message), seconds, flags, reason); + return ERROR_CALL_NOT_IMPLEMENTED; +} + BOOL WINAPI LogonUserA( LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWORD dwLogonType, DWORD dwLogonProvider, PHANDLE phToken ) { diff --git a/dlls/advapi32/advapi32.spec b/dlls/advapi32/advapi32.spec index dd4102ebba..91d6750658 100644 --- a/dlls/advapi32/advapi32.spec +++ b/dlls/advapi32/advapi32.spec @@ -405,8 +405,8 @@ @ stdcall InitializeAcl(ptr long long) @ stdcall InitializeSecurityDescriptor(ptr long) @ stdcall InitializeSid(ptr ptr long) -# @ stub InitiateShutdownA -# @ stub InitiateShutdownW +@ stdcall InitiateShutdownA(str str long long long) +@ stdcall InitiateShutdownW(wstr wstr long long long) @ stdcall InitiateSystemShutdownA(str str long long long) @ stdcall InitiateSystemShutdownExA(str str long long long long) @ stdcall InitiateSystemShutdownExW(wstr wstr long long long long) diff --git a/include/winreg.h b/include/winreg.h index 45057df702..bc001c84a5 100644 --- a/include/winreg.h +++ b/include/winreg.h @@ -91,6 +91,9 @@ typedef LONG LSTATUS; WINADVAPI BOOL WINAPI AbortSystemShutdownA(LPSTR); WINADVAPI BOOL WINAPI AbortSystemShutdownW(LPWSTR); #define AbortSystemShutdown WINELIB_NAME_AW(AbortSystemShutdown) +WINADVAPI DWORD WINAPI InitiateShutdownA(char*,char*,DWORD,DWORD,DWORD); +WINADVAPI DWORD WINAPI InitiateShutdownW(WCHAR*,WCHAR*,DWORD,DWORD,DWORD); +#define InitiateShutdown WINELIB_NAME_AW(InitiateShutdown) WINADVAPI BOOL WINAPI InitiateSystemShutdownA(LPSTR,LPSTR,DWORD,BOOL,BOOL); WINADVAPI BOOL WINAPI InitiateSystemShutdownW(LPWSTR,LPWSTR,DWORD,BOOL,BOOL); #define InitiateSystemShutdown WINELIB_NAME_AW(InitiateSystemShutdown) -- 2.20.1

1 0

[PATCH vkd3d 5/7] tests: Introduce queue_{signal,wait}() helpers.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 117 +++++++++++++-------------------------- tests/d3d12_test_utils.h | 18 ++++++ 2 files changed, 57 insertions(+), 78 deletions(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index bc3695de41c0..2c8c44bb2b2b 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -3618,14 +3618,12 @@ static void test_gpu_signal_fence(void) * in D3D12. Vulkan implementations don't signal a fence immediately so * libvkd3d doesn't as well. In order to make this test reliable * wait_queue_idle() is inserted after every ID3D12CommandQueue_Signal(). */ - hr = ID3D12CommandQueue_Signal(queue, fence, 10); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 10); wait_queue_idle(device, queue); value = ID3D12Fence_GetCompletedValue(fence); ok(value == 10, "Got unexpected value %"PRIu64".\n", value); - hr = ID3D12CommandQueue_Signal(queue, fence, 0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 0); wait_queue_idle(device, queue); value = ID3D12Fence_GetCompletedValue(fence); ok(value == 0, "Got unexpected value %"PRIu64".\n", value); @@ -3640,8 +3638,7 @@ static void test_gpu_signal_fence(void) ok(hr == S_OK, "Failed to set event on completion, hr %#x.\n", hr); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 5); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 5); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_OBJECT_0, "Got unexpected return value %#x.\n", ret); @@ -3652,23 +3649,20 @@ static void test_gpu_signal_fence(void) ok(hr == S_OK, "Failed to set event on completion, hr %#x.\n", hr); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 7); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 7); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_OBJECT_0, "Got unexpected return value %#x.\n", ret); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 10); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 10); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); /* Attach one event to multiple values. */ - hr = ID3D12CommandQueue_Signal(queue, fence, 0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 0); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); @@ -3687,8 +3681,7 @@ static void test_gpu_signal_fence(void) ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); for (i = 1; i < 13; ++i) { - hr = ID3D12CommandQueue_Signal(queue, fence, i); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, i); wait_queue_idle(device, queue); if (i == 3 || i == 5 || i == 9 || i == 12) { @@ -3700,8 +3693,7 @@ static void test_gpu_signal_fence(void) } /* Tests with 2 events. */ - hr = ID3D12CommandQueue_Signal(queue, fence, 0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 0); wait_queue_idle(device, queue); value = ID3D12Fence_GetCompletedValue(fence); ok(value == 0, "Got unexpected value %"PRIu64".\n", value); @@ -3718,24 +3710,21 @@ static void test_gpu_signal_fence(void) hr = ID3D12Fence_SetEventOnCompletion(fence, ~(UINT64)0, event2); ok(hr == S_OK, "Failed to set event on completion, hr %#x.\n", hr); - hr = ID3D12CommandQueue_Signal(queue, fence, 50); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 50); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 99); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 99); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 100); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 100); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_OBJECT_0, "Got unexpected return value %#x.\n", ret); @@ -3744,32 +3733,28 @@ static void test_gpu_signal_fence(void) ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 101); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 101); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 0); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 100); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 100); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, ~(UINT64)0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, ~(UINT64)0); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); @@ -3778,15 +3763,13 @@ static void test_gpu_signal_fence(void) ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, ~(UINT64)0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, ~(UINT64)0); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 0); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); @@ -3794,8 +3777,7 @@ static void test_gpu_signal_fence(void) ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); /* Attach two events to the same value. */ - hr = ID3D12CommandQueue_Signal(queue, fence, 0); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 0); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); @@ -3810,8 +3792,7 @@ static void test_gpu_signal_fence(void) ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); ret = wait_event(event2, 0); ok(ret == WAIT_TIMEOUT, "Got unexpected return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, fence, 3); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, 3); wait_queue_idle(device, queue); ret = wait_event(event1, 0); ok(ret == WAIT_OBJECT_0, "Got unexpected return value %#x.\n", ret); @@ -3926,8 +3907,7 @@ static void test_multithread_fence_wait(void) ret = wait_event(thread_data.event, INFINITE); ok(ret == WAIT_OBJECT_0, "Failed to wait for thread start, return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, thread_data.fence, thread_data.value); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, thread_data.fence, thread_data.value); ok(join_thread(thread), "Failed to join thread.\n"); @@ -3937,8 +3917,7 @@ static void test_multithread_fence_wait(void) ret = wait_event(thread_data.event, INFINITE); ok(ret == WAIT_OBJECT_0, "Failed to wait for thread start, return value %#x.\n", ret); - hr = ID3D12CommandQueue_Signal(queue, thread_data.fence, thread_data.value); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, thread_data.fence, thread_data.value); ok(join_thread(thread), "Failed to join thread.\n"); @@ -3977,8 +3956,7 @@ static void test_fence_values(void) for (i = 0; i < 100; ++i) { ++next_value; - hr = ID3D12CommandQueue_Signal(queue, fence, next_value); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, next_value); wait_queue_idle(device, queue); value = ID3D12Fence_GetCompletedValue(fence); ok(value == next_value, "Got value %#"PRIx64", expected %#"PRIx64".\n", value, next_value); @@ -4012,14 +3990,12 @@ static void test_fence_values(void) hr = ID3D12Device_CreateFence(device, 0, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, (void **)&fence); ok(hr == S_OK, "Failed to create fence, hr %#x.\n", hr); next_value = (uint64_t)1 << 60; - hr = ID3D12CommandQueue_Signal(queue, fence, next_value); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, next_value); wait_queue_idle(device, queue); value = ID3D12Fence_GetCompletedValue(fence); ok(value == next_value, "Got value %#"PRIx64", expected %#"PRIx64".\n", value, next_value); next_value = 0; - hr = ID3D12CommandQueue_Signal(queue, fence, next_value); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence, next_value); wait_queue_idle(device, queue); value = ID3D12Fence_GetCompletedValue(fence); ok(value == next_value, "Got value %#"PRIx64", expected %#"PRIx64".\n", value, next_value); @@ -28491,8 +28467,7 @@ static void test_queue_wait(void) /* Wait() with signaled fence */ update_buffer_data(cb, 0, sizeof(green), &green); - hr = ID3D12CommandQueue_Wait(queue, fence, 1); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(queue, fence, 1); exec_command_list(queue, command_list); wait_queue_idle(device, queue); init_readback(&rb, readback_buffer, buffer_size, resource_desc.Width, resource_desc.Height, 1, row_pitch); @@ -28507,11 +28482,9 @@ static void test_queue_wait(void) /* Wait() before CPU signal */ update_buffer_data(cb, 0, sizeof(blue), &blue); - hr = ID3D12CommandQueue_Wait(queue, fence, 2); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(queue, fence, 2); exec_command_list(queue, command_list); - hr = ID3D12CommandQueue_Signal(queue, fence2, 1); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence2, 1); hr = ID3D12Fence_SetEventOnCompletion(fence2, 1, event); ok(hr == S_OK, "Failed to set event on completion, hr %#x.\n", hr); ret = wait_event(event, 0); @@ -28536,11 +28509,9 @@ static void test_queue_wait(void) /* Wait() before GPU signal */ update_buffer_data(cb, 0, sizeof(green), &green); - hr = ID3D12CommandQueue_Wait(queue, fence, 3); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(queue, fence, 3); exec_command_list(queue, command_list); - hr = ID3D12CommandQueue_Signal(queue, fence2, 2); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence2, 2); hr = ID3D12Fence_SetEventOnCompletion(fence2, 2, event); ok(hr == S_OK, "Failed to set event on completion, hr %#x.\n", hr); ret = wait_event(event, 0); @@ -28551,8 +28522,7 @@ static void test_queue_wait(void) value = ID3D12Fence_GetCompletedValue(fence2); ok(value == 1, "Got unexpected value %"PRIu64".\n", value); - hr = ID3D12CommandQueue_Signal(queue2, fence, 3); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue2, fence, 3); ret = wait_event(event, INFINITE); ok(ret == WAIT_OBJECT_0, "Got unexpected return value %#x.\n", ret); ret = wait_event(event, 0); @@ -28564,8 +28534,7 @@ static void test_queue_wait(void) ok(value == 2, "Got unexpected value %"PRIu64".\n", value); /* update constant buffer after Wait() */ - hr = ID3D12CommandQueue_Wait(queue, fence, 5); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(queue, fence, 5); exec_command_list(queue, command_list); hr = ID3D12Fence_Signal(fence, 4); ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); @@ -28589,10 +28558,8 @@ static void test_queue_wait(void) skip_tests: /* Signal() and Wait() in the same command queue */ update_buffer_data(cb, 0, sizeof(blue), &blue); - hr = ID3D12CommandQueue_Signal(queue, fence, 7); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); - hr = ID3D12CommandQueue_Wait(queue, fence, 7); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_signal(queue, fence, 7); + queue_wait(queue, fence, 7); exec_command_list(queue, command_list); wait_queue_idle(device, queue); init_readback(&rb, readback_buffer, buffer_size, resource_desc.Width, resource_desc.Height, 1, row_pitch); @@ -28788,23 +28755,17 @@ static void test_graphics_compute_queue_synchronization(void) } exec_command_list(compute_queue, compute_lists[0]); - hr = ID3D12CommandQueue_Signal(compute_queue, fence, 1); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(compute_queue, fence, 1); - hr = ID3D12CommandQueue_Wait(queue, fence, 1); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(queue, fence, 1); exec_command_list(queue, graphics_lists[0]); - hr = ID3D12CommandQueue_Signal(queue, fence2, 1); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(queue, fence2, 1); - hr = ID3D12CommandQueue_Wait(compute_queue, fence2, 1); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(compute_queue, fence2, 1); exec_command_list(compute_queue, compute_lists[1]); - hr = ID3D12CommandQueue_Signal(compute_queue, fence, 2); - ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + queue_signal(compute_queue, fence, 2); - hr = ID3D12CommandQueue_Wait(queue, fence, 2); - ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + queue_wait(queue, fence, 2); exec_command_list(queue, graphics_lists[1]); hr = wait_for_fence(fence2, 1); diff --git a/tests/d3d12_test_utils.h b/tests/d3d12_test_utils.h index 22ab9e7fcfb4..027a1fd68e97 100644 --- a/tests/d3d12_test_utils.h +++ b/tests/d3d12_test_utils.h @@ -93,6 +93,24 @@ static inline void reset_command_list_(unsigned int line, ok_(line)(SUCCEEDED(hr), "Failed to reset command list, hr %#x.\n", hr); } +#define queue_signal(a, b, c) queue_signal_(__LINE__, a, b, c) +static inline void queue_signal_(unsigned int line, ID3D12CommandQueue *queue, ID3D12Fence *fence, uint64_t value) +{ + HRESULT hr; + + hr = ID3D12CommandQueue_Signal(queue, fence, value); + ok_(line)(hr == S_OK, "Failed to submit signal operation to queue, hr %#x.\n", hr); +} + +#define queue_wait(a, b, c) queue_wait_(__LINE__, a, b, c) +static inline void queue_wait_(unsigned int line, ID3D12CommandQueue *queue, ID3D12Fence *fence, uint64_t value) +{ + HRESULT hr; + + hr = ID3D12CommandQueue_Wait(queue, fence, value); + ok_(line)(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); +} + #define create_buffer(a, b, c, d, e) create_buffer_(__LINE__, a, b, c, d, e) static ID3D12Resource *create_buffer_(unsigned int line, ID3D12Device *device, D3D12_HEAP_TYPE heap_type, size_t size, D3D12_RESOURCE_FLAGS resource_flags, -- 2.21.0

2 1

[PATCH vkd3d 7/7] include: Define TRACE_ON() for VKD3D_NO_TRACE_MESSAGES.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- include/private/vkd3d_debug.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/include/private/vkd3d_debug.h b/include/private/vkd3d_debug.h index 7642dec5a15a..80c5781d1921 100644 --- a/include/private/vkd3d_debug.h +++ b/include/private/vkd3d_debug.h @@ -26,6 +26,7 @@ #ifdef VKD3D_NO_TRACE_MESSAGES #define TRACE(args...) do { } while (0) +#define TRACE_ON() (false) #endif #ifdef VKD3D_NO_DEBUG_MESSAGES @@ -74,7 +75,9 @@ const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN; #define ERR VKD3D_DBG_LOG(ERR) +#ifndef TRACE_ON #define TRACE_ON() (vkd3d_dbg_get_level() == VKD3D_DBG_LEVEL_TRACE) +#endif #define VKD3D_DEBUG_ENV_NAME(name) const char *vkd3d_dbg_env_name = name -- 2.21.0

2 1

[PATCH vkd3d 6/7] vkd3d: Allow 0 vertex stride.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/state.c | 3 - tests/d3d12.c | 171 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 171 insertions(+), 3 deletions(-) diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 6a7b6e5e1d5d..054a9aea1a4f 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -2744,9 +2744,6 @@ VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_sta b->stride = strides[binding]; b->inputRate = graphics->input_rates[binding]; - if (!b->stride) - FIXME("Invalid stride for input slot %u.\n", binding); - pipeline_key.strides[binding_count] = strides[binding]; ++binding_count; diff --git a/tests/d3d12.c b/tests/d3d12.c index 2c8c44bb2b2b..d5f491e190f1 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -21627,6 +21627,176 @@ static void test_dispatch_zero_thread_groups(void) destroy_test_context(&context); } +static void test_zero_vertex_stride(void) +{ + ID3D12PipelineState *instance_pipeline_state; + ID3D12GraphicsCommandList *command_list; + D3D12_INPUT_LAYOUT_DESC input_layout; + D3D12_VERTEX_BUFFER_VIEW vbv[2]; + struct test_context_desc desc; + struct test_context context; + ID3D12CommandQueue *queue; + ID3D12Resource *vb[2]; + + static const D3D12_INPUT_ELEMENT_DESC layout_desc[] = + { + {"sv_position", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + {"color", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + }; + static const D3D12_INPUT_ELEMENT_DESC instance_layout_desc[] = + { + {"sv_position", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0}, + {"color", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 1, D3D12_APPEND_ALIGNED_ELEMENT, + D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA, 0}, + }; + static const DWORD vs_code[] = + { +#if 0 + struct vs_data + { + float4 pos : SV_POSITION; + float4 color : COLOR; + }; + + void main(in struct vs_data vs_input, out struct vs_data vs_output) + { + vs_output.pos = vs_input.pos; + vs_output.color = vs_input.color; + } +#endif + 0x43425844, 0xd5b32785, 0x35332906, 0x4d05e031, 0xf66a58af, 0x00000001, 0x00000144, 0x00000003, + 0x0000002c, 0x00000080, 0x000000d4, 0x4e475349, 0x0000004c, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000000, 0x00000003, 0x00000000, 0x00000f0f, 0x00000044, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x00000f0f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, + 0x4e47534f, 0x0000004c, 0x00000002, 0x00000008, 0x00000038, 0x00000000, 0x00000001, 0x00000003, + 0x00000000, 0x0000000f, 0x00000044, 0x00000000, 0x00000000, 0x00000003, 0x00000001, 0x0000000f, + 0x505f5653, 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, 0x52444853, 0x00000068, 0x00010040, + 0x0000001a, 0x0300005f, 0x001010f2, 0x00000000, 0x0300005f, 0x001010f2, 0x00000001, 0x04000067, + 0x001020f2, 0x00000000, 0x00000001, 0x03000065, 0x001020f2, 0x00000001, 0x05000036, 0x001020f2, + 0x00000000, 0x00101e46, 0x00000000, 0x05000036, 0x001020f2, 0x00000001, 0x00101e46, 0x00000001, + 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE vs = {vs_code, sizeof(vs_code)}; + static const DWORD ps_code[] = + { +#if 0 + struct ps_data + { + float4 pos : SV_POSITION; + float4 color : COLOR; + }; + + float4 main(struct ps_data ps_input) : SV_Target + { + return ps_input.color; + } +#endif + 0x43425844, 0x89803e59, 0x3f798934, 0xf99181df, 0xf5556512, 0x00000001, 0x000000f4, 0x00000003, + 0x0000002c, 0x00000080, 0x000000b4, 0x4e475349, 0x0000004c, 0x00000002, 0x00000008, 0x00000038, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000000f, 0x00000044, 0x00000000, 0x00000000, + 0x00000003, 0x00000001, 0x00000f0f, 0x505f5653, 0x5449534f, 0x004e4f49, 0x4f4c4f43, 0xabab0052, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x52444853, 0x00000038, 0x00000040, + 0x0000000e, 0x03001062, 0x001010f2, 0x00000001, 0x03000065, 0x001020f2, 0x00000000, 0x05000036, + 0x001020f2, 0x00000000, 0x00101e46, 0x00000001, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps = {ps_code, sizeof(ps_code)}; + static const struct vec4 positions[] = + { + {-1.0f, -1.0f, 0.0f, 1.0f}, + {-1.0f, 1.0f, 0.0f, 1.0f}, + { 1.0f, -1.0f, 0.0f, 1.0f}, + { 1.0f, 1.0f, 0.0f, 1.0f}, + }; + static const struct vec4 colors[] = + { + {0.0f, 1.0f, 0.0f, 1.0f}, + {1.0f, 0.0f, 0.0f, 1.0f}, + {0.5f, 0.5f, 0.5f, 1.0f}, + {1.0f, 0.0f, 1.0f, 1.0f}, + {1.0f, 0.0f, 1.0f, 1.0f}, + {1.0f, 0.0f, 1.0f, 1.0f}, + {1.0f, 0.0f, 1.0f, 1.0f}, + {1.0f, 0.0f, 1.0f, 1.0f}, + {1.0f, 0.0f, 1.0f, 1.0f}, + }; + static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; + + memset(&desc, 0, sizeof(desc)); + desc.no_root_signature = true; + if (!init_test_context(&context, &desc)) + return; + command_list = context.list; + queue = context.queue; + + context.root_signature = create_empty_root_signature(context.device, + D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); + input_layout.pInputElementDescs = layout_desc; + input_layout.NumElements = ARRAY_SIZE(layout_desc); + context.pipeline_state = create_pipeline_state(context.device, + context.root_signature, context.render_target_desc.Format, &vs, &ps, &input_layout); + + input_layout.pInputElementDescs = instance_layout_desc; + input_layout.NumElements = ARRAY_SIZE(instance_layout_desc); + instance_pipeline_state = create_pipeline_state(context.device, + context.root_signature, context.render_target_desc.Format, &vs, &ps, &input_layout); + + memset(vbv, 0, sizeof(vbv)); + vb[0] = create_upload_buffer(context.device, sizeof(positions), positions); + vbv[0].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(vb[0]); + vbv[0].StrideInBytes = sizeof(*positions); + vbv[0].SizeInBytes = sizeof(positions); + + vb[1] = create_upload_buffer(context.device, sizeof(colors), colors); + vbv[1].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(vb[1]) + 2 * sizeof(*colors); + vbv[1].StrideInBytes = 0; + vbv[1].SizeInBytes = sizeof(colors); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, ARRAY_SIZE(vbv), vbv); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 4, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uint(context.render_target, 0, queue, command_list, 0xff808080, 2); + + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_RENDER_TARGET); + + vbv[1].BufferLocation = ID3D12Resource_GetGPUVirtualAddress(vb[1]); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, instance_pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + ID3D12GraphicsCommandList_IASetVertexBuffers(command_list, 0, ARRAY_SIZE(vbv), vbv); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 4, 4, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uint(context.render_target, 0, queue, command_list, 0xff00ff00, 0); + + ID3D12Resource_Release(vb[1]); + ID3D12Resource_Release(vb[0]); + ID3D12PipelineState_Release(instance_pipeline_state); + destroy_test_context(&context); +} + static void test_instance_id(void) { D3D12_GRAPHICS_PIPELINE_STATE_DESC pso_desc; @@ -28910,6 +29080,7 @@ START_TEST(d3d12) run_test(test_resolve_query_data_in_reordered_command_list); run_test(test_execute_indirect); run_test(test_dispatch_zero_thread_groups); + run_test(test_zero_vertex_stride); run_test(test_instance_id); run_test(test_vertex_id); run_test(test_copy_texture); -- 2.21.0

2 1

[PATCH vkd3d 4/7] vkd3d: Reuse Vulkan semaphores.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 108 +++++++++++++++++++++++++++++-------- libs/vkd3d/vkd3d_private.h | 10 ++-- 2 files changed, 92 insertions(+), 26 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 53675d597d49..960d3be429d2 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -49,6 +49,8 @@ HRESULT vkd3d_queue_create(struct d3d12_device *device, object->semaphores_size = 0; object->semaphore_count = 0; + memset(object->old_vk_semaphores, 0, sizeof(object->old_vk_semaphores)); + VK_CALL(vkGetDeviceQueue(device->vk_device, family_index, 0, &object->vk_queue)); TRACE("Created queue %p for queue family index %u.\n", object, family_index); @@ -72,6 +74,12 @@ void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device) vkd3d_free(queue->semaphores); + for (i = 0; i < ARRAY_SIZE(queue->old_vk_semaphores); ++i) + { + if (queue->old_vk_semaphores[i]) + VK_CALL(vkDestroySemaphore(device->vk_device, queue->old_vk_semaphores[i], NULL)); + } + if (!rc) pthread_mutex_unlock(&queue->mutex); @@ -129,8 +137,10 @@ static void vkd3d_queue_update_sequence_number(struct vkd3d_queue *queue, uint64_t sequence_number, struct d3d12_device *device) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + unsigned int destroyed_semaphore_count = 0; uint64_t completed_sequence_number; - unsigned int i; + VkSemaphore vk_semaphore; + unsigned int i, j; int rc; if ((rc = pthread_mutex_lock(&queue->mutex))) @@ -149,15 +159,34 @@ static void vkd3d_queue_update_sequence_number(struct vkd3d_queue *queue, if (queue->semaphores[i].sequence_number > queue->completed_sequence_number) break; - VK_CALL(vkDestroySemaphore(device->vk_device, queue->semaphores[i].vk_semaphore, NULL)); + vk_semaphore = queue->semaphores[i].vk_semaphore; + + /* Try to store the Vulkan semaphore for reuse. */ + for (j = 0; j < ARRAY_SIZE(queue->old_vk_semaphores); ++j) + { + if (queue->old_vk_semaphores[j] == VK_NULL_HANDLE) + { + queue->old_vk_semaphores[j] = vk_semaphore; + vk_semaphore = VK_NULL_HANDLE; + break; + } + } + + if (!vk_semaphore) + continue; + + VK_CALL(vkDestroySemaphore(device->vk_device, vk_semaphore, NULL)); + ++destroyed_semaphore_count; } if (i > 0) { - TRACE("Destroyed %u Vulkan semaphores.\n", i); queue->semaphore_count -= i; memmove(queue->semaphores, &queue->semaphores[i], queue->semaphore_count * sizeof(*queue->semaphores)); } + if (destroyed_semaphore_count) + TRACE("Destroyed %u Vulkan semaphores.\n", destroyed_semaphore_count); + pthread_mutex_unlock(&queue->mutex); } @@ -176,6 +205,42 @@ static uint64_t vkd3d_queue_reset_sequence_number_locked(struct vkd3d_queue *que return queue->submitted_sequence_number; } +static VkResult vkd3d_queue_create_vk_semaphore_locked(struct vkd3d_queue *queue, + struct d3d12_device *device, VkSemaphore *vk_semaphore) +{ + const struct vkd3d_vk_device_procs *vk_procs; + VkSemaphoreCreateInfo semaphore_info; + unsigned int i; + VkResult vr; + + *vk_semaphore = VK_NULL_HANDLE; + + for (i = 0; i < ARRAY_SIZE(queue->old_vk_semaphores); ++i) + { + if ((*vk_semaphore = queue->old_vk_semaphores[i])) + { + queue->old_vk_semaphores[i] = VK_NULL_HANDLE; + break; + } + } + + if (*vk_semaphore) + return VK_SUCCESS; + + vk_procs = &device->vk_procs; + + semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + semaphore_info.pNext = NULL; + semaphore_info.flags = 0; + if ((vr = VK_CALL(vkCreateSemaphore(device->vk_device, &semaphore_info, NULL, vk_semaphore))) < 0) + { + WARN("Failed to create Vulkan semaphore, vr %d.\n", vr); + *vk_semaphore = VK_NULL_HANDLE; + } + + return vr; +} + /* Fence worker thread */ static HRESULT vkd3d_enqueue_gpu_fence(struct vkd3d_fence_worker *worker, VkFence vk_fence, struct d3d12_fence *fence, uint64_t value, @@ -488,6 +553,8 @@ static VkResult d3d12_fence_create_vk_fence(struct d3d12_fence *fence, VkFence * VkResult vr; int rc; + *vk_fence = VK_NULL_HANDLE; + if ((rc = pthread_mutex_lock(&fence->mutex))) { ERR("Failed to lock mutex, error %d.\n", rc); @@ -515,7 +582,10 @@ create_fence: fence_info.pNext = NULL; fence_info.flags = 0; if ((vr = VK_CALL(vkCreateFence(device->vk_device, &fence_info, NULL, vk_fence))) < 0) + { + WARN("Failed to create Vulkan fence, vr %d.\n", vr); *vk_fence = VK_NULL_HANDLE; + } return vr; } @@ -529,12 +599,12 @@ static void d3d12_fence_garbage_collect_vk_semaphores_locked(struct d3d12_fence unsigned int semaphore_count; semaphore_count = fence->semaphore_count; - if (!destroy_all && semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE) + if (!destroy_all && semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS) return; LIST_FOR_EACH_ENTRY_SAFE(current, p, &fence->semaphores, struct vkd3d_signaled_semaphore, entry) { - if (!destroy_all && fence->semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE) + if (!destroy_all && fence->semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS) break; /* The semaphore doesn't have a pending signal operation if the fence @@ -5259,7 +5329,6 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * struct d3d12_command_queue *command_queue = impl_from_ID3D12CommandQueue(iface); const struct vkd3d_vk_device_procs *vk_procs; VkSemaphore vk_semaphore = VK_NULL_HANDLE; - VkSemaphoreCreateInfo semaphore_info; VkFence vk_fence = VK_NULL_HANDLE; struct vkd3d_queue *vkd3d_queue; struct d3d12_device *device; @@ -5284,15 +5353,17 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * goto fail_vkresult; } - /* XXX: It may be a good idea to re-use Vulkan semaphores. */ - semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; - semaphore_info.pNext = NULL; - semaphore_info.flags = 0; - if ((vr = VK_CALL(vkCreateSemaphore(device->vk_device, &semaphore_info, NULL, &vk_semaphore))) < 0) + if (!(vk_queue = vkd3d_queue_acquire(vkd3d_queue))) { - WARN("Failed to create Vulkan semaphore, vr %d.\n", vr); + ERR("Failed to acquire queue %p.\n", vkd3d_queue); + hr = E_FAIL; + goto fail; + } + + if ((vr = vkd3d_queue_create_vk_semaphore_locked(vkd3d_queue, device, &vk_semaphore)) < 0) + { + ERR("Failed to create Vulkan semaphore, vr %d.\n", vr); vk_semaphore = VK_NULL_HANDLE; - goto fail_vkresult; } submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; @@ -5302,16 +5373,9 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * submit_info.pWaitDstStageMask = NULL; submit_info.commandBufferCount = 0; submit_info.pCommandBuffers = NULL; - submit_info.signalSemaphoreCount = 1; + submit_info.signalSemaphoreCount = vk_semaphore ? 1 : 0; submit_info.pSignalSemaphores = &vk_semaphore; - if (!(vk_queue = vkd3d_queue_acquire(vkd3d_queue))) - { - ERR("Failed to acquire queue %p.\n", vkd3d_queue); - hr = E_FAIL; - goto fail; - } - if ((vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, vk_fence))) >= 0) { sequence_number = ++vkd3d_queue->submitted_sequence_number; @@ -5329,7 +5393,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * goto fail_vkresult; } - if (SUCCEEDED(hr = d3d12_fence_add_vk_semaphore(fence, vk_semaphore, vk_fence, value))) + if (vk_semaphore && SUCCEEDED(hr = d3d12_fence_add_vk_semaphore(fence, vk_semaphore, vk_fence, value))) vk_semaphore = VK_NULL_HANDLE; vr = VK_CALL(vkGetFenceStatus(device->vk_device, vk_fence)); diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 349591ddfe04..8314298e9b41 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -48,9 +48,9 @@ #define VKD3D_DESCRIPTOR_MAGIC_DSV 0x00565344u #define VKD3D_DESCRIPTOR_MAGIC_RTV 0x00565452u -#define VKD3D_MAX_QUEUE_FAMILY_COUNT 3u -#define VKD3D_MAX_SHADER_STAGES 5u -#define VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE 4u +#define VKD3D_MAX_QUEUE_FAMILY_COUNT 3u +#define VKD3D_MAX_SHADER_STAGES 5u +#define VKD3D_MAX_VK_SYNC_OBJECTS 4u struct d3d12_command_list; struct d3d12_device; @@ -310,7 +310,7 @@ struct d3d12_fence struct list semaphores; unsigned int semaphore_count; - VkFence old_vk_fences[VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE]; + VkFence old_vk_fences[VKD3D_MAX_VK_SYNC_OBJECTS]; struct d3d12_device *device; @@ -902,6 +902,8 @@ struct vkd3d_queue } *semaphores; size_t semaphores_size; size_t semaphore_count; + + VkSemaphore old_vk_semaphores[VKD3D_MAX_VK_SYNC_OBJECTS]; }; VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; -- 2.21.0

2 1

[PATCH vkd3d 3/7] vkd3d: Handle integer overflow of sequence numbers.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index c8e23e1fd2ab..53675d597d49 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -161,6 +161,21 @@ static void vkd3d_queue_update_sequence_number(struct vkd3d_queue *queue, pthread_mutex_unlock(&queue->mutex); } +static uint64_t vkd3d_queue_reset_sequence_number_locked(struct vkd3d_queue *queue) +{ + unsigned int i; + + WARN("Ressetting sequence number for queue %p.\n", queue); + + queue->completed_sequence_number = 0; + queue->submitted_sequence_number = 1; + + for (i = 0; i < queue->semaphore_count; ++i) + queue->semaphores[i].sequence_number = queue->submitted_sequence_number; + + return queue->submitted_sequence_number; +} + /* Fence worker thread */ static HRESULT vkd3d_enqueue_gpu_fence(struct vkd3d_fence_worker *worker, VkFence vk_fence, struct d3d12_fence *fence, uint64_t value, @@ -5298,11 +5313,15 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * } if ((vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, vk_fence))) >= 0) + { sequence_number = ++vkd3d_queue->submitted_sequence_number; - vkd3d_queue_release(vkd3d_queue); + /* We don't expect to overrun the 64-bit counter, but we handle it gracefully anyway. */ + if (!sequence_number) + sequence_number = vkd3d_queue_reset_sequence_number_locked(vkd3d_queue); + } - assert(sequence_number != ~(uint64_t)0); + vkd3d_queue_release(vkd3d_queue); if (vr < 0) { -- 2.21.0

2 1

[PATCH vkd3d 2/7] vkd3d: Validate resource flags.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 36e470bdd0d5..aba850f27206 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -549,6 +549,9 @@ HRESULT vkd3d_create_buffer(struct d3d12_device *device, buffer_info.pQueueFamilyIndices = NULL; } + if (desc->Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) + FIXME("Unsupported resource flags %#x.\n", desc->Flags); + if ((vr = VK_CALL(vkCreateBuffer(device->vk_device, &buffer_info, NULL, vk_buffer))) < 0) { WARN("Failed to create Vulkan buffer, vr %d.\n", vr); @@ -672,6 +675,7 @@ HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, HRESULT hr; assert(desc->Dimension != D3D12_RESOURCE_DIMENSION_BUFFER); + assert(d3d12_resource_validate_desc(desc) == S_OK); if (!desc->MipLevels) { @@ -1190,6 +1194,22 @@ struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) return impl_from_ID3D12Resource(iface); } +static void d3d12_validate_resource_flags(D3D12_RESOURCE_FLAGS flags) +{ + unsigned int unknown_flags = flags & ~(D3D12_RESOURCE_FLAG_NONE + | D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET + | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL + | D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS + | D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE + | D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER + | D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS); + + if (unknown_flags) + FIXME("Unknown resource flags %#x.\n", unknown_flags); + if (flags & D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER) + FIXME("Ignoring D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER.\n"); +} + HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc) { switch (desc->Dimension) @@ -1228,6 +1248,8 @@ HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc) return E_INVALIDARG; } + d3d12_validate_resource_flags(desc->Flags); + /* FIXME: Validate alignment for textures. */ return S_OK; -- 2.21.0

2 1

[PATCH vkd3d 1/7] vkd3d: Use VK_SHARING_MODE_CONCURRENT only when queue family count > 1.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> The Vulkan spec states: If sharingMode is VK_SHARING_MODE_CONCURRENT, queueFamilyIndexCount must be greater than 1. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 5bb76bf0c3e0..36e470bdd0d5 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -536,9 +536,18 @@ HRESULT vkd3d_create_buffer(struct d3d12_device *device, return E_INVALIDARG; } - buffer_info.sharingMode = VK_SHARING_MODE_CONCURRENT; - buffer_info.queueFamilyIndexCount = device->queue_family_count; - buffer_info.pQueueFamilyIndices = device->queue_family_indices; + if (device->queue_family_count > 1) + { + buffer_info.sharingMode = VK_SHARING_MODE_CONCURRENT; + buffer_info.queueFamilyIndexCount = device->queue_family_count; + buffer_info.pQueueFamilyIndices = device->queue_family_indices; + } + else + { + buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + buffer_info.queueFamilyIndexCount = 0; + buffer_info.pQueueFamilyIndices = NULL; + } if ((vr = VK_CALL(vkCreateBuffer(device->vk_device, &buffer_info, NULL, vk_buffer))) < 0) { @@ -626,7 +635,7 @@ static HRESULT vkd3d_create_image(struct d3d12_device *device, if (!(desc->Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE)) image_info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT; - if (desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS) + if ((desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS) && device->queue_family_count > 1) { TRACE("Creating image with VK_SHARING_MODE_CONCURRENT.\n"); image_info.sharingMode = VK_SHARING_MODE_CONCURRENT; -- 2.21.0

2 1

[PATCH 5/5] winex11: Only handle errors from GLX requests in GLXErrorHandler().
by Henri Verbeet 06 May '19

06 May '19

Spurious errors that would otherwise be handled by ignore_error() may cause OpenGL context creation to fail. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/winex11.drv/opengl.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/dlls/winex11.drv/opengl.c b/dlls/winex11.drv/opengl.c index a51a935ca4d..ee28a1d7902 100644 --- a/dlls/winex11.drv/opengl.c +++ b/dlls/winex11.drv/opengl.c @@ -182,6 +182,7 @@ static char *glExtensions; static const char *glxExtensions; static char wglExtensions[4096]; static int glxVersion[2]; +static int glx_opcode; struct wgl_pixel_format { @@ -336,7 +337,6 @@ static void (*pglXDestroyContext)( Display *dpy, GLXContext ctx ); static Bool (*pglXMakeCurrent)( Display *dpy, GLXDrawable drawable, GLXContext ctx); static void (*pglXCopyContext)( Display *dpy, GLXContext src, GLXContext dst, unsigned long mask ); static void (*pglXSwapBuffers)( Display *dpy, GLXDrawable drawable ); -static Bool (*pglXQueryExtension)( Display *dpy, int *errorb, int *event ); static Bool (*pglXQueryVersion)( Display *dpy, int *maj, int *min ); static Bool (*pglXIsDirect)( Display *dpy, GLXContext ctx ); static GLXContext (*pglXGetCurrentContext)( void ); @@ -412,6 +412,8 @@ static BOOL has_extension( const char *list, const char *ext ) static int GLXErrorHandler(Display *dpy, XErrorEvent *event, void *arg) { /* In the future we might want to find the exact X or GLX error to report back to the app */ + if (event->request_code != glx_opcode) + return 0; return 1; } @@ -594,7 +596,6 @@ static BOOL WINAPI init_opengl( INIT_ONCE *once, void *param, void **context ) LOAD_FUNCPTR(glXIsDirect); LOAD_FUNCPTR(glXMakeCurrent); LOAD_FUNCPTR(glXSwapBuffers); - LOAD_FUNCPTR(glXQueryExtension); LOAD_FUNCPTR(glXQueryVersion); /* GLX 1.1 */ @@ -633,7 +634,8 @@ static BOOL WINAPI init_opengl( INIT_ONCE *once, void *param, void **context ) if(!X11DRV_WineGL_InitOpenglInfo()) goto failed; - if (pglXQueryExtension(gdi_display, &error_base, &event_base)) { + if (XQueryExtension( gdi_display, "GLX", &glx_opcode, &event_base, &error_base )) + { TRACE("GLX is up and running error_base = %d\n", error_base); } else { ERR( "GLX extension is missing, disabling OpenGL.\n" ); -- 2.11.0

2 1

[PATCH 4/5] wined3d: Get rid of context_validate_onscreen_formats().
by Henri Verbeet 06 May '19

06 May '19

This was used when using the onscreen depth/stencil buffer with FBOs. We no longer do that. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 48 ------------------------------------------------ 1 file changed, 48 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 30686f57200..0defbcc25a9 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -2683,47 +2683,6 @@ static void context_set_render_offscreen(struct wined3d_context *context, BOOL o context->render_offscreen = offscreen; } -static BOOL match_depth_stencil_format(const struct wined3d_format *existing, - const struct wined3d_format *required) -{ - if (existing == required) - return TRUE; - if ((existing->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT) - != (required->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)) - return FALSE; - if (existing->depth_size < required->depth_size) - return FALSE; - /* If stencil bits are used the exact amount is required - otherwise - * wrapping won't work correctly. */ - if (required->stencil_size && required->stencil_size != existing->stencil_size) - return FALSE; - return TRUE; -} - -/* Context activation is done by the caller. */ -static void context_validate_onscreen_formats(struct wined3d_context *context, - const struct wined3d_rendertarget_view *depth_stencil) -{ - /* Onscreen surfaces are always in a swapchain */ - struct wined3d_swapchain *swapchain = context->current_rt.texture->swapchain; - - if (context->render_offscreen || !depth_stencil) return; - if (match_depth_stencil_format(swapchain->ds_format, depth_stencil->format)) return; - - /* TODO: If the requested format would satisfy the needs of the existing one(reverse match), - * or no onscreen depth buffer was created, the OpenGL drawable could be changed to the new - * format. */ - WARN("Depth stencil format is not supported by WGL, rendering the backbuffer in an FBO\n"); - - /* The currently active context is the necessary context to access the swapchain's onscreen buffers */ - if (!(wined3d_texture_load_location(context->current_rt.texture, context->current_rt.sub_resource_idx, - context, WINED3D_LOCATION_TEXTURE_RGB))) - ERR("Failed to load location.\n"); - swapchain->render_to_fbo = TRUE; - swapchain_update_draw_bindings(swapchain); - context_set_render_offscreen(context, TRUE); -} - GLenum context_get_offscreen_gl_buffer(const struct wined3d_context *context) { switch (wined3d_settings.offscreen_rendering_mode) @@ -3031,8 +2990,6 @@ BOOL context_apply_clear_state(struct wined3d_context *context, const struct win { struct wined3d_rendertarget_info ds_info = {{0}}; - context_validate_onscreen_formats(context, dsv); - if (!rt_count || wined3d_resource_is_offscreen(rts[0]->resource)) { memset(context->blit_targets, 0, sizeof(context->blit_targets)); @@ -3946,11 +3903,6 @@ static BOOL context_apply_draw_state(struct wined3d_context *context, context_set_render_offscreen(context, TRUE); } - if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && isStateDirty(context, STATE_FRAMEBUFFER)) - { - context_validate_onscreen_formats(context, fb->depth_stencil); - } - /* Preload resources before FBO setup. Texture preload in particular may * result in changes to the current FBO, due to using e.g. FBO blits for * updating a resource location. */ -- 2.11.0

2 1

[PATCH 3/5] wined3d: Get rid of the "target" parameter to wined3d_adapter_gl_create_context().
by Henri Verbeet 06 May '19

06 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 3 +-- dlls/wined3d/context.c | 16 ++++++++-------- dlls/wined3d/directx.c | 2 +- dlls/wined3d/wined3d_private.h | 8 ++++---- 4 files changed, 14 insertions(+), 15 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index a5fd8912603..da53edd953a 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -288,8 +288,7 @@ static void adapter_vk_destroy_device(struct wined3d_device *device) heap_free(device_vk); } -static BOOL adapter_vk_create_context(struct wined3d_context *context, - struct wined3d_texture *target, const struct wined3d_format *ds_format) +static BOOL adapter_vk_create_context(struct wined3d_context *context, const struct wined3d_format *ds_format) { return TRUE; } diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index a4f4be5357c..30686f57200 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1967,12 +1967,11 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, const struct wined3d_format *ds_format) { - struct wined3d_texture *target = swapchain->front_buffer; struct wined3d_device *device = swapchain->device; struct wined3d_context_gl *context_gl; struct wined3d_context *context; - TRACE("swapchain %p, target %p, window %p.\n", swapchain, target, swapchain->win_handle); + TRACE("swapchain %p.\n", swapchain); wined3d_from_cs(device->cs); @@ -1985,7 +1984,7 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, cons heap_free(context_gl); return NULL; } - if (!(device->adapter->adapter_ops->adapter_create_context(context, target, ds_format))) + if (!(device->adapter->adapter_ops->adapter_create_context(context, ds_format))) { wined3d_release_dc(context->win_handle, context->hdc); heap_free(context_gl); @@ -2004,13 +2003,13 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, cons return context; } -BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, - struct wined3d_texture *target, const struct wined3d_format *ds_format) +BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, const struct wined3d_format *ds_format) { struct wined3d_device *device = context->device; const struct wined3d_format *color_format; const struct wined3d_d3d_info *d3d_info; const struct wined3d_gl_info *gl_info; + struct wined3d_resource *target; unsigned int target_bind_flags; BOOL aux_buffers = FALSE; HGLRC ctx, share_ctx; @@ -2057,8 +2056,9 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, sizeof(*context->texture_type)))) return FALSE; - color_format = target->resource.format; - target_bind_flags = target->resource.bind_flags; + target = &context->current_rt.texture->resource; + color_format = target->format; + target_bind_flags = target->bind_flags; /* In case of ORM_BACKBUFFER, make sure to request an alpha component for * X4R4G4B4/X8R8G8B8 as we might need it for the backbuffer. */ @@ -2141,7 +2141,7 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, } } - context->render_offscreen = wined3d_resource_is_offscreen(&target->resource); + context->render_offscreen = wined3d_resource_is_offscreen(target); context->draw_buffers_mask = context_generate_rt_mask(GL_BACK); context->valid = 1; diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index b8c151dc971..c909e5185a1 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2256,7 +2256,7 @@ static void adapter_no3d_destroy_device(struct wined3d_device *device) } static BOOL wined3d_adapter_no3d_create_context(struct wined3d_context *context, - struct wined3d_texture *target, const struct wined3d_format *ds_format) + const struct wined3d_format *ds_format) { return TRUE; } diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 02177a96b7f..fbcda94537e 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2711,8 +2711,7 @@ struct wined3d_adapter_ops BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, struct wined3d_device_parent *device_parent, struct wined3d_device **device); void (*adapter_destroy_device)(struct wined3d_device *device); - BOOL (*adapter_create_context)(struct wined3d_context *context, - struct wined3d_texture *target, const struct wined3d_format *ds_format); + BOOL (*adapter_create_context)(struct wined3d_context *context, const struct wined3d_format *ds_format); void (*adapter_get_wined3d_caps)(const struct wined3d_adapter *adapter, struct wined3d_caps *caps); BOOL (*adapter_check_format)(const struct wined3d_adapter *adapter, const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format, @@ -2767,9 +2766,10 @@ static inline const struct wined3d_adapter_gl *wined3d_adapter_gl_const(const st return CONTAINING_RECORD(adapter, struct wined3d_adapter_gl, a); } -struct wined3d_adapter *wined3d_adapter_gl_create(unsigned int ordinal, unsigned int wined3d_creation_flags) DECLSPEC_HIDDEN; +struct wined3d_adapter *wined3d_adapter_gl_create(unsigned int ordinal, + unsigned int wined3d_creation_flags) DECLSPEC_HIDDEN; BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, - struct wined3d_texture *target, const struct wined3d_format *ds_format) DECLSPEC_HIDDEN; + const struct wined3d_format *ds_format) DECLSPEC_HIDDEN; struct wined3d_adapter_vk { -- 2.11.0

2 1

[PATCH] d3d11: Set more format support flags.
by Józef Kucia 06 May '19

06 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47096 Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/device.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/dlls/d3d11/device.c b/dlls/d3d11/device.c index 588395b4b6a6..768fe4bc5503 100644 --- a/dlls/d3d11/device.c +++ b/dlls/d3d11/device.c @@ -3342,6 +3342,20 @@ static HRESULT STDMETHODCALLTYPE d3d11_device_CheckFormatSupport(ID3D11Device2 * } wined3d_mutex_unlock(); + if (*format_support & (D3D11_FORMAT_SUPPORT_TEXTURE1D + | D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURE3D)) + { + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_LOAD; + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE; + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER; + + if (*format_support & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL) + { + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON; + *format_support |= D3D11_FORMAT_SUPPORT_SHADER_GATHER_COMPARISON; + } + } + return S_OK; } -- 2.19.2

4 3

[PATCH 2/5] wined3d: Get rid of the "target" parameter to wined3d_context_init().
by Henri Verbeet 06 May '19

06 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 3b1832fe108..a4f4be5357c 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1910,8 +1910,7 @@ HGLRC context_create_wgl_attribs(const struct wined3d_gl_info *gl_info, HDC hdc, return ctx; } -static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d_swapchain *swapchain, - struct wined3d_texture *target, const struct wined3d_format *ds_format) +static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d_swapchain *swapchain) { struct wined3d_device *device = swapchain->device; DWORD state; @@ -1952,7 +1951,7 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d context->device = device; context->swapchain = swapchain; - context->current_rt.texture = target; + context->current_rt.texture = swapchain->front_buffer; context->current_rt.sub_resource_idx = 0; context->tid = GetCurrentThreadId(); @@ -1981,7 +1980,7 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, cons return NULL; context = &context_gl->c; - if (!(wined3d_context_init(context, swapchain, target, ds_format))) + if (!(wined3d_context_init(context, swapchain))) { heap_free(context_gl); return NULL; -- 2.11.0

1 0

[PATCH 1/5] wined3d: Get rid of the "target" parameter to context_create().
by Henri Verbeet 06 May '19

06 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 4 ++-- dlls/wined3d/swapchain.c | 4 ++-- dlls/wined3d/wined3d_private.h | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 7e7ab09b76c..3b1832fe108 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1966,9 +1966,9 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d return TRUE; } -struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, - struct wined3d_texture *target, const struct wined3d_format *ds_format) +struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, const struct wined3d_format *ds_format) { + struct wined3d_texture *target = swapchain->front_buffer; struct wined3d_device *device = swapchain->device; struct wined3d_context_gl *context_gl; struct wined3d_context *context; diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index 4ac091f6924..7210682c45f 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -739,7 +739,7 @@ static void wined3d_swapchain_cs_init(void *object) for (i = 0; i < ARRAY_SIZE(formats); ++i) { swapchain->ds_format = wined3d_get_format(adapter, formats[i], WINED3D_BIND_DEPTH_STENCIL); - if ((swapchain->context[0] = context_create(swapchain, swapchain->front_buffer, swapchain->ds_format))) + if ((swapchain->context[0] = context_create(swapchain, swapchain->ds_format))) break; TRACE("Depth stencil format %s is not supported, trying next format.\n", debug_d3dformat(formats[i])); } @@ -1085,7 +1085,7 @@ static struct wined3d_context *swapchain_create_context(struct wined3d_swapchain TRACE("Creating a new context for swapchain %p, thread %u.\n", swapchain, GetCurrentThreadId()); - if (!(ctx = context_create(swapchain, swapchain->front_buffer, swapchain->ds_format))) + if (!(ctx = context_create(swapchain, swapchain->ds_format))) { ERR("Failed to create a new context for the swapchain\n"); return NULL; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index e698c792813..02177a96b7f 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2196,7 +2196,7 @@ void context_check_fbo_status(const struct wined3d_context *context, GLenum targ void context_copy_bo_address(struct wined3d_context *context, const struct wined3d_bo_address *dst, GLenum dst_binding, const struct wined3d_bo_address *src, GLenum src_binding, size_t size) DECLSPEC_HIDDEN; -struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, struct wined3d_texture *target, +struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, const struct wined3d_format *ds_format) DECLSPEC_HIDDEN; HGLRC context_create_wgl_attribs(const struct wined3d_gl_info *gl_info, HDC hdc, HGLRC share_ctx) DECLSPEC_HIDDEN; void wined3d_context_destroy(struct wined3d_context *context) DECLSPEC_HIDDEN; -- 2.11.0

1 0

[PATCH] winemac.drv: Allow mac IME to clear text in system input method
by Aric Stewart 06 May '19

06 May '19

v2: correct Extra semicolon spotted by Zhiyi Zhang v3: updates from Ken Thomases Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/winemac.drv/cocoa_window.m | 26 +++++++++++++++++++++++--- dlls/winemac.drv/ime.c | 2 +- dlls/winemac.drv/macdrv_cocoa.h | 2 ++ 3 files changed, 26 insertions(+), 4 deletions(-)

2 1

[PATCH 2/4] d3d11/tests: Add test for creating deferred contexts.
by Józef Kucia 06 May '19

06 May '19

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 52 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 2850d59757e5..b1148cd9494d 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -2185,6 +2185,57 @@ static void test_get_immediate_context(void) ok(!refcount, "Device has %u references left.\n", refcount); } +static void test_create_deferred_context(void) +{ + ULONG refcount, expected_refcount; + struct device_desc device_desc; + ID3D11DeviceContext *context; + ID3D11Device *device; + HRESULT hr; + + device_desc.feature_level = NULL; + device_desc.flags = D3D11_CREATE_DEVICE_SINGLETHREADED; + if (!(device = create_device(&device_desc))) + { + skip("Failed to create single-threaded device.\n"); + return; + } + + hr = ID3D11Device_CreateDeferredContext(device, 0, &context); + todo_wine ok(hr == DXGI_ERROR_INVALID_CALL, "Failed to create deferred context, hr %#x.\n", hr); + + refcount = ID3D11Device_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + + if (!(device = create_device(NULL))) + { + skip("Failed to create device.\n"); + return; + } + + expected_refcount = get_refcount(device) + 1; + hr = ID3D11Device_CreateDeferredContext(device, 0, &context); + todo_wine ok(hr == S_OK, "Failed to create deferred context, hr %#x.\n", hr); + if (FAILED(hr)) + goto done; + refcount = get_refcount(device); + ok(refcount == expected_refcount, "Got refcount %u, expected %u.\n", refcount, expected_refcount); + refcount = get_refcount(context); + ok(refcount == 1, "Got unexpected refcount %u.\n", refcount); + + check_interface(context, &IID_IUnknown, TRUE, FALSE); + check_interface(context, &IID_ID3D11DeviceChild, TRUE, FALSE); + check_interface(context, &IID_ID3D11DeviceContext, TRUE, FALSE); + check_interface(context, &IID_ID3D11Multithread, FALSE, FALSE); + + refcount = ID3D11DeviceContext_Release(context); + ok(!refcount, "Got unexpected refcount %u.\n", refcount); + +done: + refcount = ID3D11Device_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); +} + static void test_create_texture1d(void) { ULONG refcount, expected_refcount; @@ -29205,6 +29256,7 @@ START_TEST(d3d11) queue_test(test_create_device); queue_for_each_feature_level(test_device_interfaces); queue_test(test_get_immediate_context); + queue_test(test_create_deferred_context); queue_test(test_create_texture1d); queue_test(test_texture1d_interfaces); queue_test(test_create_texture2d); -- 2.21.0

3 2

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel