wine-devel June 2020

wine-devel@winehq.org

75 participants
814 discussions

Start a nNew thread

[PATCH 4/8 v2] msi: Test freeing _TransformView table.
by Piotr Caban 30 Jun '20

30 Jun '20

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msi/tests/db.c | 6 ++++++ 1 file changed, 6 insertions(+)

2 1

[PATCH 3/8 v2] msi: Remove ref_count from MSICOLUMNINFO.
by Piotr Caban 30 Jun '20

30 Jun '20

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msi/alter.c | 6 +++--- dlls/msi/table.c | 50 ++++++++++++++++-------------------------------- 2 files changed, 19 insertions(+), 37 deletions(-)

2 1

[PATCH 2/8 v2] msi: Fix table ref count on create.
by Piotr Caban 30 Jun '20

30 Jun '20

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- dlls/msi/create.c | 2 +- dlls/msi/query.h | 2 +- dlls/msi/table.c | 7 +++++-- 3 files changed, 7 insertions(+), 4 deletions(-)

2 1

[PATCH 1/8 v2] msi: Support removing temporary columns in TABLE_remove_column.
by Piotr Caban 30 Jun '20

30 Jun '20

Signed-off-by: Piotr Caban <piotr(a)codeweavers.com> --- v2: - patches 1-6 are the same as in v1 - last 2 patches get rid of temporary field instead of using it more dlls/msi/table.c | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-)

2 1

[PATCH 1/5] user32/tests: Add GetRawInputBuffer tests.
by Rémi Bernon 30 Jun '20

