June 2020 - Wine-Devel - list.winehq.org

[PATCH vkd3d 6/6] vkd3d: Require VKD3D_API_VERSION_1_2 for version 1.1 root signatures.
by Henri Verbeet June 30, 2020

June 30, 2020

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

June 30, 2020

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

June 30, 2020

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

June 30, 2020

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

June 30, 2020

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

June 30, 2020

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

June 30, 2020

_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 June 30, 2020

June 30, 2020

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

June 30, 2020

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

June 30, 2020

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