30 Jun '20

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- This should apply and work independently from the other server rawinput patch series.. dlls/user32/tests/input.c | 247 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 247 insertions(+) diff --git a/dlls/user32/tests/input.c b/dlls/user32/tests/input.c index 3dde3ce3c08..8b98c3f5c57 100644 --- a/dlls/user32/tests/input.c +++ b/dlls/user32/tests/input.c @@ -82,6 +82,7 @@ static int (WINAPI *pGetMouseMovePointsEx) (UINT, LPMOUSEMOVEPOINT, LPMOUSEMOVEP static UINT (WINAPI *pGetRawInputDeviceList) (PRAWINPUTDEVICELIST, PUINT, UINT); static UINT (WINAPI *pGetRawInputDeviceInfoW) (HANDLE, UINT, void *, UINT *); static UINT (WINAPI *pGetRawInputDeviceInfoA) (HANDLE, UINT, void *, UINT *); +static BOOL (WINAPI *pIsWow64Process)(HANDLE, PBOOL); #define MAXKEYEVENTS 12 #define MAXKEYMESSAGES MAXKEYEVENTS /* assuming a key event generates one @@ -144,6 +145,7 @@ static BYTE InputKeyStateTable[256]; static BYTE AsyncKeyStateTable[256]; static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP or a WM_KEYUP message */ +static BOOL is_wow64; static void init_function_pointers(void) { @@ -159,7 +161,13 @@ static void init_function_pointers(void) GET_PROC(GetRawInputDeviceList); GET_PROC(GetRawInputDeviceInfoW); GET_PROC(GetRawInputDeviceInfoA); + + hdll = GetModuleHandleA("kernel32"); + GET_PROC(IsWow64Process); #undef GET_PROC + + if (!pIsWow64Process || !pIsWow64Process( GetCurrentProcess(), &is_wow64 )) + is_wow64 = FALSE; } static int KbdMessage( KEV kev, WPARAM *pwParam, LPARAM *plParam ) @@ -1819,6 +1827,244 @@ static void test_RegisterRawInputDevices(void) DestroyWindow(hwnd); } +static int rawinputbuffer_wndproc_count; + +#ifdef _WIN64 +typedef RAWINPUT RAWINPUT64; +#else +typedef struct +{ + RAWINPUTHEADER header; + char pad[8]; + union { + RAWMOUSE mouse; + RAWKEYBOARD keyboard; + RAWHID hid; + } data; +} RAWINPUT64; +#endif + +static int rawinput_buffer_mouse_x(void *buffer, size_t index) +{ + if (is_wow64) return ((RAWINPUT64 *)buffer)[index].data.mouse.lLastX; + return ((RAWINPUT *)buffer)[index].data.mouse.lLastX; +} + +static LRESULT CALLBACK rawinputbuffer_wndproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) +{ + RAWINPUT ri; + char buffer[16 * sizeof(RAWINPUT64)]; + UINT size, count, rawinput_size, iteration = rawinputbuffer_wndproc_count++; + MSG message; + + if (is_wow64) rawinput_size = sizeof(RAWINPUT64); + else rawinput_size = sizeof(RAWINPUT); + + if (msg == WM_INPUT) + { + count = GetRawInputBuffer(NULL, NULL, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == ~0U, "GetRawInputBuffer succeeded\n"); + + size = sizeof(buffer); + count = GetRawInputBuffer(NULL, &size, sizeof(RAWINPUTHEADER)); + ok(count == 0, "GetRawInputBuffer returned %u\n", count); + todo_wine + ok(size == rawinput_size, "GetRawInputBuffer returned unexpected size: %u\n", size); + + size = sizeof(buffer); + memset(buffer, 0, sizeof(buffer)); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == 3, "GetRawInputBuffer returned %u\n", count); + ok(size == sizeof(buffer), "GetRawInputBuffer returned unexpected size: %u\n", size); + todo_wine + ok(rawinput_buffer_mouse_x(buffer, 0) == 2, "Unexpected rawinput data: %d\n", rawinput_buffer_mouse_x(buffer, 0)); + todo_wine + ok(rawinput_buffer_mouse_x(buffer, 1) == 3, "Unexpected rawinput data: %d\n", rawinput_buffer_mouse_x(buffer, 1)); + todo_wine + ok(rawinput_buffer_mouse_x(buffer, 2) == 4, "Unexpected rawinput data: %d\n", rawinput_buffer_mouse_x(buffer, 2)); + + /* the first event should be removed by the next GetRawInputBuffer call + * and the others should do another round through the message loop but not more */ + if (iteration == 0) + { + mouse_event(MOUSEEVENTF_MOVE, 5, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 6, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 2, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 3, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 4, 0, 0, 0); + + /* even though rawinput_size is the minimum required size, + * it needs one more byte to return success */ + size = rawinput_size + 1; + memset(buffer, 0, sizeof(buffer)); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == 1, "GetRawInputBuffer returned %u\n", count); + todo_wine + ok(rawinput_buffer_mouse_x(buffer, 0) == 5, "Unexpected rawinput data: %d\n", rawinput_buffer_mouse_x(buffer, 0)); + + /* peek the messages now, they should still arrive in the correct order */ + while (PeekMessageA(&message, 0, WM_INPUT, WM_INPUT, PM_REMOVE)) DispatchMessageA(&message); + } + + /* reading the message data now should fail on the second iteration, the data + * from the first message has been overwritten. */ + size = sizeof(ri); + memset(&ri, 0, sizeof(ri)); + count = GetRawInputData((HRAWINPUT)lparam, RID_INPUT, &ri, &size, sizeof(RAWINPUTHEADER)); + if (iteration == 1) + { + ok(count == sizeof(ri), "GetRawInputData failed\n"); + todo_wine + ok(ri.data.mouse.lLastX == 6, "Unexpected rawinput data: %d\n", ri.data.mouse.lLastX); + } + else + { + todo_wine + ok(count == ~0U, "GetRawInputData succeeded\n"); + } + } + + return DefWindowProcA(hwnd, msg, wparam, lparam); +} + +static void test_GetRawInputBuffer(void) +{ + RAWINPUTDEVICE raw_devices[1]; + char buffer[16 * sizeof(RAWINPUT64)]; + UINT size, count, rawinput_size; + HWND hwnd; + BOOL ret; + + if (is_wow64) rawinput_size = sizeof(RAWINPUT64); + else rawinput_size = sizeof(RAWINPUT); + + hwnd = CreateWindowA("static", "static", WS_VISIBLE | WS_POPUP, + 100, 100, 100, 100, 0, NULL, NULL, NULL); + SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)rawinputbuffer_wndproc); + ok(hwnd != 0, "CreateWindow failed\n"); + empty_message_queue(); + + raw_devices[0].usUsagePage = 0x01; + raw_devices[0].usUsage = 0x02; + raw_devices[0].dwFlags = RIDEV_INPUTSINK; + raw_devices[0].hwndTarget = hwnd; + + SetLastError(0xdeadbeef); + ret = RegisterRawInputDevices(raw_devices, ARRAY_SIZE(raw_devices), sizeof(RAWINPUTDEVICE)); + ok(ret, "RegisterRawInputDevices failed\n"); + ok(GetLastError() == 0xdeadbeef, "RegisterRawInputDevices returned %08x\n", GetLastError()); + + SetLastError(0xdeadbeef); + count = GetRawInputBuffer(NULL, NULL, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == ~0U, "GetRawInputBuffer succeeded\n"); + todo_wine + ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetRawInputBuffer returned %08x\n", GetLastError()); + + size = sizeof(buffer); + count = GetRawInputBuffer(NULL, &size, sizeof(RAWINPUTHEADER)); + ok(count == 0U, "GetRawInputBuffer returned %u\n", count); + todo_wine + ok(size == 0U, "GetRawInputBuffer returned unexpected size: %u\n", size); + + size = 0; + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + ok(count == 0U, "GetRawInputBuffer returned %u\n", count); + ok(size == 0U, "GetRawInputBuffer returned unexpected size: %u\n", size); + + SetLastError(0xdeadbeef); + size = sizeof(buffer); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, 0); + todo_wine + ok(count == ~0U, "GetRawInputBuffer succeeded\n"); + todo_wine + ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetRawInputBuffer returned %08x\n", GetLastError()); + + size = sizeof(buffer); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + ok(count == 0U, "GetRawInputBuffer returned %u\n", count); + todo_wine + ok(size == 0U, "GetRawInputBuffer returned unexpected size: %u\n", size); + + mouse_event(MOUSEEVENTF_MOVE, 5, 0, 0, 0); + + SetLastError(0xdeadbeef); + size = 0; + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == ~0U, "GetRawInputBuffer succeeded\n"); + todo_wine + ok(size == rawinput_size, "GetRawInputBuffer returned unexpected size: %u\n", size); + todo_wine + ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetRawInputBuffer returned %08x\n", GetLastError()); + + size = 0; + count = GetRawInputBuffer(NULL, &size, sizeof(RAWINPUTHEADER)); + ok(count == 0, "GetRawInputBuffer returned %u\n", count); + todo_wine + ok(size == rawinput_size, "GetRawInputBuffer returned unexpected size: %u\n", size); + + SetLastError(0xdeadbeef); + size = sizeof(buffer); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, 0); + todo_wine + ok(count == ~0U, "GetRawInputBuffer succeeded\n"); + todo_wine + ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetRawInputBuffer returned %08x\n", GetLastError()); + + size = sizeof(buffer); + memset(buffer, 0, sizeof(buffer)); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == 1U, "GetRawInputBuffer returned %u\n", count); + ok(size == sizeof(buffer), "GetRawInputBuffer returned unexpected size: %u\n", size); + todo_wine + ok(rawinput_buffer_mouse_x(buffer, 0) == 5, "Unexpected rawinput data: %d\n", rawinput_buffer_mouse_x(buffer, 0)); + + + /* NOTE: calling with size == rawinput_size returns an error, */ + /* BUT it fills the buffer nonetheless and empties the internal buffer (!!) */ + mouse_event(MOUSEEVENTF_MOVE, 5, 0, 0, 0); + + SetLastError(0xdeadbeef); + size = rawinput_size; + memset(buffer, 0, sizeof(buffer)); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + todo_wine + ok(count == ~0U, "GetRawInputBuffer succeeded\n"); + todo_wine + ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "GetRawInputBuffer returned %08x\n", GetLastError()); + todo_wine + ok(rawinput_buffer_mouse_x(buffer, 0) == 5, "Unexpected rawinput data: %d\n", rawinput_buffer_mouse_x(buffer, 0)); + + size = sizeof(buffer); + count = GetRawInputBuffer((RAWINPUT*)buffer, &size, sizeof(RAWINPUTHEADER)); + ok(count == 0U, "GetRawInputBuffer returned %u\n", count); + + + rawinputbuffer_wndproc_count = 0; + mouse_event(MOUSEEVENTF_MOVE, 1, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 2, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 3, 0, 0, 0); + mouse_event(MOUSEEVENTF_MOVE, 4, 0, 0, 0); + empty_message_queue(); + todo_wine + ok(rawinputbuffer_wndproc_count == 2, "Spurious WM_INPUT messages\n"); + + raw_devices[0].dwFlags = RIDEV_REMOVE; + raw_devices[0].hwndTarget = 0; + + SetLastError(0xdeadbeef); + ret = RegisterRawInputDevices(raw_devices, ARRAY_SIZE(raw_devices), sizeof(RAWINPUTDEVICE)); + ok(ret, "RegisterRawInputDevices failed\n"); + ok(GetLastError() == 0xdeadbeef, "RegisterRawInputDevices returned %08x\n", GetLastError()); + + DestroyWindow(hwnd); +} + static BOOL rawinput_test_received_legacy; static BOOL rawinput_test_received_raw; static BOOL rawinput_test_received_rawfg; @@ -3417,6 +3663,7 @@ START_TEST(input) test_GetKeyState(); test_OemKeyScan(); test_GetRawInputData(); + test_GetRawInputBuffer(); test_RegisterRawInputDevices(); test_rawinput(argv[0]); -- 2.27.0

3 12

[PATCH vkd3d 6/6] vkd3d: Require VKD3D_API_VERSION_1_2 for version 1.1 root signatures.
by Henri Verbeet 30 Jun '20

30 Jun '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- libs/vkd3d/device.c | 2 ++ tests/vkd3d_api.c | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index c53856a..d88fde9 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2766,6 +2766,8 @@ static HRESULT STDMETHODCALLTYPE d3d12_device_CheckFeatureSupport(ID3D12Device * TRACE("Root signature requested %#x.\n", data->HighestVersion); data->HighestVersion = min(data->HighestVersion, D3D_ROOT_SIGNATURE_VERSION_1_1); + if (device->vkd3d_instance->api_version < VKD3D_API_VERSION_1_2) + data->HighestVersion = min(data->HighestVersion, D3D_ROOT_SIGNATURE_VERSION_1_0); TRACE("Root signature version %#x.\n", data->HighestVersion); return S_OK; diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index 13fa3d6..8195c06 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -1073,12 +1073,28 @@ static void test_formats(void) static void test_application_info(void) { + D3D12_FEATURE_DATA_ROOT_SIGNATURE root_signature; struct vkd3d_instance_create_info create_info; + struct vkd3d_device_create_info device_info; struct vkd3d_application_info app_info; struct vkd3d_instance *instance; + ID3D12Device *device; + unsigned int i; ULONG refcount; HRESULT hr; + static const struct + { + enum vkd3d_api_version api_version; + D3D_ROOT_SIGNATURE_VERSION rs_version; + } + root_signature_versions[] = + { + {VKD3D_API_VERSION_1_0, D3D_ROOT_SIGNATURE_VERSION_1_0}, + {VKD3D_API_VERSION_1_1, D3D_ROOT_SIGNATURE_VERSION_1_0}, + {VKD3D_API_VERSION_1_2, D3D_ROOT_SIGNATURE_VERSION_1_1}, + }; + app_info.type = VKD3D_STRUCTURE_TYPE_APPLICATION_INFO; app_info.next = NULL; app_info.engine_name = NULL; @@ -1113,6 +1129,44 @@ static void test_application_info(void) 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); + + device_info = device_default_create_info; + device_info.instance_create_info = &create_info; + for (i = 0; i < ARRAY_SIZE(root_signature_versions); ++i) + { + app_info.api_version = root_signature_versions[i].api_version; + hr = vkd3d_create_device(&device_info, &IID_ID3D12Device, (void **)&device); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + root_signature.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_0; + hr = ID3D12Device_CheckFeatureSupport(device, D3D12_FEATURE_ROOT_SIGNATURE, + &root_signature, sizeof(root_signature)); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ok(root_signature.HighestVersion == D3D_ROOT_SIGNATURE_VERSION_1_0, + "Got unexpected root signature feature version %#x.\n", root_signature.HighestVersion); + + root_signature.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1; + hr = ID3D12Device_CheckFeatureSupport(device, D3D12_FEATURE_ROOT_SIGNATURE, + &root_signature, sizeof(root_signature)); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ok(root_signature.HighestVersion == root_signature_versions[i].rs_version, + "Got unexpected root signature feature version %#x.\n", root_signature.HighestVersion); + + ID3D12Device_Release(device); + } + + create_info.next = NULL; + hr = vkd3d_create_device(&device_info, &IID_ID3D12Device, (void **)&device); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + + root_signature.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1; + hr = ID3D12Device_CheckFeatureSupport(device, D3D12_FEATURE_ROOT_SIGNATURE, + &root_signature, sizeof(root_signature)); + ok(hr == S_OK, "Got unexpected hr %#x.\n", hr); + ok(root_signature.HighestVersion == D3D_ROOT_SIGNATURE_VERSION_1_0, + "Got unexpected root signature feature version %#x.\n", root_signature.HighestVersion); + + ID3D12Device_Release(device); } static bool have_d3d12_device(void) -- 2.11.0

1 0

[PATCH vkd3d 5/6] vkd3d: Introduce API versions.
by Henri Verbeet 30 Jun '20

30 Jun '20

For backwards compatibility. Newer vkd3d versions may report more capabilities, but some of those may also require newer vkd3d APIs in order to use them. That's an issue for a vkd3d user like Wine, where reporting more capabilities may cause the application to try to use APIs that are not implemented in that version of Wine. Note that using ELF symbol versioning would have solved the issue for existing binaries compiled against older versions of vkd3d, but not for older source compiled against newer versions of vkd3d. Users of vkd3d-utils should define VKD3D_UTILS_API_VERSION to the vkd3d API version they wish to target. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- demos/demo_xcb.h | 1 + include/vkd3d.h | 9 +++++++++ include/vkd3d_utils.h | 8 +++++++- libs/vkd3d-utils/vkd3d_utils.map | 1 + libs/vkd3d-utils/vkd3d_utils_main.c | 21 +++++++++++++++++---- libs/vkd3d/device.c | 8 +++++++- libs/vkd3d/vkd3d_private.h | 1 + tests/d3d12_crosstest.h | 1 + tests/vkd3d_api.c | 8 ++++++++ 9 files changed, 52 insertions(+), 6 deletions(-) diff --git a/demos/demo_xcb.h b/demos/demo_xcb.h index 6fae790..6ce02ed 100644 --- a/demos/demo_xcb.h +++ b/demos/demo_xcb.h @@ -18,6 +18,7 @@ */ #define VK_USE_PLATFORM_XCB_KHR +#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_2 #include <vkd3d.h> #include <vkd3d_utils.h> #include <xcb/xcb_event.h> diff --git a/include/vkd3d.h b/include/vkd3d.h index e2d9ec8..0ef8105 100644 --- a/include/vkd3d.h +++ b/include/vkd3d.h @@ -51,6 +51,13 @@ enum vkd3d_structure_type VKD3D_FORCE_32_BIT_ENUM(VKD3D_STRUCTURE_TYPE), }; +enum vkd3d_api_version +{ + VKD3D_API_VERSION_1_0, + VKD3D_API_VERSION_1_1, + VKD3D_API_VERSION_1_2, +}; + typedef HRESULT (*PFN_vkd3d_signal_event)(HANDLE event); typedef void * (*PFN_vkd3d_thread)(void *data); @@ -98,6 +105,8 @@ struct vkd3d_application_info const char *engine_name; /* "vkd3d" if NULL */ uint32_t engine_version; /* vkd3d version if engine_name is NULL */ + + enum vkd3d_api_version api_version; }; struct vkd3d_device_create_info diff --git a/include/vkd3d_utils.h b/include/vkd3d_utils.h index 4a5ee5d..02687ed 100644 --- a/include/vkd3d_utils.h +++ b/include/vkd3d_utils.h @@ -21,6 +21,10 @@ #include <vkd3d.h> +#ifndef VKD3D_UTILS_API_VERSION +#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_0 +#endif + #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ @@ -36,13 +40,15 @@ HRESULT vkd3d_signal_event(HANDLE event); unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds); void vkd3d_destroy_event(HANDLE event); -HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, D3D_FEATURE_LEVEL feature_level, REFIID iid, void **device); +#define D3D12CreateDevice(a, b, c, d) D3D12CreateDeviceVKD3D(a, b, c, d, VKD3D_UTILS_API_VERSION) HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer); HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug); HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc, D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob); /* 1.2 */ +HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL feature_level, + REFIID iid, void **device, enum vkd3d_api_version api_version); HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer); HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, diff --git a/libs/vkd3d-utils/vkd3d_utils.map b/libs/vkd3d-utils/vkd3d_utils.map index 9d95a84..fb39124 100644 --- a/libs/vkd3d-utils/vkd3d_utils.map +++ b/libs/vkd3d-utils/vkd3d_utils.map @@ -2,6 +2,7 @@ VKD3D_1_0 { global: D3D12CreateDevice; + D3D12CreateDeviceVKD3D; D3D12CreateRootSignatureDeserializer; D3D12CreateVersionedRootSignatureDeserializer; D3D12GetDebugInterface; diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c index d06a750..c19fe7f 100644 --- a/libs/vkd3d-utils/vkd3d_utils_main.c +++ b/libs/vkd3d-utils/vkd3d_utils_main.c @@ -17,6 +17,7 @@ */ #include "vkd3d_utils_private.h" +#undef D3D12CreateDevice VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG"); @@ -27,8 +28,8 @@ HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug) return E_NOTIMPL; } -HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, - D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device) +HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, + REFIID iid, void **device, enum vkd3d_api_version api_version) { struct vkd3d_optional_instance_extensions_info optional_extensions_info; struct vkd3d_instance_create_info instance_create_info; @@ -47,15 +48,21 @@ HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, { VK_KHR_SWAPCHAIN_EXTENSION_NAME, }; + struct vkd3d_application_info application_info = + { + .type = VKD3D_STRUCTURE_TYPE_APPLICATION_INFO, + .api_version = api_version, + }; - TRACE("adapter %p, minimum_feature_level %#x, iid %s, device %p.\n", - adapter, minimum_feature_level, debugstr_guid(iid), device); + TRACE("adapter %p, minimum_feature_level %#x, iid %s, device %p, api_version %#x.\n", + adapter, minimum_feature_level, debugstr_guid(iid), device, api_version); if (adapter) FIXME("Ignoring adapter %p.\n", adapter); memset(&optional_extensions_info, 0, sizeof(optional_extensions_info)); optional_extensions_info.type = VKD3D_STRUCTURE_TYPE_OPTIONAL_INSTANCE_EXTENSIONS_INFO; + optional_extensions_info.next = &application_info; optional_extensions_info.extensions = optional_instance_extensions; optional_extensions_info.extension_count = ARRAY_SIZE(optional_instance_extensions); @@ -78,6 +85,12 @@ HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, return vkd3d_create_device(&device_create_info, iid, device); } +HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, + D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device) +{ + return D3D12CreateDeviceVKD3D(adapter, minimum_feature_level, iid, device, VKD3D_API_VERSION_1_0); +} + HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 437454d..c53856a 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -506,16 +506,21 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, application_info.pEngineName = PACKAGE_NAME; application_info.engineVersion = vkd3d_get_vk_version(); application_info.apiVersion = VK_API_VERSION_1_0; + instance->api_version = VKD3D_API_VERSION_1_0; if ((vkd3d_application_info = vkd3d_find_struct(create_info->next, APPLICATION_INFO))) { - application_info.pApplicationName = vkd3d_application_info->application_name; + if (vkd3d_application_info->application_name) + application_info.pApplicationName = vkd3d_application_info->application_name; + else if (vkd3d_get_program_name(application_name)) + application_info.pApplicationName = 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; } + instance->api_version = vkd3d_application_info->api_version; } else if (vkd3d_get_program_name(application_name)) { @@ -523,6 +528,7 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, } TRACE("Application: %s.\n", debugstr_a(application_info.pApplicationName)); + TRACE("vkd3d API version: %u.\n", instance->api_version); if (!(extensions = vkd3d_calloc(extension_count, sizeof(*extensions)))) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 97cae22..1c36b24 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -147,6 +147,7 @@ struct vkd3d_instance void *libvulkan; uint64_t config_flags; + enum vkd3d_api_version api_version; VkDebugReportCallbackEXT vk_debug_callback; diff --git a/tests/d3d12_crosstest.h b/tests/d3d12_crosstest.h index 7b59471..7ff835a 100644 --- a/tests/d3d12_crosstest.h +++ b/tests/d3d12_crosstest.h @@ -55,6 +55,7 @@ typedef int HRESULT; #ifdef _WIN32 # include "vkd3d_dxgi1_4.h" #else +# define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_2 # include <pthread.h> # include "vkd3d.h" # include "vkd3d_utils.h" diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index d4fe79a..13fa3d6 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -58,9 +58,16 @@ static HRESULT signal_event(HANDLE event) return S_OK; } +static const struct vkd3d_application_info instance_default_application_info = +{ + .type = VKD3D_STRUCTURE_TYPE_APPLICATION_INFO, + .api_version = VKD3D_API_VERSION_1_2, +}; + static const struct vkd3d_instance_create_info instance_default_create_info = { .type = VKD3D_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + .next = &instance_default_application_info, .wchar_size = sizeof(WCHAR), .pfn_signal_event = signal_event, }; @@ -1078,6 +1085,7 @@ static void test_application_info(void) app_info.engine_version = 0; app_info.application_name = NULL; app_info.application_version = 0; + app_info.api_version = VKD3D_API_VERSION_1_0; create_info = instance_default_create_info; create_info.next = &app_info; -- 2.11.0

1 0

[PATCH vkd3d 4/6] vkd3d-shader: Introduce struct vkd3d_shader_resource.
by Henri Verbeet 30 Jun '20

30 Jun '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- libs/vkd3d-shader/dxbc.c | 58 ++++++++++++++------------- libs/vkd3d-shader/spirv.c | 21 +++++----- libs/vkd3d-shader/trace.c | 32 ++++++++------- libs/vkd3d-shader/vkd3d_shader_main.c | 69 +++++++++++--------------------- libs/vkd3d-shader/vkd3d_shader_private.h | 16 +++++--- 5 files changed, 91 insertions(+), 105 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index de6aea3..6a63fd6 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -594,6 +594,7 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_semantic *semantic = &ins->declaration.semantic; enum vkd3d_sm4_resource_type resource_type; const DWORD *end = &tokens[token_count]; enum vkd3d_sm4_data_type data_type; @@ -604,15 +605,15 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, if (!resource_type || (resource_type >= ARRAY_SIZE(resource_type_table))) { FIXME("Unhandled resource type %#x.\n", resource_type); - ins->declaration.semantic.resource_type = VKD3D_SHADER_RESOURCE_NONE; + semantic->resource_type = VKD3D_SHADER_RESOURCE_NONE; } else { - ins->declaration.semantic.resource_type = resource_type_table[resource_type]; + semantic->resource_type = resource_type_table[resource_type]; } reg_data_type = opcode == VKD3D_SM4_OP_DCL_RESOURCE ? VKD3D_DATA_RESOURCE : VKD3D_DATA_UAV; - shader_sm4_read_dst_param(priv, &tokens, end, reg_data_type, &ins->declaration.semantic.reg); - ins->declaration.semantic.register_index = shader_sm4_map_resource_idx(&ins->declaration.semantic.reg.reg, priv); + shader_sm4_read_dst_param(priv, &tokens, end, reg_data_type, &semantic->resource.reg); + semantic->resource.register_index = shader_sm4_map_resource_idx(&semantic->resource.reg.reg, priv); components = *tokens++; if ((components & 0xfff0) != (components & 0xf) * 0x1110) @@ -622,17 +623,17 @@ static void shader_sm4_read_dcl_resource(struct vkd3d_shader_instruction *ins, if (!data_type || (data_type >= ARRAY_SIZE(data_type_table))) { FIXME("Unhandled data type %#x.\n", data_type); - ins->declaration.semantic.resource_data_type = VKD3D_DATA_FLOAT; + semantic->resource_data_type = VKD3D_DATA_FLOAT; } else { - ins->declaration.semantic.resource_data_type = data_type_table[data_type]; + semantic->resource_data_type = data_type_table[data_type]; } if (reg_data_type == VKD3D_DATA_UAV) ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.semantic.register_space); + shader_sm4_read_register_space(priv, &tokens, end, &semantic->resource.register_space); } static void shader_sm4_read_dcl_constant_buffer(struct vkd3d_shader_instruction *ins, @@ -869,29 +870,29 @@ static void shader_sm5_read_dcl_uav_raw(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_raw_resource *resource = &ins->declaration.raw_resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &ins->declaration.raw_resource.dst); - ins->declaration.raw_resource.register_index = shader_sm4_map_resource_idx( - &ins->declaration.raw_resource.dst.reg, priv); + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &resource->resource.reg); + resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.raw_resource.register_space); + shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); } static void shader_sm5_read_dcl_uav_structured(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_structured_resource *resource = &ins->declaration.structured_resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &ins->declaration.structured_resource.reg); - ins->declaration.structured_resource.register_index = shader_sm4_map_resource_idx( - &ins->declaration.structured_resource.reg.reg, priv); + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_UAV, &resource->resource.reg); + resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); ins->flags = (opcode_token & VKD3D_SM5_UAV_FLAGS_MASK) >> VKD3D_SM5_UAV_FLAGS_SHIFT; - ins->declaration.structured_resource.byte_stride = *tokens++; - if (ins->declaration.structured_resource.byte_stride % 4) - FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.structured_resource.byte_stride); - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.structured_resource.register_space); + resource->byte_stride = *tokens++; + if (resource->byte_stride % 4) + FIXME("Byte stride %u is not multiple of 4.\n", resource->byte_stride); + shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); } static void shader_sm5_read_dcl_tgsm_raw(struct vkd3d_shader_instruction *ins, @@ -920,26 +921,27 @@ static void shader_sm5_read_dcl_resource_structured(struct vkd3d_shader_instruct DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_structured_resource *resource = &ins->declaration.structured_resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &ins->declaration.structured_resource.reg); - ins->declaration.structured_resource.register_index = shader_sm4_map_resource_idx( - &ins->declaration.structured_resource.reg.reg, priv); - ins->declaration.structured_resource.byte_stride = *tokens++; - if (ins->declaration.structured_resource.byte_stride % 4) - FIXME("Byte stride %u is not multiple of 4.\n", ins->declaration.structured_resource.byte_stride); - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.structured_resource.register_space); + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &resource->resource.reg); + resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); + resource->byte_stride = *tokens++; + if (resource->byte_stride % 4) + FIXME("Byte stride %u is not multiple of 4.\n", resource->byte_stride); + shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); } static void shader_sm5_read_dcl_resource_raw(struct vkd3d_shader_instruction *ins, DWORD opcode, DWORD opcode_token, const DWORD *tokens, unsigned int token_count, struct vkd3d_sm4_data *priv) { + struct vkd3d_shader_raw_resource *resource = &ins->declaration.raw_resource; const DWORD *end = &tokens[token_count]; - shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &ins->declaration.dst); - ins->declaration.raw_resource.register_index = shader_sm4_map_resource_idx(&ins->declaration.dst.reg, priv); - shader_sm4_read_register_space(priv, &tokens, end, &ins->declaration.raw_resource.register_space); + shader_sm4_read_dst_param(priv, &tokens, end, VKD3D_DATA_RESOURCE, &resource->resource.reg); + resource->resource.register_index = shader_sm4_map_resource_idx(&resource->resource.reg.reg, priv); + shader_sm4_read_register_space(priv, &tokens, end, &resource->resource.register_space); } static void shader_sm5_read_sync(struct vkd3d_shader_instruction *ins, diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index f058c24..a04645c 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -5280,14 +5280,16 @@ static void vkd3d_dxbc_compiler_emit_combined_sampler_declarations(struct vkd3d_ } static void vkd3d_dxbc_compiler_emit_resource_declaration(struct vkd3d_dxbc_compiler *compiler, - const struct vkd3d_shader_register *reg, unsigned int register_space, unsigned int register_index, - enum vkd3d_shader_resource_type resource_type, enum vkd3d_data_type resource_data_type, - unsigned int structure_stride, bool raw) + const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type, + enum vkd3d_data_type resource_data_type, unsigned int structure_stride, bool raw) { uint32_t counter_type_id, type_id, ptr_type_id, var_id, counter_var_id = 0; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; SpvStorageClass storage_class = SpvStorageClassUniformConstant; + const struct vkd3d_shader_register *reg = &resource->reg.reg; const struct vkd3d_spirv_resource_type *resource_type_info; + unsigned int register_space = resource->register_space; + unsigned int register_index = resource->register_index; enum vkd3d_component_type sampled_type; struct vkd3d_symbol resource_symbol; bool is_uav; @@ -5373,8 +5375,8 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource(struct vkd3d_dxbc_compiler *co if (instruction->flags) FIXME("Unhandled UAV flags %#x.\n", instruction->flags); - vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &semantic->reg.reg, semantic->register_space, - semantic->register_index, semantic->resource_type, semantic->resource_data_type, 0, false); + vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &semantic->resource, + semantic->resource_type, semantic->resource_data_type, 0, false); } static void vkd3d_dxbc_compiler_emit_dcl_resource_raw(struct vkd3d_dxbc_compiler *compiler, @@ -5385,22 +5387,21 @@ static void vkd3d_dxbc_compiler_emit_dcl_resource_raw(struct vkd3d_dxbc_compiler if (instruction->flags) FIXME("Unhandled UAV flags %#x.\n", instruction->flags); - vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &resource->dst.reg, resource->register_space, - resource->register_index, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, 0, true); + vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &resource->resource, + VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, 0, true); } static void vkd3d_dxbc_compiler_emit_dcl_resource_structured(struct vkd3d_dxbc_compiler *compiler, const struct vkd3d_shader_instruction *instruction) { const struct vkd3d_shader_structured_resource *resource = &instruction->declaration.structured_resource; - const struct vkd3d_shader_register *reg = &resource->reg.reg; unsigned int stride = resource->byte_stride; if (instruction->flags) FIXME("Unhandled UAV flags %#x.\n", instruction->flags); - vkd3d_dxbc_compiler_emit_resource_declaration(compiler, reg, resource->register_space, - resource->register_index, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, stride / 4, false); + vkd3d_dxbc_compiler_emit_resource_declaration(compiler, &resource->resource, + VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_DATA_UINT, stride / 4, false); } static void vkd3d_dxbc_compiler_emit_workgroup_memory(struct vkd3d_dxbc_compiler *compiler, diff --git a/libs/vkd3d-shader/trace.c b/libs/vkd3d-shader/trace.c index 1b59e4c..8ea2d0c 100644 --- a/libs/vkd3d-shader/trace.c +++ b/libs/vkd3d-shader/trace.c @@ -569,7 +569,7 @@ static void shader_dump_decl_usage(struct vkd3d_string_buffer *buffer, { shader_addline(buffer, "dcl"); - if (semantic->reg.reg.type == VKD3DSPR_SAMPLER) + if (semantic->resource.reg.reg.type == VKD3DSPR_SAMPLER) { switch (semantic->resource_type) { @@ -590,9 +590,9 @@ static void shader_dump_decl_usage(struct vkd3d_string_buffer *buffer, break; } } - else if (semantic->reg.reg.type == VKD3DSPR_RESOURCE || semantic->reg.reg.type == VKD3DSPR_UAV) + else if (semantic->resource.reg.reg.type == VKD3DSPR_RESOURCE || semantic->resource.reg.reg.type == VKD3DSPR_UAV) { - if (semantic->reg.reg.type == VKD3DSPR_RESOURCE) + if (semantic->resource.reg.reg.type == VKD3DSPR_RESOURCE) shader_addline(buffer, "_resource_"); else shader_addline(buffer, "_uav_"); @@ -642,7 +642,7 @@ static void shader_dump_decl_usage(struct vkd3d_string_buffer *buffer, shader_addline(buffer, "unknown"); break; } - if (semantic->reg.reg.type == VKD3DSPR_UAV) + if (semantic->resource.reg.reg.type == VKD3DSPR_UAV) shader_dump_uav_flags(buffer, flags); switch (semantic->resource_data_type) { @@ -1361,10 +1361,10 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer, case VKD3DSIH_DCL: case VKD3DSIH_DCL_UAV_TYPED: shader_dump_decl_usage(buffer, &ins->declaration.semantic, ins->flags, shader_version); - shader_dump_ins_modifiers(buffer, &ins->declaration.semantic.reg); + shader_dump_ins_modifiers(buffer, &ins->declaration.semantic.resource.reg); shader_addline(buffer, " "); - shader_dump_dst_param(buffer, &ins->declaration.semantic.reg, shader_version); - shader_dump_register_space(buffer, ins->declaration.semantic.register_space, shader_version); + shader_dump_dst_param(buffer, &ins->declaration.semantic.resource.reg, shader_version); + shader_dump_register_space(buffer, ins->declaration.semantic.resource.register_space, shader_version); break; case VKD3DSIH_DCL_CONSTANT_BUFFER: @@ -1469,15 +1469,16 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer, case VKD3DSIH_DCL_RESOURCE_RAW: shader_addline(buffer, "%s ", shader_opcode_names[ins->handler_idx]); - shader_dump_dst_param(buffer, &ins->declaration.raw_resource.dst, shader_version); - shader_dump_register_space(buffer, ins->declaration.raw_resource.register_space, shader_version); + shader_dump_dst_param(buffer, &ins->declaration.raw_resource.resource.reg, shader_version); + shader_dump_register_space(buffer, ins->declaration.raw_resource.resource.register_space, shader_version); break; case VKD3DSIH_DCL_RESOURCE_STRUCTURED: shader_addline(buffer, "%s ", shader_opcode_names[ins->handler_idx]); - shader_dump_dst_param(buffer, &ins->declaration.structured_resource.reg, shader_version); + shader_dump_dst_param(buffer, &ins->declaration.structured_resource.resource.reg, shader_version); shader_addline(buffer, ", %u", ins->declaration.structured_resource.byte_stride); - shader_dump_register_space(buffer, ins->declaration.structured_resource.register_space, shader_version); + shader_dump_register_space(buffer, + ins->declaration.structured_resource.resource.register_space, shader_version); break; case VKD3DSIH_DCL_SAMPLER: @@ -1537,17 +1538,18 @@ static void shader_dump_instruction(struct vkd3d_string_buffer *buffer, shader_addline(buffer, "%s", shader_opcode_names[ins->handler_idx]); shader_dump_uav_flags(buffer, ins->flags); shader_addline(buffer, " "); - shader_dump_dst_param(buffer, &ins->declaration.raw_resource.dst, shader_version); - shader_dump_register_space(buffer, ins->declaration.raw_resource.register_space, shader_version); + shader_dump_dst_param(buffer, &ins->declaration.raw_resource.resource.reg, shader_version); + shader_dump_register_space(buffer, ins->declaration.raw_resource.resource.register_space, shader_version); break; case VKD3DSIH_DCL_UAV_STRUCTURED: shader_addline(buffer, "%s", shader_opcode_names[ins->handler_idx]); shader_dump_uav_flags(buffer, ins->flags); shader_addline(buffer, " "); - shader_dump_dst_param(buffer, &ins->declaration.structured_resource.reg, shader_version); + shader_dump_dst_param(buffer, &ins->declaration.structured_resource.resource.reg, shader_version); shader_addline(buffer, ", %u", ins->declaration.structured_resource.byte_stride); - shader_dump_register_space(buffer, ins->declaration.structured_resource.register_space, shader_version); + shader_dump_register_space(buffer, + ins->declaration.structured_resource.resource.register_space, shader_version); break; case VKD3DSIH_DEF: diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 0ef3035..b9caac7 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -320,16 +320,28 @@ static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_conte } static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_context *context, - const struct vkd3d_shader_instruction *instruction) + const struct vkd3d_shader_resource *resource, enum vkd3d_shader_resource_type resource_type, + enum vkd3d_shader_resource_data_type resource_data_type) { - const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic; - enum vkd3d_shader_resource_data_type resource_data_type; enum vkd3d_shader_descriptor_type type; - if (semantic->reg.reg.type == VKD3DSPR_UAV) + if (resource->reg.reg.type == VKD3DSPR_UAV) type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV; else type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; + vkd3d_shader_scan_add_descriptor(context, type, resource->register_space, + resource->register_index, resource_type, resource_data_type, 0); + if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV) + vkd3d_shader_scan_add_uav_range(context, resource->reg.reg.idx[0].offset, + context->scan_info->descriptor_count - 1); +} + +static void vkd3d_shader_scan_typed_resource_declaration(struct vkd3d_shader_scan_context *context, + const struct vkd3d_shader_instruction *instruction) +{ + const struct vkd3d_shader_semantic *semantic = &instruction->declaration.semantic; + enum vkd3d_shader_resource_data_type resource_data_type; + switch (semantic->resource_data_type) { case VKD3D_DATA_UNORM: @@ -352,45 +364,8 @@ static void vkd3d_shader_scan_resource_declaration(struct vkd3d_shader_scan_cont resource_data_type = VKD3D_SHADER_RESOURCE_DATA_FLOAT; break; } - vkd3d_shader_scan_add_descriptor(context, type, semantic->register_space, - semantic->register_index, semantic->resource_type, resource_data_type, 0); - if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV) - vkd3d_shader_scan_add_uav_range(context, semantic->reg.reg.idx[0].offset, - context->scan_info->descriptor_count - 1); -} - -static void vkd3d_shader_scan_resource_declaration_raw(struct vkd3d_shader_scan_context *context, - const struct vkd3d_shader_instruction *instruction) -{ - const struct vkd3d_shader_raw_resource *resource = &instruction->declaration.raw_resource; - enum vkd3d_shader_descriptor_type type; - - if (resource->dst.reg.type == VKD3DSPR_UAV) - type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV; - else - type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; - vkd3d_shader_scan_add_descriptor(context, type, resource->register_space, - resource->register_index, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0); - if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV) - vkd3d_shader_scan_add_uav_range(context, resource->dst.reg.idx[0].offset, - context->scan_info->descriptor_count - 1); -} - -static void vkd3d_shader_scan_resource_declaration_structured(struct vkd3d_shader_scan_context *context, - const struct vkd3d_shader_instruction *instruction) -{ - const struct vkd3d_shader_structured_resource *resource = &instruction->declaration.structured_resource; - enum vkd3d_shader_descriptor_type type; - - if (resource->reg.reg.type == VKD3DSPR_UAV) - type = VKD3D_SHADER_DESCRIPTOR_TYPE_UAV; - else - type = VKD3D_SHADER_DESCRIPTOR_TYPE_SRV; - vkd3d_shader_scan_add_descriptor(context, type, resource->register_space, - resource->register_index, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0); - if (type == VKD3D_SHADER_DESCRIPTOR_TYPE_UAV) - vkd3d_shader_scan_add_uav_range(context, resource->reg.reg.idx[0].offset, - context->scan_info->descriptor_count - 1); + vkd3d_shader_scan_resource_declaration(context, &semantic->resource, + semantic->resource_type, resource_data_type); } static void vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *context, @@ -408,15 +383,17 @@ static void vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *cont break; case VKD3DSIH_DCL: case VKD3DSIH_DCL_UAV_TYPED: - vkd3d_shader_scan_resource_declaration(context, instruction); + vkd3d_shader_scan_typed_resource_declaration(context, instruction); break; case VKD3DSIH_DCL_RESOURCE_RAW: case VKD3DSIH_DCL_UAV_RAW: - vkd3d_shader_scan_resource_declaration_raw(context, instruction); + vkd3d_shader_scan_resource_declaration(context, &instruction->declaration.raw_resource.resource, + VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT); break; case VKD3DSIH_DCL_RESOURCE_STRUCTURED: case VKD3DSIH_DCL_UAV_STRUCTURED: - vkd3d_shader_scan_resource_declaration_structured(context, instruction); + vkd3d_shader_scan_resource_declaration(context, &instruction->declaration.structured_resource.resource, + VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT); break; default: break; diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index a9a0c52..e4ff267 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -574,6 +574,13 @@ struct vkd3d_shader_index_range unsigned int register_count; }; +struct vkd3d_shader_resource +{ + struct vkd3d_shader_dst_param reg; + unsigned int register_space; + unsigned int register_index; +}; + enum vkd3d_decl_usage { VKD3D_DECL_USAGE_POSITION = 0, @@ -598,8 +605,7 @@ struct vkd3d_shader_semantic unsigned int usage_idx; enum vkd3d_shader_resource_type resource_type; enum vkd3d_data_type resource_data_type; - struct vkd3d_shader_dst_param reg; - unsigned int register_space, register_index; + struct vkd3d_shader_resource resource; }; enum vkd3d_shader_input_sysval_semantic @@ -659,15 +665,13 @@ struct vkd3d_shader_constant_buffer struct vkd3d_shader_structured_resource { - struct vkd3d_shader_dst_param reg; + struct vkd3d_shader_resource resource; unsigned int byte_stride; - unsigned int register_space, register_index; }; struct vkd3d_shader_raw_resource { - struct vkd3d_shader_dst_param dst; - unsigned int register_space, register_index; + struct vkd3d_shader_resource resource; }; struct vkd3d_shader_tgsm -- 2.11.0

1 0

[PATCH vkd3d 3/6] vkd3d-shader: Support more than 8 UAV counters.
by Henri Verbeet 30 Jun '20

30 Jun '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- include/vkd3d_shader.h | 3 --- libs/vkd3d/command.c | 30 ++++++++++++++++++++++++------ libs/vkd3d/vkd3d_private.h | 3 ++- 3 files changed, 26 insertions(+), 10 deletions(-) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index e7bb925..701a312 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -582,9 +582,6 @@ struct vkd3d_versioned_root_signature_desc } u; }; -/* FIXME: Add support for 64 UAV bind slots. */ -#define VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS 8 - enum vkd3d_shader_resource_type { VKD3D_SHADER_RESOURCE_NONE = 0x0, diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 647431a..e5c6791 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -1865,7 +1865,11 @@ static void d3d12_command_list_invalidate_bindings(struct d3d12_command_list *li if (state && state->uav_counter_count) { enum vkd3d_pipeline_bind_point bind_point = (enum vkd3d_pipeline_bind_point)state->vk_bind_point; - list->pipeline_bindings[bind_point].uav_counters_dirty = true; + struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; + + vkd3d_array_reserve((void **)&bindings->vk_uav_counter_views, &bindings->vk_uav_counter_views_size, + state->uav_counter_count, sizeof(*bindings->vk_uav_counter_views)); + bindings->uav_counters_dirty = true; } } @@ -2190,6 +2194,11 @@ static ULONG STDMETHODCALLTYPE d3d12_command_list_AddRef(ID3D12GraphicsCommandLi return refcount; } +static void vkd3d_pipeline_bindings_cleanup(struct vkd3d_pipeline_bindings *bindings) +{ + vkd3d_free(bindings->vk_uav_counter_views); +} + static ULONG STDMETHODCALLTYPE d3d12_command_list_Release(ID3D12GraphicsCommandList2 *iface) { struct d3d12_command_list *list = impl_from_ID3D12GraphicsCommandList2(iface); @@ -2207,6 +2216,9 @@ static ULONG STDMETHODCALLTYPE d3d12_command_list_Release(ID3D12GraphicsCommandL if (list->allocator) d3d12_command_allocator_free_command_buffer(list->allocator, list); + vkd3d_pipeline_bindings_cleanup(&list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_COMPUTE]); + vkd3d_pipeline_bindings_cleanup(&list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_GRAPHICS]); + vkd3d_free(list); d3d12_device_release(device); @@ -2341,6 +2353,8 @@ static void d3d12_command_list_reset_state(struct d3d12_command_list *list, list->pso_render_pass = VK_NULL_HANDLE; list->current_render_pass = VK_NULL_HANDLE; + vkd3d_pipeline_bindings_cleanup(&list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_COMPUTE]); + vkd3d_pipeline_bindings_cleanup(&list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_GRAPHICS]); memset(list->pipeline_bindings, 0, sizeof(list->pipeline_bindings)); list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_GRAPHICS].vk_bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS; list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_COMPUTE].vk_bind_point = VK_PIPELINE_BIND_POINT_COMPUTE; @@ -2824,11 +2838,11 @@ done: static void d3d12_command_list_update_uav_counter_descriptors(struct d3d12_command_list *list, enum vkd3d_pipeline_bind_point bind_point) { - VkWriteDescriptorSet vk_descriptor_writes[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS]; struct vkd3d_pipeline_bindings *bindings = &list->pipeline_bindings[bind_point]; const struct vkd3d_vk_device_procs *vk_procs = &list->device->vk_procs; const struct d3d12_pipeline_state *state = list->state; VkDevice vk_device = list->device->vk_device; + VkWriteDescriptorSet *vk_descriptor_writes; VkDescriptorSet vk_descriptor_set; unsigned int uav_counter_count; unsigned int i; @@ -2837,11 +2851,10 @@ static void d3d12_command_list_update_uav_counter_descriptors(struct d3d12_comma return; uav_counter_count = state->uav_counter_count; - assert(uav_counter_count <= ARRAY_SIZE(vk_descriptor_writes)); - - vk_descriptor_set = d3d12_command_allocator_allocate_descriptor_set(list->allocator, state->vk_set_layout); - if (!vk_descriptor_set) + if (!(vk_descriptor_writes = vkd3d_calloc(uav_counter_count, sizeof(*vk_descriptor_writes)))) return; + if (!(vk_descriptor_set = d3d12_command_allocator_allocate_descriptor_set(list->allocator, state->vk_set_layout))) + goto done; for (i = 0; i < uav_counter_count; ++i) { @@ -2868,6 +2881,9 @@ static void d3d12_command_list_update_uav_counter_descriptors(struct d3d12_comma state->vk_pipeline_layout, state->set_index, 1, &vk_descriptor_set, 0, NULL)); bindings->uav_counters_dirty = false; + +done: + vkd3d_free(vk_descriptor_writes); } static void d3d12_command_list_update_descriptors(struct d3d12_command_list *list, @@ -5619,6 +5635,8 @@ static HRESULT d3d12_command_list_init(struct d3d12_command_list *list, struct d if (SUCCEEDED(hr = d3d12_command_allocator_allocate_command_buffer(allocator, list))) { + list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_GRAPHICS].vk_uav_counter_views = NULL; + list->pipeline_bindings[VKD3D_PIPELINE_BIND_POINT_COMPUTE].vk_uav_counter_views = NULL; d3d12_command_list_reset_state(list, initial_pipeline_state); } else diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index d7da7f1..97cae22 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -921,7 +921,8 @@ struct vkd3d_pipeline_bindings uint64_t descriptor_table_dirty_mask; uint64_t descriptor_table_active_mask; - VkBufferView vk_uav_counter_views[VKD3D_SHADER_MAX_UNORDERED_ACCESS_VIEWS]; + VkBufferView *vk_uav_counter_views; + size_t vk_uav_counter_views_size; bool uav_counters_dirty; /* Needed when VK_KHR_push_descriptor is not available. */ -- 2.11.0

1 0

[PATCH vkd3d 2/6] tests: Test using UAV counters with multiple register spaces.
by Henri Verbeet 30 Jun '20

30 Jun '20

From: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- tests/d3d12.c | 48 +++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 39 insertions(+), 9 deletions(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index c4ec41a..ec7be9d 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -32825,7 +32825,7 @@ static void test_write_buffer_immediate(void) static void test_register_space(void) { - ID3D12Resource *input_buffers[6], *output_buffers[8]; + ID3D12Resource *input_buffers[6], *output_buffers[8], *counter_buffers[2]; D3D12_ROOT_SIGNATURE_DESC root_signature_desc; D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc; D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc; @@ -32834,6 +32834,7 @@ static void test_register_space(void) ID3D12DescriptorHeap *heap; ID3D12CommandQueue *queue; ID3D12Device *device; + uint32_t counter; unsigned int i; HRESULT hr; @@ -32907,11 +32908,13 @@ static void test_register_space(void) u6[0] = t6.Load(0); u7[0] = c1; u8[0] = c2; + u7.IncrementCounter(); + u8.DecrementCounter(); } #endif - 0x43425844, 0x073b3de1, 0x527d26fc, 0xa46f417c, 0x4d9f338c, 0x00000001, 0x00000444, 0x00000003, + 0x43425844, 0x2a87323a, 0x4f83d345, 0x707e5d14, 0xdf41ce4a, 0x00000001, 0x00000474, 0x00000003, 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, - 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000003f0, 0x00050051, 0x000000fc, 0x0100086a, + 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x00000420, 0x00050051, 0x00000108, 0x0100086a, 0x07000059, 0x00308e46, 0x00000000, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x07000059, 0x00308e46, 0x00000001, 0x00000001, 0x00000001, 0x00000001, 0x00000002, 0x060000a1, 0x00307e46, 0x00000000, 0x00000001, 0x00000001, 0x00000001, 0x07000858, 0x00307e46, 0x00000001, 0x00000002, @@ -32923,8 +32926,8 @@ static void test_register_space(void) 0x00000002, 0x00000001, 0x0700089c, 0x0031ee46, 0x00000002, 0x00000003, 0x00000003, 0x00004444, 0x00000001, 0x0600009d, 0x0031ee46, 0x00000003, 0x00000001, 0x00000001, 0x00000002, 0x0600009d, 0x0031ee46, 0x00000004, 0x00000002, 0x00000002, 0x00000002, 0x0700089c, 0x0031ee46, 0x00000005, - 0x00000003, 0x00000003, 0x00004444, 0x00000002, 0x0700009e, 0x0031ee46, 0x00000006, 0x00000003, - 0x00000003, 0x00000004, 0x00000003, 0x0700009e, 0x0031ee46, 0x00000007, 0x00000003, 0x00000003, + 0x00000003, 0x00000003, 0x00004444, 0x00000002, 0x0780009e, 0x0031ee46, 0x00000006, 0x00000003, + 0x00000003, 0x00000004, 0x00000003, 0x0780009e, 0x0031ee46, 0x00000007, 0x00000003, 0x00000003, 0x00000004, 0x00000004, 0x02000068, 0x00000001, 0x0400009b, 0x00000001, 0x00000001, 0x00000001, 0x080000a5, 0x00100012, 0x00000000, 0x00004001, 0x00000000, 0x00207006, 0x00000003, 0x00000001, 0x080000a6, 0x0021e012, 0x00000000, 0x00000001, 0x00004001, 0x00000000, 0x0010000a, 0x00000000, @@ -32943,7 +32946,8 @@ static void test_register_space(void) 0x0c0000a8, 0x0021e012, 0x00000007, 0x00000003, 0x00004001, 0x00000000, 0x00004001, 0x00000000, 0x0030800a, 0x00000000, 0x00000001, 0x00000000, 0x0c0000a8, 0x0021e012, 0x00000006, 0x00000003, 0x00004001, 0x00000000, 0x00004001, 0x00000000, 0x0030800a, 0x00000001, 0x00000001, 0x00000000, - 0x0100003e, + 0x060000b2, 0x00100012, 0x00000000, 0x0021e000, 0x00000007, 0x00000003, 0x060000b3, 0x00100012, + 0x00000000, 0x0021e000, 0x00000006, 0x00000003, 0x0100003e, }; static const uint32_t srv_data[] = {100, 200, 300, 400, 500, 600}; @@ -32980,18 +32984,37 @@ static void test_register_space(void) get_cpu_descriptor_handle(&context, heap, i)); } + for (i = 0; i < ARRAY_SIZE(counter_buffers); ++i) + { + counter_buffers[i] = create_default_buffer(device, sizeof(uint32_t), + D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_DEST); + counter = 2; + upload_buffer_data(counter_buffers[i], 0, sizeof(counter), &counter, queue, command_list); + reset_command_list(command_list, context.allocator); + transition_sub_resource_state(command_list, counter_buffers[i], 0, + D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + } + for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) { output_buffers[i] = create_default_buffer(device, sizeof(uint32_t), D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); memset(&uav_desc, 0, sizeof(uav_desc)); - uav_desc.Format = DXGI_FORMAT_R32_UINT; uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER; uav_desc.Buffer.FirstElement = 0; uav_desc.Buffer.NumElements = 1; - ID3D12Device_CreateUnorderedAccessView(device, output_buffers[i], NULL, &uav_desc, - get_cpu_descriptor_handle(&context, heap, ARRAY_SIZE(input_buffers) + i)); + if (i < 6) + { + uav_desc.Format = DXGI_FORMAT_R32_UINT; + } + else + { + uav_desc.Format = DXGI_FORMAT_UNKNOWN; + uav_desc.Buffer.StructureByteStride = sizeof(uint32_t); + } + ID3D12Device_CreateUnorderedAccessView(device, output_buffers[i], i >= 6 ? counter_buffers[i - 6] : NULL, + &uav_desc, get_cpu_descriptor_handle(&context, heap, ARRAY_SIZE(input_buffers) + i)); } context.pipeline_state = create_compute_pipeline_state(device, context.root_signature, @@ -33014,10 +33037,17 @@ static void test_register_space(void) reset_command_list(command_list, context.allocator); } + counter = read_uav_counter(&context, counter_buffers[0], 0); + ok(counter == 3, "Got unexpected value %d.\n", counter); + counter = read_uav_counter(&context, counter_buffers[1], 0); + ok(counter == 1, "Got unexpected value %d.\n", counter); + for (i = 0; i < ARRAY_SIZE(input_buffers); ++i) ID3D12Resource_Release(input_buffers[i]); for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) ID3D12Resource_Release(output_buffers[i]); + for (i = 0; i < ARRAY_SIZE(counter_buffers); ++i) + ID3D12Resource_Release(counter_buffers[i]); ID3D12DescriptorHeap_Release(heap); destroy_test_context(&context); } -- 2.11.0

1 0

[PATCH vkd3d 1/6] vkd3d-shader: Get rid of the "use_vocp" field in the vkd3d_shader_scan_info structure.
by Henri Verbeet 30 Jun '20

30 Jun '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- include/vkd3d_shader.h | 2 -- libs/vkd3d-shader/spirv.c | 7 +++++-- libs/vkd3d-shader/vkd3d_shader_main.c | 12 ------------ 3 files changed, 5 insertions(+), 16 deletions(-) diff --git a/include/vkd3d_shader.h b/include/vkd3d_shader.h index e155663..e7bb925 100644 --- a/include/vkd3d_shader.h +++ b/include/vkd3d_shader.h @@ -640,8 +640,6 @@ struct vkd3d_shader_scan_info struct vkd3d_shader_descriptor_info *descriptors; unsigned int descriptor_count; - - bool use_vocp; }; enum vkd3d_component_type diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index 0baa191..f058c24 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -2106,6 +2106,7 @@ struct vkd3d_dxbc_compiler const struct vkd3d_shader_scan_info *scan_info; unsigned int input_control_point_count; unsigned int output_control_point_count; + bool use_vocp; unsigned int shader_phase_count; struct vkd3d_shader_phase *shader_phases; @@ -5456,6 +5457,9 @@ static void vkd3d_dxbc_compiler_emit_dcl_input(struct vkd3d_dxbc_compiler *compi vkd3d_dxbc_compiler_emit_input(compiler, dst, VKD3D_SIV_NONE, VKD3DSIM_NONE); else vkd3d_dxbc_compiler_emit_input_register(compiler, dst); + + if (dst->reg.type == VKD3DSPR_OUTCONTROLPOINT) + compiler->use_vocp = true; } static void vkd3d_dxbc_compiler_emit_dcl_input_ps(struct vkd3d_dxbc_compiler *compiler, @@ -5987,7 +5991,6 @@ static void vkd3d_dxbc_compiler_emit_hull_shader_barrier(struct vkd3d_dxbc_compi static void vkd3d_dxbc_compiler_emit_hull_shader_main(struct vkd3d_dxbc_compiler *compiler) { - const struct vkd3d_shader_scan_info *scan_info = compiler->scan_info; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; const struct vkd3d_shader_phase *control_point_phase, *phase; uint32_t phase_instance_id; @@ -6003,7 +6006,7 @@ static void vkd3d_dxbc_compiler_emit_hull_shader_main(struct vkd3d_dxbc_compiler else vkd3d_dxbc_compiler_emit_default_control_point_phase(compiler); - if (scan_info->use_vocp) + if (compiler->use_vocp) vkd3d_dxbc_compiler_emit_hull_shader_barrier(compiler); for (i = 0; i < compiler->shader_phase_count; ++i) diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index ed67350..0ef3035 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -305,15 +305,6 @@ static void vkd3d_shader_scan_constant_buffer_declaration(struct vkd3d_shader_sc cb->register_index, VKD3D_SHADER_RESOURCE_BUFFER, VKD3D_SHADER_RESOURCE_DATA_UINT, 0); } -static void vkd3d_shader_scan_input_declaration(struct vkd3d_shader_scan_info *scan_info, - const struct vkd3d_shader_instruction *instruction) -{ - const struct vkd3d_shader_dst_param *dst = &instruction->declaration.dst; - - if (dst->reg.type == VKD3DSPR_OUTCONTROLPOINT) - scan_info->use_vocp = true; -} - static void vkd3d_shader_scan_sampler_declaration(struct vkd3d_shader_scan_context *context, const struct vkd3d_shader_instruction *instruction) { @@ -412,9 +403,6 @@ static void vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *cont case VKD3DSIH_DCL_CONSTANT_BUFFER: vkd3d_shader_scan_constant_buffer_declaration(context, instruction); break; - case VKD3DSIH_DCL_INPUT: - vkd3d_shader_scan_input_declaration(context->scan_info, instruction); - break; case VKD3DSIH_DCL_SAMPLER: vkd3d_shader_scan_sampler_declaration(context, instruction); break; -- 2.11.0

1 0

[PATCH 2/2] winex11.drv: Use _GTK_WORKAREAS to get work areas if it is available.
by Zhiyi Zhang 30 Jun '20

30 Jun '20

_NET_WORKAREA reports a single rectangle as intersected work areas of all monitors. So work areas on non-primary monitors may be incorrect. For example, a dock only shown on the primary monitor reduces the work areas on non-primary monitors. There were attempts to extend _NET_WORKAREA to support work areas of multiple monitors but they were rejected as EWMH is no longer being maintained and _GTK_WORKAREAS was introduced instead. Fix Office 2010 missing title bar on non-primary monitors on GNOME. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- For the merge request to extend _NET_WORKAREA, see https://gitlab.freedesktop.org/xdg/xdg-specs/-/merge_requests/22 dlls/winex11.drv/display.c | 29 ++++++++++++++++++++++++++++- dlls/winex11.drv/x11drv.h | 1 + dlls/winex11.drv/x11drv_main.c | 1 + 3 files changed, 30 insertions(+), 1 deletion(-) diff --git a/dlls/winex11.drv/display.c b/dlls/winex11.drv/display.c index 625e8be4f47..262127367db 100644 --- a/dlls/winex11.drv/display.c +++ b/dlls/winex11.drv/display.c @@ -263,10 +263,37 @@ RECT get_work_area(RECT *monitor_rect) { Atom type; int format; - unsigned long count, remaining; + unsigned long count, remaining, i; long *work_area; RECT work_rect; + /* Try _GTK_WORKAREAS first as _NET_WORKAREA may be incorrect on multi-monitor systems */ + if (!XGetWindowProperty(gdi_display, DefaultRootWindow(gdi_display), + x11drv_atom(_GTK_WORKAREAS_D0), 0, ~0, False, XA_CARDINAL, &type, + &format, &count, &remaining, (unsigned char **)&work_area)) + { + if (type == XA_CARDINAL && format == 32 && count >= 4) + { + for (i = 0; i + 3 < count; i += 4) + { + work_rect.left = work_area[i * 4]; + work_rect.top = work_area[i * 4 + 1]; + work_rect.right = work_rect.left + work_area[i * 4 + 2]; + work_rect.bottom = work_rect.top + work_area[i * 4 + 3]; + + if (IntersectRect(&work_rect, &work_rect, monitor_rect)) + { + TRACE("work_rect:%s.\n", wine_dbgstr_rect(&work_rect)); + XFree(work_area); + return work_rect; + } + } + } + XFree(work_area); + } + + WARN("_GTK_WORKAREAS is not supported, fallback to _NET_WORKAREA. " + "Work areas may be incorrect on multi-monitor systems.\n"); if (!XGetWindowProperty(gdi_display, DefaultRootWindow(gdi_display), x11drv_atom(_NET_WORKAREA), 0, ~0, False, XA_CARDINAL, &type, &format, &count, &remaining, (unsigned char **)&work_area)) diff --git a/dlls/winex11.drv/x11drv.h b/dlls/winex11.drv/x11drv.h index bfc9aee027c..1efdac7064c 100644 --- a/dlls/winex11.drv/x11drv.h +++ b/dlls/winex11.drv/x11drv.h @@ -464,6 +464,7 @@ enum x11drv_atoms XATOM__NET_WM_WINDOW_TYPE_NORMAL, XATOM__NET_WM_WINDOW_TYPE_UTILITY, XATOM__NET_WORKAREA, + XATOM__GTK_WORKAREAS_D0, XATOM__XEMBED, XATOM__XEMBED_INFO, XATOM_XdndAware, diff --git a/dlls/winex11.drv/x11drv_main.c b/dlls/winex11.drv/x11drv_main.c index e6e61e801e1..9ec4c7a98f6 100644 --- a/dlls/winex11.drv/x11drv_main.c +++ b/dlls/winex11.drv/x11drv_main.c @@ -177,6 +177,7 @@ static const char * const atom_names[NB_XATOMS - FIRST_XATOM] = "_NET_WM_WINDOW_TYPE_NORMAL", "_NET_WM_WINDOW_TYPE_UTILITY", "_NET_WORKAREA", + "_GTK_WORKAREAS_D0", "_XEMBED", "_XEMBED_INFO", "XdndAware", -- 2.25.1

1 0

[PATCH 1/2] winex11.drv: Refactor query_work_area() to get intersected work area directly.
by Zhiyi Zhang 30 Jun '20

30 Jun '20

Refactor query_work_area() to pass in a monitor rectangle and check if the resulting work area intersects with the monitor rectangle in the function rather than doing it in the callers. Also move the function to display.c and rename it to get_work_area(). Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/winex11.drv/display.c | 32 ++++++++++++++++++++++++++++++++ dlls/winex11.drv/x11drv.h | 2 +- dlls/winex11.drv/xinerama.c | 30 +++--------------------------- dlls/winex11.drv/xrandr.c | 6 ++---- 4 files changed, 38 insertions(+), 32 deletions(-) diff --git a/dlls/winex11.drv/display.c b/dlls/winex11.drv/display.c index a6fe23ea68a..625e8be4f47 100644 --- a/dlls/winex11.drv/display.c +++ b/dlls/winex11.drv/display.c @@ -259,6 +259,38 @@ RECT get_host_primary_monitor_rect(void) return rect; } +RECT get_work_area(RECT *monitor_rect) +{ + Atom type; + int format; + unsigned long count, remaining; + long *work_area; + RECT work_rect; + + if (!XGetWindowProperty(gdi_display, DefaultRootWindow(gdi_display), x11drv_atom(_NET_WORKAREA), + 0, ~0, False, XA_CARDINAL, &type, &format, &count, &remaining, + (unsigned char **)&work_area)) + { + if (type == XA_CARDINAL && format == 32 && count >= 4) + { + SetRect(&work_rect, work_area[0], work_area[1], work_area[0] + work_area[2], + work_area[1] + work_area[3]); + + if (IntersectRect(&work_rect, &work_rect, monitor_rect)) + { + TRACE("work_rect:%s.\n", wine_dbgstr_rect(&work_rect)); + XFree(work_area); + return work_rect; + } + } + XFree(work_area); + } + + WARN("_NET_WORKAREA is not supported, Work areas may be incorrect.\n"); + TRACE("work_rect:%s.\n", wine_dbgstr_rect(monitor_rect)); + return *monitor_rect; +} + void X11DRV_DisplayDevices_SetHandler(const struct x11drv_display_device_handler *new_handler) { if (new_handler->priority > host_handler.priority) diff --git a/dlls/winex11.drv/x11drv.h b/dlls/winex11.drv/x11drv.h index cfce09bf11d..bfc9aee027c 100644 --- a/dlls/winex11.drv/x11drv.h +++ b/dlls/winex11.drv/x11drv.h @@ -645,7 +645,7 @@ extern POINT root_to_virtual_screen( INT x, INT y ) DECLSPEC_HIDDEN; extern RECT get_virtual_screen_rect(void) DECLSPEC_HIDDEN; extern RECT get_primary_monitor_rect(void) DECLSPEC_HIDDEN; extern RECT get_host_primary_monitor_rect(void) DECLSPEC_HIDDEN; -extern void query_work_area( RECT *rc_work ) DECLSPEC_HIDDEN; +extern RECT get_work_area( RECT *monitor_rect ) DECLSPEC_HIDDEN; extern void xinerama_init( unsigned int width, unsigned int height ) DECLSPEC_HIDDEN; struct x11drv_mode_info diff --git a/dlls/winex11.drv/xinerama.c b/dlls/winex11.drv/xinerama.c index 7e79fdeed77..c9863482534 100644 --- a/dlls/winex11.drv/xinerama.c +++ b/dlls/winex11.drv/xinerama.c @@ -54,26 +54,6 @@ static inline MONITORINFOEXW *get_primary(void) return &monitors[idx]; } -void query_work_area( RECT *rc_work ) -{ - Atom type; - int format; - unsigned long count, remaining; - long *work_area; - - if (!XGetWindowProperty( gdi_display, DefaultRootWindow(gdi_display), x11drv_atom(_NET_WORKAREA), 0, - ~0, False, XA_CARDINAL, &type, &format, &count, - &remaining, (unsigned char **)&work_area )) - { - if (type == XA_CARDINAL && format == 32 && count >= 4) - { - SetRect( rc_work, work_area[0], work_area[1], - work_area[0] + work_area[2], work_area[1] + work_area[3] ); - } - XFree( work_area ); - } -} - #ifdef SONAME_LIBXINERAMA #define MAKE_FUNCPTR(f) static typeof(f) * p##f @@ -100,13 +80,10 @@ static int query_screens(void) { int i, count, event_base, error_base; XineramaScreenInfo *screens; - RECT rc_work = {0, 0, 0, 0}; if (!monitors) /* first time around */ load_xinerama(); - query_work_area( &rc_work ); - if (!pXineramaQueryExtension || !pXineramaQueryScreens || !pXineramaQueryExtension( gdi_display, &event_base, &error_base ) || !(screens = pXineramaQueryScreens( gdi_display, &count ))) return 0; @@ -123,8 +100,7 @@ static int query_screens(void) monitors[i].rcMonitor.right = screens[i].x_org + screens[i].width; monitors[i].rcMonitor.bottom = screens[i].y_org + screens[i].height; monitors[i].dwFlags = 0; - if (!IntersectRect( &monitors[i].rcWork, &rc_work, &monitors[i].rcMonitor )) - monitors[i].rcWork = monitors[i].rcMonitor; + monitors[i].rcWork = get_work_area( &monitors[i].rcMonitor ); } get_primary()->dwFlags |= MONITORINFOF_PRIMARY; @@ -298,8 +274,8 @@ void xinerama_init( unsigned int width, unsigned int height ) SetRect( &rect, 0, 0, width, height ); if (!query_screens()) { - default_monitor.rcWork = default_monitor.rcMonitor = rect; - query_work_area( &default_monitor.rcWork ); + default_monitor.rcMonitor = rect; + default_monitor.rcWork = get_work_area( &default_monitor.rcMonitor ); nb_monitors = 1; monitors = &default_monitor; } diff --git a/dlls/winex11.drv/xrandr.c b/dlls/winex11.drv/xrandr.c index dce4e6739e4..14574e198f5 100644 --- a/dlls/winex11.drv/xrandr.c +++ b/dlls/winex11.drv/xrandr.c @@ -1054,7 +1054,7 @@ static BOOL xrandr14_get_monitors( ULONG_PTR adapter_id, struct x11drv_monitor * XRROutputInfo *output_info = NULL, *enum_output_info = NULL; XRRCrtcInfo *crtc_info = NULL, *enum_crtc_info; INT primary_index = 0, monitor_count = 0, capacity; - RECT work_rect, primary_rect; + RECT primary_rect; BOOL ret = FALSE; INT i; @@ -1089,7 +1089,6 @@ static BOOL xrandr14_get_monitors( ULONG_PTR adapter_id, struct x11drv_monitor * /* Active monitors, need to find other monitors with the same coordinates as mirrored */ else { - query_work_area( &work_rect ); primary_rect = get_primary_rect( screen_resources ); for (i = 0; i < screen_resources->noutput; ++i) @@ -1132,8 +1131,7 @@ static BOOL xrandr14_get_monitors( ULONG_PTR adapter_id, struct x11drv_monitor * SetRect( &monitors[monitor_count].rc_monitor, crtc_info->x, crtc_info->y, crtc_info->x + crtc_info->width, crtc_info->y + crtc_info->height ); - if (!IntersectRect( &monitors[monitor_count].rc_work, &work_rect, &monitors[monitor_count].rc_monitor )) - monitors[monitor_count].rc_work = monitors[monitor_count].rc_monitor; + monitors[monitor_count].rc_work = get_work_area( &monitors[monitor_count].rc_monitor ); monitors[monitor_count].state_flags = DISPLAY_DEVICE_ATTACHED; if (!IsRectEmpty( &monitors[monitor_count].rc_monitor )) -- 2.25.1

1 0

[PATCH] dxva2: Implement locking functionality in device manager.
by Nikolay Sivov 30 Jun '20

30 Jun '20

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/dxva2/main.c | 94 +++++++++++++++++++++++++++++++-- dlls/dxva2/tests/dxva2.c | 110 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 199 insertions(+), 5 deletions(-) diff --git a/dlls/dxva2/main.c b/dlls/dxva2/main.c index 4a51410d4b6..dd949b3d316 100644 --- a/dlls/dxva2/main.c +++ b/dlls/dxva2/main.c @@ -42,6 +42,7 @@ enum device_handle_flags struct device_handle { unsigned int flags; + IDirect3DStateBlock9 *state_block; }; struct device_manager @@ -57,7 +58,10 @@ struct device_manager size_t count; size_t capacity; + HANDLE locking_handle; + CRITICAL_SECTION cs; + CONDITION_VARIABLE lock; }; static BOOL dxva_array_reserve(void **elements, size_t *capacity, size_t count, size_t size) @@ -254,6 +258,7 @@ static ULONG WINAPI device_manager_Release(IDirect3DDeviceManager9 *iface) { struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface); ULONG refcount = InterlockedDecrement(&manager->refcount); + size_t i; TRACE("%p, refcount %u.\n", iface, refcount); @@ -262,6 +267,11 @@ static ULONG WINAPI device_manager_Release(IDirect3DDeviceManager9 *iface) if (manager->device) IDirect3DDevice9_Release(manager->device); DeleteCriticalSection(&manager->cs); + for (i = 0; i < manager->count; ++i) + { + if (manager->handles[i].state_block) + IDirect3DStateBlock9_Release(manager->handles[i].state_block); + } heap_free(manager->handles); heap_free(manager); } @@ -284,13 +294,21 @@ static HRESULT WINAPI device_manager_ResetDevice(IDirect3DDeviceManager9 *iface, if (manager->device) { for (i = 0; i < manager->count; ++i) + { + if (manager->handles[i].state_block) + IDirect3DStateBlock9_Release(manager->handles[i].state_block); + manager->handles[i].state_block = NULL; manager->handles[i].flags |= HANDLE_FLAG_INVALID; + } + manager->locking_handle = NULL; IDirect3DDevice9_Release(manager->device); } manager->device = device; IDirect3DDevice9_AddRef(manager->device); LeaveCriticalSection(&manager->cs); + WakeAllConditionVariable(&manager->lock); + return S_OK; } @@ -324,6 +342,7 @@ static HRESULT WINAPI device_manager_OpenDeviceHandle(IDirect3DDeviceManager9 *i { *hdevice = ULongToHandle(manager->count + 1); manager->handles[manager->count].flags |= HANDLE_FLAG_OPEN; + manager->handles[manager->count].state_block = NULL; manager->count++; } else @@ -355,15 +374,22 @@ static HRESULT WINAPI device_manager_CloseDeviceHandle(IDirect3DDeviceManager9 * { if (manager->handles[idx].flags & HANDLE_FLAG_OPEN) { + if (manager->locking_handle == hdevice) + manager->locking_handle = NULL; manager->handles[idx].flags = 0; if (idx == manager->count - 1) manager->count--; + if (manager->handles[idx].state_block) + IDirect3DStateBlock9_Release(manager->handles[idx].state_block); + manager->handles[idx].state_block = NULL; } else hr = E_HANDLE; } LeaveCriticalSection(&manager->cs); + WakeAllConditionVariable(&manager->lock); + return hr; } @@ -393,16 +419,75 @@ static HRESULT WINAPI device_manager_TestDevice(IDirect3DDeviceManager9 *iface, static HRESULT WINAPI device_manager_LockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice, IDirect3DDevice9 **device, BOOL block) { - FIXME("%p, %p, %p, %d.\n", iface, hdevice, device, block); + struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface); + HRESULT hr; + size_t idx; - return E_NOTIMPL; + TRACE("%p, %p, %p, %d.\n", iface, hdevice, device, block); + + EnterCriticalSection(&manager->cs); + if (!manager->device) + hr = DXVA2_E_NOT_INITIALIZED; + else if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx))) + { + if (manager->locking_handle && !block) + hr = DXVA2_E_VIDEO_DEVICE_LOCKED; + else + { + while (manager->locking_handle && block) + { + SleepConditionVariableCS(&manager->lock, &manager->cs, INFINITE); + } + + if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx))) + { + if (manager->handles[idx].flags & HANDLE_FLAG_INVALID) + hr = DXVA2_E_NEW_VIDEO_DEVICE; + else + { + if (manager->handles[idx].state_block) + { + if (FAILED(IDirect3DStateBlock9_Apply(manager->handles[idx].state_block))) + WARN("Failed to apply state.\n"); + IDirect3DStateBlock9_Release(manager->handles[idx].state_block); + manager->handles[idx].state_block = NULL; + } + *device = manager->device; + IDirect3DDevice9_AddRef(*device); + manager->locking_handle = hdevice; + } + } + } + } + LeaveCriticalSection(&manager->cs); + + return hr; } static HRESULT WINAPI device_manager_UnlockDevice(IDirect3DDeviceManager9 *iface, HANDLE hdevice, BOOL savestate) { - FIXME("%p, %p, %d.\n", iface, hdevice, savestate); + struct device_manager *manager = impl_from_IDirect3DDeviceManager9(iface); + HRESULT hr; + size_t idx; - return E_NOTIMPL; + TRACE("%p, %p, %d.\n", iface, hdevice, savestate); + + EnterCriticalSection(&manager->cs); + + if (hdevice != manager->locking_handle) + hr = E_INVALIDARG; + else if (SUCCEEDED(hr = device_manager_get_handle_index(manager, hdevice, &idx))) + { + manager->locking_handle = NULL; + if (savestate) + IDirect3DDevice9_CreateStateBlock(manager->device, D3DSBT_ALL, &manager->handles[idx].state_block); + } + + LeaveCriticalSection(&manager->cs); + + WakeAllConditionVariable(&manager->lock); + + return hr; } static HRESULT WINAPI device_manager_GetVideoService(IDirect3DDeviceManager9 *iface, HANDLE hdevice, REFIID riid, @@ -470,6 +555,7 @@ HRESULT WINAPI DXVA2CreateDirect3DDeviceManager9(UINT *token, IDirect3DDeviceMan object->refcount = 1; object->token = GetTickCount(); InitializeCriticalSection(&object->cs); + InitializeConditionVariable(&object->lock); *token = object->token; *manager = &object->IDirect3DDeviceManager9_iface; diff --git a/dlls/dxva2/tests/dxva2.c b/dlls/dxva2/tests/dxva2.c index e3e8dd2e66c..49b192a1fad 100644 --- a/dlls/dxva2/tests/dxva2.c +++ b/dlls/dxva2/tests/dxva2.c @@ -72,6 +72,7 @@ static void test_device_manager(void) HWND window; UINT token; HRESULT hr; + RECT rect; window = create_window(); d3d = Direct3DCreate9(D3D_SDK_VERSION); @@ -88,13 +89,15 @@ static void test_device_manager(void) hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle); ok(hr == DXVA2_E_NOT_INITIALIZED, "Unexpected hr %#x.\n", hr); + hr = IDirect3DDeviceManager9_LockDevice(manager, 0, &device2, FALSE); + ok(hr == DXVA2_E_NOT_INITIALIZED, "Unexpected hr %#x.\n", hr); + /* Invalid token. */ hr = IDirect3DDeviceManager9_ResetDevice(manager, device, token + 1); ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); hr = IDirect3DDeviceManager9_ResetDevice(manager, device, token); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); - refcount = get_refcount((IUnknown *)device); handle1 = NULL; @@ -140,6 +143,7 @@ static void test_device_manager(void) IDirectXVideoProcessorService_Release(processor_service); device2 = create_device(d3d, window); + hr = IDirect3DDeviceManager9_ResetDevice(manager, device2, token); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); @@ -150,6 +154,110 @@ static void test_device_manager(void) hr = IDirect3DDeviceManager9_TestDevice(manager, handle); ok(hr == DXVA2_E_NEW_VIDEO_DEVICE, "Unexpected hr %#x.\n", hr); + hr = IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + /* Lock/Unlock. */ + hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle, &device3, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(device2 == device3, "Unexpected device pointer.\n"); + IDirect3DDevice9_Release(device3); + + hr = IDirect3DDeviceManager9_UnlockDevice(manager, handle, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_UnlockDevice(manager, handle, FALSE); + ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_UnlockDevice(manager, (HANDLE)((ULONG_PTR)handle + 100), FALSE); + ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); + + /* Locked with one handle, unlock with another. */ + hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle, &device3, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(device2 == device3, "Unexpected device pointer.\n"); + IDirect3DDevice9_Release(device3); + + hr = IDirect3DDeviceManager9_UnlockDevice(manager, handle1, FALSE); + ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); + + /* Closing unlocks the device. */ + hr = IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle1, &device3, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(device2 == device3, "Unexpected device pointer.\n"); + IDirect3DDevice9_Release(device3); + + hr = IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + /* Open two handles. */ + hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle, &device3, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(device2 == device3, "Unexpected device pointer.\n"); + IDirect3DDevice9_Release(device3); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle1, &device3, FALSE); + ok(hr == DXVA2_E_VIDEO_DEVICE_LOCKED, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle1); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + /* State saving function. */ + hr = IDirect3DDeviceManager9_OpenDeviceHandle(manager, &handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle, &device3, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(device2 == device3, "Unexpected device pointer.\n"); + + SetRect(&rect, 50, 60, 70, 80); + hr = IDirect3DDevice9_SetScissorRect(device3, &rect); + ok(SUCCEEDED(hr), "Failed to set scissor rect, hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_UnlockDevice(manager, handle, TRUE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + SetRect(&rect, 30, 60, 70, 80); + hr = IDirect3DDevice9_SetScissorRect(device3, &rect); + ok(SUCCEEDED(hr), "Failed to set scissor rect, hr %#x.\n", hr); + + IDirect3DDevice9_Release(device3); + + hr = IDirect3DDeviceManager9_LockDevice(manager, handle, &device3, FALSE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(device2 == device3, "Unexpected device pointer.\n"); + + hr = IDirect3DDevice9_GetScissorRect(device3, &rect); + ok(SUCCEEDED(hr), "Failed to get scissor rect, hr %#x.\n", hr); + ok(rect.left == 50 && rect.top == 60 && rect.right == 70 && rect.bottom == 80, + "Got unexpected scissor rect %s.\n", wine_dbgstr_rect(&rect)); + + IDirect3DDevice9_Release(device3); + + hr = IDirect3DDeviceManager9_UnlockDevice(manager, handle, TRUE); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = IDirect3DDeviceManager9_CloseDeviceHandle(manager, handle); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + /* Acceleration service. */ hr = DXVA2CreateVideoService(device, &IID_IDirectXVideoAccelerationService, (void **)&accel_service); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); -- 2.27.0

1 0

TestBot vs. the power spike
by Francois Gouget 30 Jun '20

30 Jun '20

There was some sort of power spike and now the power is wonky including for the rack where the TestBot VM hosts are hosted :-(. So for now they are powered off until the power issues are sorted out. So if you wonder why the TestBot VMs are offline that's why. I'll post an update when we know more. -- Francois Gouget <fgouget(a)codeweavers.com>

1 1

[PATCH 0/6] Implement QueryDisplayConfig() and GetDisplayConfigBufferSizes().
by Brendan Shanks 30 Jun '20

30 Jun '20

Implement QueryDisplayConfig() and the closely related GetDisplayConfigBufferSizes(). Thanks to Zhiyi Zhang for reviewing earlier versions of this patchset. Brendan Shanks (6): include: Add d3dkmdt.h. user32/tests: Mark DisplayConfigGetDeviceInfo() tests returning success as todo_wine. user32: Implement GetDisplayConfigBufferSizes(). user32/tests: Test additional flag values with GetDisplayConfigBufferSizes(). user32: Implement QueryDisplayConfig(). user32/tests: Add more QueryDisplayConfig() tests. dlls/user32/sysparams.c | 287 +++++++++++++++++++++++++++++++++++- dlls/user32/tests/monitor.c | 92 ++++++++++-- include/Makefile.in | 1 + include/d3dkmdt.h | 59 ++++++++ 4 files changed, 422 insertions(+), 17 deletions(-) create mode 100644 include/d3dkmdt.h -- 2.26.2

2 7

[PATCH] msvcrt: Print assertion failure messages to stderr.
by Zebediah Figura 30 Jun '20

30 Jun '20

This matches Windows behaviour. In particular, redirecting stderr with freopen() followed by assert(0) will print the failure message to the relevant file. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- The motivation for this patch is that WriteConsoleW() and therefore _cwprintf() consistently swallow messages when I try to run Wine tests. I don't know if this is a bug, but it turns out there was an easier fix than trying to delve into console code... dlls/msvcrt/exit.c | 2 +- dlls/msvcrt/msvcrt.h | 3 +++ dlls/msvcrt/scanf.c | 2 -- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/dlls/msvcrt/exit.c b/dlls/msvcrt/exit.c index f631d4d727b..cb38b35de9a 100644 --- a/dlls/msvcrt/exit.c +++ b/dlls/msvcrt/exit.c @@ -305,7 +305,7 @@ void CDECL MSVCRT__wassert(const MSVCRT_wchar_t* str, const MSVCRT_wchar_t* file DoMessageBoxW(assertion_failed, text); } else - _cwprintf(format_console, str, file, line); + MSVCRT_fwprintf(MSVCRT_stderr, format_console, str, file, line); MSVCRT_raise(MSVCRT_SIGABRT); MSVCRT__exit(3); diff --git a/dlls/msvcrt/msvcrt.h b/dlls/msvcrt/msvcrt.h index 3ffc785d065..dc89c6af23e 100644 --- a/dlls/msvcrt/msvcrt.h +++ b/dlls/msvcrt/msvcrt.h @@ -447,6 +447,8 @@ struct MSVCRT__iobuf { typedef struct MSVCRT__iobuf MSVCRT_FILE; +extern MSVCRT_FILE MSVCRT__iob[]; + struct MSVCRT_lconv { char* decimal_point; char* thousands_sep; @@ -1107,6 +1109,7 @@ MSVCRT___time32_t __cdecl MSVCRT__time32(MSVCRT___time32_t*); MSVCRT___time64_t __cdecl MSVCRT__time64(MSVCRT___time64_t*); MSVCRT_FILE* __cdecl MSVCRT__fdopen(int, const char *); MSVCRT_FILE* __cdecl MSVCRT__wfdopen(int, const MSVCRT_wchar_t *); +int WINAPIV MSVCRT_fwprintf(MSVCRT_FILE *file, const MSVCRT_wchar_t *format, ...); int __cdecl MSVCRT_vsnprintf(char *str, MSVCRT_size_t len, const char *format, __ms_va_list valist); int __cdecl MSVCRT_vsnwprintf(MSVCRT_wchar_t *str, MSVCRT_size_t len, const MSVCRT_wchar_t *format, __ms_va_list valist ); diff --git a/dlls/msvcrt/scanf.c b/dlls/msvcrt/scanf.c index 04f87077e16..4b2ac2ed4a1 100644 --- a/dlls/msvcrt/scanf.c +++ b/dlls/msvcrt/scanf.c @@ -35,8 +35,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(msvcrt); -extern MSVCRT_FILE MSVCRT__iob[]; - /* helper function for *scanf. Returns the value of character c in the * given base, or -1 if the given character is not a digit of the base. */ -- 2.27.0

2 1

[PATCH] winegstreamer: Don't store DirectShow caps.
by Zebediah Figura 30 Jun '20

30 Jun '20

Primarily so that we can connect using video caps that can't be translated into DirectShow caps. They will later be converted into translatable caps once the DirectShow source pin is connected. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=47642 Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/winegstreamer/gstdemux.c | 162 ++++++++++++++++++++-------------- 1 file changed, 94 insertions(+), 68 deletions(-) diff --git a/dlls/winegstreamer/gstdemux.c b/dlls/winegstreamer/gstdemux.c index 8f89935b82..5697d2c0e0 100644 --- a/dlls/winegstreamer/gstdemux.c +++ b/dlls/winegstreamer/gstdemux.c @@ -78,7 +78,6 @@ struct gstdemux_source GstPad *their_src, *post_sink, *post_src, *my_sink; GstElement *flip; - AM_MEDIA_TYPE mt; HANDLE caps_event, eos_event; GstSegment *segment; SourceSeeking seek; @@ -99,15 +98,11 @@ static HRESULT WINAPI GST_ChangeCurrent(IMediaSeeking *iface); static HRESULT WINAPI GST_ChangeStop(IMediaSeeking *iface); static HRESULT WINAPI GST_ChangeRate(IMediaSeeking *iface); -static gboolean amt_from_gst_caps_audio_raw(const GstCaps *caps, AM_MEDIA_TYPE *amt) +static gboolean amt_from_gst_audio_info(const GstAudioInfo *info, AM_MEDIA_TYPE *amt) { WAVEFORMATEXTENSIBLE *wfe; WAVEFORMATEX *wfx; gint32 depth, bpp; - GstAudioInfo ainfo; - - if (!gst_audio_info_from_caps (&ainfo, caps)) - return FALSE; wfe = CoTaskMemAlloc(sizeof(*wfe)); wfx = (WAVEFORMATEX*)wfe; @@ -122,10 +117,10 @@ static gboolean amt_from_gst_caps_audio_raw(const GstCaps *caps, AM_MEDIA_TYPE * wfx->wFormatTag = WAVE_FORMAT_EXTENSIBLE; - wfx->nChannels = ainfo.channels; - wfx->nSamplesPerSec = ainfo.rate; - depth = GST_AUDIO_INFO_WIDTH(&ainfo); - bpp = GST_AUDIO_INFO_DEPTH(&ainfo); + wfx->nChannels = info->channels; + wfx->nSamplesPerSec = info->rate; + depth = GST_AUDIO_INFO_WIDTH(info); + bpp = GST_AUDIO_INFO_DEPTH(info); if (!depth || depth > 32 || depth % 8) depth = bpp; @@ -144,7 +139,8 @@ static gboolean amt_from_gst_caps_audio_raw(const GstCaps *caps, AM_MEDIA_TYPE * default: wfe->dwChannelMask = 0; } - if (GST_AUDIO_INFO_IS_FLOAT(&ainfo)) { + if (GST_AUDIO_INFO_IS_FLOAT(info)) + { amt->subtype = MEDIASUBTYPE_IEEE_FLOAT; wfe->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT; } else { @@ -207,7 +203,7 @@ static gboolean amt_from_gst_video_info(const GstVideoInfo *info, AM_MEDIA_TYPE bih->biBitCount = 16; break; default: - FIXME("Unhandled type %s.\n", GST_VIDEO_INFO_NAME(info)); + WARN("Cannot convert %s to a DirectShow type.\n", GST_VIDEO_INFO_NAME(info)); CoTaskMemFree(vih); return FALSE; } @@ -314,8 +310,16 @@ static gboolean amt_from_gst_caps(const GstCaps *caps, AM_MEDIA_TYPE *mt) const char *type = gst_structure_get_name(gst_caps_get_structure(caps, 0)); GstStructure *structure = gst_caps_get_structure(caps, 0); + memset(mt, 0, sizeof(AM_MEDIA_TYPE)); + if (!strcmp(type, "audio/x-raw")) - return amt_from_gst_caps_audio_raw(caps, mt); + { + GstAudioInfo info; + + if (!(gst_audio_info_from_caps(&info, caps))) + return FALSE; + return amt_from_gst_audio_info(&info, mt); + } else if (!strcmp(type, "video/x-raw")) { GstVideoInfo info; @@ -331,7 +335,6 @@ static gboolean amt_from_gst_caps(const GstCaps *caps, AM_MEDIA_TYPE *mt) VIDEOINFOHEADER *vih; gint i; - memset(mt, 0, sizeof(AM_MEDIA_TYPE)); mt->majortype = MEDIATYPE_Video; mt->subtype = MEDIASUBTYPE_CVID; mt->bTemporalCompression = TRUE; @@ -466,24 +469,6 @@ static GstCaps *amt_to_gst_caps(const AM_MEDIA_TYPE *mt) return NULL; } -static gboolean setcaps_sink(GstPad *pad, GstCaps *caps) -{ - struct gstdemux_source *pin = gst_pad_get_element_private(pad); - struct gstdemux *filter = impl_from_strmbase_filter(pin->pin.pin.filter); - gchar *caps_str = gst_caps_to_string(caps); - - TRACE("filter %p, caps %s.\n", filter, debugstr_a(caps_str)); - g_free(caps_str); - - FreeMediaType(&pin->mt); - - if (!amt_from_gst_caps(caps, &pin->mt)) - return FALSE; - - SetEvent(pin->caps_event); - return TRUE; -} - static gboolean query_sink(GstPad *pad, GstObject *parent, GstQuery *query) { struct gstdemux_source *pin = gst_pad_get_element_private(pad); @@ -662,6 +647,7 @@ static gboolean event_src(GstPad *pad, GstObject *parent, GstEvent *event) static gboolean event_sink(GstPad *pad, GstObject *parent, GstEvent *event) { struct gstdemux_source *pin = gst_pad_get_element_private(pad); + gboolean ret; TRACE("pin %p, type \"%s\".\n", pin, GST_EVENT_TYPE_NAME(event)); @@ -722,11 +708,10 @@ static gboolean event_sink(GstPad *pad, GstObject *parent, GstEvent *event) if (pin->pin.pin.peer) IPin_EndFlush(pin->pin.pin.peer); return TRUE; - case GST_EVENT_CAPS: { - GstCaps *caps; - gst_event_parse_caps(event, &caps); - return setcaps_sink(pad, caps); - } + case GST_EVENT_CAPS: + ret = gst_pad_event_default(pad, parent, event); + SetEvent(pin->caps_event); + return ret; default: WARN("Ignoring \"%s\" event.\n", GST_EVENT_TYPE_NAME(event)); return gst_pad_event_default(pad, parent, event); @@ -1678,6 +1663,10 @@ static HRESULT gstdecoder_source_query_accept(struct gstdemux_source *pin, const static HRESULT gstdecoder_source_get_media_type(struct gstdemux_source *pin, unsigned int index, AM_MEDIA_TYPE *mt) { + GstCaps *caps = gst_pad_get_current_caps(pin->my_sink); + const GstStructure *structure; + const char *type; + static const GstVideoFormat video_formats[] = { /* Try to prefer YUV formats over RGB ones. Most decoders output in the @@ -1695,42 +1684,48 @@ static HRESULT gstdecoder_source_get_media_type(struct gstdemux_source *pin, GST_VIDEO_FORMAT_BGR, }; - if (!index) + assert(caps); /* We shouldn't be able to get here if caps haven't been set. */ + structure = gst_caps_get_structure(caps, 0); + type = gst_structure_get_name(structure); + + memset(mt, 0, sizeof(AM_MEDIA_TYPE)); + + if (amt_from_gst_caps(caps, mt)) { - CopyMediaType(mt, &pin->mt); - return S_OK; + if (!index--) + { + gst_caps_unref(caps); + return S_OK; + } } - else if (IsEqualGUID(&pin->mt.majortype, &MEDIATYPE_Video) - && index - 1 < ARRAY_SIZE(video_formats)) + + if (!strcmp(type, "video/x-raw") && index < ARRAY_SIZE(video_formats)) { - const VIDEOINFOHEADER *vih = (VIDEOINFOHEADER *)pin->mt.pbFormat; + gint width, height; GstVideoInfo info; - gst_video_info_set_format(&info, video_formats[index - 1], - vih->bmiHeader.biWidth, vih->bmiHeader.biHeight); + gst_caps_unref(caps); + gst_structure_get_int(structure, "width", &width); + gst_structure_get_int(structure, "height", &height); + gst_video_info_set_format(&info, video_formats[index], width, height); if (!amt_from_gst_video_info(&info, mt)) return E_OUTOFMEMORY; return S_OK; } - else if (IsEqualGUID(&pin->mt.majortype, &MEDIATYPE_Audio) && index == 1) - { - const WAVEFORMATEX *our_format = (WAVEFORMATEX *)pin->mt.pbFormat; - WAVEFORMATEX *format; - - *mt = pin->mt; - mt->subtype = MEDIASUBTYPE_PCM; - mt->pbFormat = CoTaskMemAlloc(sizeof(WAVEFORMATEX)); - format = (WAVEFORMATEX *)mt->pbFormat; - format->wFormatTag = WAVE_FORMAT_PCM; - format->nChannels = 2; - format->nSamplesPerSec = our_format->nSamplesPerSec; - format->wBitsPerSample = 16; - format->nBlockAlign = 4; - format->nAvgBytesPerSec = format->nSamplesPerSec * 4; - format->cbSize = 0; + else if (!strcmp(type, "audio/x-raw") && !index) + { + GstAudioInfo info; + gint rate; + + gst_caps_unref(caps); + gst_structure_get_int(structure, "rate", &rate); + gst_audio_info_set_format(&info, GST_AUDIO_FORMAT_S16LE, rate, 2, NULL); + if (!amt_from_gst_audio_info(&info, mt)) + return E_OUTOFMEMORY; return S_OK; } + gst_caps_unref(caps); return VFW_S_NO_MORE_ITEMS; } @@ -2137,7 +2132,6 @@ static void free_source_pin(struct gstdemux_source *pin) gst_object_unref(pin->my_sink); CloseHandle(pin->caps_event); CloseHandle(pin->eos_event); - FreeMediaType(&pin->mt); gst_segment_free(pin->segment); strmbase_seeking_cleanup(&pin->seek); @@ -2394,9 +2388,24 @@ static BOOL wave_parser_init_gst(struct gstdemux *filter) return TRUE; } +static gboolean get_source_amt(const struct gstdemux_source *pin, AM_MEDIA_TYPE *mt) +{ + GstCaps *caps = gst_pad_get_current_caps(pin->my_sink); + gboolean ret = amt_from_gst_caps(caps, mt); + gst_caps_unref(caps); + return ret; +} + static HRESULT wave_parser_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt) { - return compare_media_types(mt, &pin->mt) ? S_OK : S_FALSE; + AM_MEDIA_TYPE pad_mt; + HRESULT hr; + + if (!get_source_amt(pin, &pad_mt)) + return E_OUTOFMEMORY; + hr = compare_media_types(mt, &pad_mt) ? S_OK : S_FALSE; + FreeMediaType(&pad_mt); + return hr; } static HRESULT wave_parser_source_get_media_type(struct gstdemux_source *pin, @@ -2404,7 +2413,8 @@ static HRESULT wave_parser_source_get_media_type(struct gstdemux_source *pin, { if (index > 0) return VFW_S_NO_MORE_ITEMS; - CopyMediaType(mt, &pin->mt); + if (!get_source_amt(pin, mt)) + return E_OUTOFMEMORY; return S_OK; } @@ -2507,7 +2517,14 @@ static BOOL avi_splitter_init_gst(struct gstdemux *filter) static HRESULT avi_splitter_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt) { - return compare_media_types(mt, &pin->mt) ? S_OK : S_FALSE; + AM_MEDIA_TYPE pad_mt; + HRESULT hr; + + if (!get_source_amt(pin, &pad_mt)) + return E_OUTOFMEMORY; + hr = compare_media_types(mt, &pad_mt) ? S_OK : S_FALSE; + FreeMediaType(&pad_mt); + return hr; } static HRESULT avi_splitter_source_get_media_type(struct gstdemux_source *pin, @@ -2515,7 +2532,8 @@ static HRESULT avi_splitter_source_get_media_type(struct gstdemux_source *pin, { if (index > 0) return VFW_S_NO_MORE_ITEMS; - CopyMediaType(mt, &pin->mt); + if (!get_source_amt(pin, mt)) + return E_OUTOFMEMORY; return S_OK; } @@ -2632,7 +2650,14 @@ static BOOL mpeg_splitter_init_gst(struct gstdemux *filter) static HRESULT mpeg_splitter_source_query_accept(struct gstdemux_source *pin, const AM_MEDIA_TYPE *mt) { - return compare_media_types(mt, &pin->mt) ? S_OK : S_FALSE; + AM_MEDIA_TYPE pad_mt; + HRESULT hr; + + if (!get_source_amt(pin, &pad_mt)) + return E_OUTOFMEMORY; + hr = compare_media_types(mt, &pad_mt) ? S_OK : S_FALSE; + FreeMediaType(&pad_mt); + return hr; } static HRESULT mpeg_splitter_source_get_media_type(struct gstdemux_source *pin, @@ -2640,7 +2665,8 @@ static HRESULT mpeg_splitter_source_get_media_type(struct gstdemux_source *pin, { if (index > 0) return VFW_S_NO_MORE_ITEMS; - CopyMediaType(mt, &pin->mt); + if (!get_source_amt(pin, mt)) + return E_OUTOFMEMORY; return S_OK; } -- 2.27.0

1 0

[tools] winetest: Add a script to test HTTP redirection limits.
by Owen Rudge 29 Jun '20

29 Jun '20

I've written patches to implement support for WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS in winhttp; this script will be required for the tests. Signed-off-by: Owen Rudge <orudge(a)codeweavers.com> --- winetest/tests/redirecttest.php | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 winetest/tests/redirecttest.php

1 0

[PATCH] netio.sys: Remove WINAPI on static functions where not needed.
by Francois Gouget 29 Jun '20

29 Jun '20

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/netio.sys/netio.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/netio.sys/netio.c b/dlls/netio.sys/netio.c index 53d74f994db..fe73b06b978 100644 --- a/dlls/netio.sys/netio.c +++ b/dlls/netio.sys/netio.c @@ -605,7 +605,7 @@ static void WINAPI send_receive_callback(TP_CALLBACK_INSTANCE *instance, void *s unlock_socket(socket); } -static NTSTATUS WINAPI do_send_receive(WSK_SOCKET *socket, WSK_BUF *wsk_buf, ULONG flags, IRP *irp, BOOL is_send) +static NTSTATUS do_send_receive(WSK_SOCKET *socket, WSK_BUF *wsk_buf, ULONG flags, IRP *irp, BOOL is_send) { struct wsk_socket_internal *s = wsk_socket_internal_from_wsk_socket(socket); struct wsk_pending_io *io; -- 2.20.1

3 3

[PATCH 1/6] user32/tests: Add basic GetRegisteredRawInputDevices tests.
by Rémi Bernon 29 Jun '20

29 Jun '20

There's already some in dinput, but this is a more appropriate location. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- With the Sekiro test from last time, but injecting 2kHz mouse events to better show the differences, brings the normal FPS from ~=50fps (the missing esync series hurts badly here) down to ~=20fps on average with some catch up moments, probably when LL hooks start to timeout in batch. Patch #4 helps by doing less work in the LL hooks and using rawinput messages instead, and bring it up to ~=30fps on average, but still with the catch up moments. And with patch #5 it holds the load much better, with a steady ~=45fps thanks to the ll-hook removal. dlls/user32/tests/input.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/dlls/user32/tests/input.c b/dlls/user32/tests/input.c index 3130f3987e3..0607f300871 100644 --- a/dlls/user32/tests/input.c +++ b/dlls/user32/tests/input.c @@ -1757,6 +1757,7 @@ static void test_RegisterRawInputDevices(void) { HWND hwnd; RAWINPUTDEVICE raw_devices[1]; + UINT count, raw_devices_count; BOOL res; raw_devices[0].usUsagePage = 0x01; @@ -1783,6 +1784,42 @@ static void test_RegisterRawInputDevices(void) ok(res == TRUE, "RegisterRawInputDevices failed\n"); ok(GetLastError() == 0xdeadbeef, "RegisterRawInputDevices returned %08x\n", GetLastError()); + SetLastError(0xdeadbeef); + count = GetRegisteredRawInputDevices(NULL, NULL, 0); + todo_wine + ok(count == ~0U, "GetRegisteredRawInputDevices returned %u\n", count); + todo_wine + ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetRegisteredRawInputDevices unexpected error %08x\n", GetLastError()); + + SetLastError(0xdeadbeef); + raw_devices_count = 0; + count = GetRegisteredRawInputDevices(NULL, &raw_devices_count, 0); + todo_wine + ok(count == ~0U, "GetRegisteredRawInputDevices returned %u\n", count); + ok(raw_devices_count == 0, "Unexpected registered devices count: %u\n", raw_devices_count); + todo_wine + ok(GetLastError() == ERROR_INVALID_PARAMETER, "GetRegisteredRawInputDevices unexpected error %08x\n", GetLastError()); + + SetLastError(0xdeadbeef); + raw_devices_count = 0; + count = GetRegisteredRawInputDevices(NULL, &raw_devices_count, sizeof(RAWINPUTDEVICE)); + ok(count == 0, "GetRegisteredRawInputDevices returned %u\n", count); + todo_wine + ok(raw_devices_count == 1, "Unexpected registered devices count: %u\n", raw_devices_count); + ok(GetLastError() == 0xdeadbeef, "GetRegisteredRawInputDevices unexpected error %08x\n", GetLastError()); + + SetLastError(0xdeadbeef); + memset(raw_devices, 0, sizeof(raw_devices)); + raw_devices_count = ARRAY_SIZE(raw_devices); + count = GetRegisteredRawInputDevices(raw_devices, &raw_devices_count, sizeof(RAWINPUTDEVICE)); + todo_wine + ok(count == 1, "GetRegisteredRawInputDevices returned %u\n", count); + ok(raw_devices_count == 1, "Unexpected registered devices count: %u\n", raw_devices_count); + ok(GetLastError() == 0xdeadbeef, "GetRegisteredRawInputDevices unexpected error %08x\n", GetLastError()); + todo_wine + ok(raw_devices[0].usUsagePage == 0x01, "Unexpected usage page: %x\n", raw_devices[0].usUsagePage); + todo_wine + ok(raw_devices[0].usUsage == 0x05, "Unexpected usage: %x\n", raw_devices[0].usUsage); /* RIDEV_REMOVE requires hwndTarget == NULL */ raw_devices[0].dwFlags = RIDEV_REMOVE; -- 2.27.0

2 9

[PATCH] netio.sys: Fix some minor case issues in comments.
by Francois Gouget 29 Jun '20

29 Jun '20

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/netio.sys/netio.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/netio.sys/netio.c b/dlls/netio.sys/netio.c index b0ca6801799..53d74f994db 100644 --- a/dlls/netio.sys/netio.c +++ b/dlls/netio.sys/netio.c @@ -1,7 +1,7 @@ /* * WSK (Winsock Kernel) driver library. * - * Copyright 2020 Paul Gofman <pgofman(a)codeweavers.com> for Codeweavers + * Copyright 2020 Paul Gofman <pgofman(a)codeweavers.com> for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public -- 2.20.1

2 2

[PATCH] ntoskrnl.exe/tests: Fix some minor case issues in comments.
by Francois Gouget 29 Jun '20

29 Jun '20

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/ntoskrnl.exe/tests/driver4.c | 2 +- dlls/ntoskrnl.exe/tests/utils.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/ntoskrnl.exe/tests/driver4.c b/dlls/ntoskrnl.exe/tests/driver4.c index 48de151f31f..45ea90260a8 100644 --- a/dlls/ntoskrnl.exe/tests/driver4.c +++ b/dlls/ntoskrnl.exe/tests/driver4.c @@ -1,7 +1,7 @@ /* * ntoskrnl.exe testing framework * - * Copyright 2020 Paul Gofman for Codeweavers + * Copyright 2020 Paul Gofman for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public diff --git a/dlls/ntoskrnl.exe/tests/utils.h b/dlls/ntoskrnl.exe/tests/utils.h index da0b02ac006..be0f58f837c 100644 --- a/dlls/ntoskrnl.exe/tests/utils.h +++ b/dlls/ntoskrnl.exe/tests/utils.h @@ -4,7 +4,7 @@ * Copyright 2015 Sebastian Lackner * Copyright 2015 Michael M??ller * Copyright 2015 Christian Costa - * Copyright 2020 Paul Gofman for Codeweavers + * Copyright 2020 Paul Gofman for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public -- 2.20.1

2 1

[PATCH] mshtml: Add a trailing '\n' to a TRACE().
by Francois Gouget 29 Jun '20

29 Jun '20

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- dlls/mshtml/htmldoc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/mshtml/htmldoc.c b/dlls/mshtml/htmldoc.c index 57ec662de84..d267fa6de52 100644 --- a/dlls/mshtml/htmldoc.c +++ b/dlls/mshtml/htmldoc.c @@ -726,7 +726,7 @@ static HRESULT WINAPI HTMLDocument_get_bgColor(IHTMLDocument2 *iface, VARIANT *p nsres = nsIDOMHTMLDocument_GetBgColor(This->doc_node->nsdoc, &nsstr); hres = return_nsstr_variant(nsres, &nsstr, NSSTR_COLOR, p); if(hres == S_OK && V_VT(p) == VT_BSTR && !V_BSTR(p)) { - TRACE("default #ffffff"); + TRACE("default #ffffff\n"); if(!(V_BSTR(p) = SysAllocString(L"#ffffff"))) hres = E_OUTOFMEMORY; } -- 2.20.1

2 1

[PATCH] mshtml: Fix the spelling of a parameter name.
by Francois Gouget 29 Jun '20

29 Jun '20

Signed-off-by: Francois Gouget <fgouget(a)free.fr> --- include/mshtml.idl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/mshtml.idl b/include/mshtml.idl index e202dfff1ae..ba7ef0db165 100644 --- a/include/mshtml.idl +++ b/include/mshtml.idl @@ -28242,7 +28242,7 @@ interface IMarkupServices2 : IMarkupServices [in] IMarkupPointer *pPointerFinish, [in] IMarkupPointer *pPointerTarget, [in, out] IMarkupPointer *pPointerStatus, - [out] IHTMLElement **ppElemFailBotton, + [out] IHTMLElement **ppElemFailBottom, [out] IHTMLElement **ppElemFailTop); HRESULT SaveSegmentsToClipboard( -- 2.20.1

2 1

Jump to page:

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 June 2020