October 2018 - Wine-devel - list.winehq.org

[PATCH v5 1/2] ntoskrnl.exe: Implement IoRegisterDeviceInterface
by Aric Stewart 05 Oct '18

05 Oct '18

v 5: More comments from Zebediah Figura and Dmitry Timoshkov Signed-off-by: Aric Stewart <aric(a)codeweavers.com> --- dlls/ntoskrnl.exe/Makefile.in | 2 +- dlls/ntoskrnl.exe/ntoskrnl.c | 135 ++++++++++++++++++++++++++++++++++++ dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 2 +- include/ddk/wdm.h | 1 + 4 files changed, 138 insertions(+), 2 deletions(-)

2 1

[PATCH v2 2/2] configure.ac: Get rid of no longer used SOCKET_LIBS.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- v2: Leave ;; for consistency. configure.ac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

1 0

[PATCH vkd3d] Release 1.1.
by Józef Kucia 05 Oct '18

05 Oct '18

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- ANNOUNCE | 105 ++++++++++++++++++++++++++++------------------------------- AUTHORS | 1 + configure.ac | 2 +- 3 files changed, 52 insertions(+), 56 deletions(-) diff --git a/ANNOUNCE b/ANNOUNCE index 8c2c1dea4c42..b69e8fa23652 100644 --- a/ANNOUNCE +++ b/ANNOUNCE @@ -1,16 +1,16 @@ -The Wine team is proud to announce that release 1.0 of vkd3d, the +The Wine team is proud to announce that release 1.1 of vkd3d, the Direct3D 12 to Vulkan translation library, is now available. -This is the first release of vkd3d. A lot of Direct3D 12 features are still -missing and bugs are expected. The current version was tested mainly with demo -applications. A number of features that are being worked on have been deferred -to the next development cycle. This includes in particular geometry and -tessellation shaders support, various shader translation improvements, as well -as various improvements for core Direct3D 12 methods. +This release contains improvements that are listed in the release notes below. +The main highlights are: + + - Initial support for placed resources. + - MoltenVK support. + - Support for geometry shaders. The source is available from the following location: - https://dl.winehq.org/vkd3d/source/vkd3d-1.0.tar.xz + https://dl.winehq.org/vkd3d/source/vkd3d-1.1.tar.xz The current source can also be pulled directly from the git repository: @@ -21,70 +21,65 @@ for the complete list. ---------------------------------------------------------------- -What's included in vkd3d 1.0 -============================ +What's new in vkd3d 1.1 +======================= *** libvkd3d -- libvkd3d is the main component of the vkd3d project. It's a 3D graphics - library built on top of Vulkan with an API very similar to Direct3D 12. - -- A significant number of Direct3D 12 features are implemented, including: - - Graphics and compute pipelines. - - Command lists, command allocators and command queues. - - Descriptors and descriptor heaps. - - Root signatures. - - Constant buffer, shader resource, unordered access, render target and depth - stencil views. - - Samplers. - - Static samplers. - - Descriptors copying. - - Committed resources. - - Fences. - - Queries and query heaps. - - Resource barriers. - - Root constants. - - Basic support for indirect draws and dispatches. - - Basic support for command signatures. - - Various Clear*() methods. - - Various Copy*() methods. +- Initial support for memory heaps and placed resources. + +- Improved support for resource views. + +- ClearUnorderedAccessViewUint() is implemented for textures. + +- Blend factor is implemented. + +- Performance improvements. + +- A new interface is available for enabling additional Vulkan instance + extensions. + +- A new public function is available for mapping VkFormats to DXGI_FORMATs. + +- Support for more DXGI formats. + +- Various bug fixes. *** libvkd3d-shader -- libvkd3d-shader is a library which translates shader model 4 and 5 bytecode - to SPIR-V. In this release, libvkd3d-shader is an internal library. Its API - isn't set in stone yet. +- Support for geometry shaders. -- Vertex, pixel and compute shaders are supported. Also, very simple geometry - shaders should be translated correctly. Issues are expected when trying to - translate tessellation shaders or more complex geometry shaders. +- Pretty printing is implemented for shader code extracted from DXBC. -- A significant number of shader instructions are supported in this release, - including: - - Arithmetic instructions. - - Bit instructions. - - Comparison instructions. - - Control flow instructions. - - Sample, gather and load instructions. - - Atomic instructions. - - UAV instructions. +- Clip and cull distances are supported. -- Root signature serialization and deserialization is implemented. +- Support for more shader instructions: + - round_ne, + - sincos, + - ineg, + - continue, + - continuec, + - gather4_po, + - gather4_po_c, + - gather4_c. -- Shader model 4 and 5 bytecode parser is imported from wined3d. +- Texel offets are supported. -- Shader model 5.1 is not supported yet. +- Various shader translation fixes. *** libvkd3d-utils -- libvkd3d-utils contains simple implementations of various functions which - might be useful for source ports of Direct3D 12 applications. +- Vulkan WSI extensions are detected at runtime. + + +*** build + +- Demos are not built by default. +- libxcb is now an optional dependency required only for demos. -*** demos +- MoltenVK is supported. -- A simple hello triangle Direct3D 12 demo. -- A Direct3D 12 port of glxgears. diff --git a/AUTHORS b/AUTHORS index 1991bdf8081d..c15cb6ae1aef 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,3 +1,4 @@ +Chip Davis Henri Verbeet Józef Kucia Sven Hesse diff --git a/configure.ac b/configure.ac index ada7e9a7f0f8..58672c510ab9 100644 --- a/configure.ac +++ b/configure.ac @@ -1,5 +1,5 @@ AC_PREREQ([2.69]) -AC_INIT([vkd3d],[1.0]) +AC_INIT([vkd3d],[1.1]) AC_CONFIG_AUX_DIR([bin]) AC_CONFIG_MACRO_DIR([m4]) -- 2.16.4

3 2

[PATCH] build: Use XCB_CFLAGS on the vkd3d_api test, too.
by Chip Davis 05 Oct '18

05 Oct '18

Signed-off-by: Chip Davis <cdavis(a)codeweavers.com> --- Makefile.am | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile.am b/Makefile.am index 1fdc916..dea0544 100644 --- a/Makefile.am +++ b/Makefile.am @@ -129,6 +129,7 @@ check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests) AM_DEFAULT_SOURCE_EXT = .c TESTS = $(vkd3d_tests) $(vkd3d_cross_tests) tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@ +tests_vkd3d_api_CFLAGS = @XCB_CFLAGS@ tests_vkd3d_api_LDADD = libvkd3d.la @VULKAN_LIBS@ if BUILD_DEMOS -- 2.19.0

2 2

[PATCH 2/2] configure.ac: Get rid of no longer used SOCKET_LIBS.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- configure.ac | 1 - 1 file changed, 1 deletion(-)

1 0

[PATCH 1/2] hostname: Use GetComputerNameW to get hostname.
by Jacek Caban 05 Oct '18

05 Oct '18

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- programs/hostname/Makefile.in | 1 - programs/hostname/hostname.c | 31 +++++++++++++------------------ programs/hostname/hostname.h | 3 ++- programs/hostname/hostname.rc | 1 + 4 files changed, 16 insertions(+), 20 deletions(-)

1 0

[PATCH 3/3] wined3d: Drop support for pre-parsed shader DXBC chunks.
by Józef Kucia 05 Oct '18

05 Oct '18

Accept only full DXBC. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/shader.c | 6 -- dlls/d3d8/shader.c | 8 -- dlls/d3d9/shader.c | 8 -- dlls/wined3d/shader.c | 195 +++++++++++------------------------------ dlls/wined3d/wined3d_private.h | 7 +- include/wine/wined3d.h | 11 --- 6 files changed, 55 insertions(+), 180 deletions(-) diff --git a/dlls/d3d11/shader.c b/dlls/d3d11/shader.c index 4b4969135387..3f5c6e147482 100644 --- a/dlls/d3d11/shader.c +++ b/dlls/d3d11/shader.c @@ -394,7 +394,6 @@ static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -598,7 +597,6 @@ static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader, &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -792,7 +790,6 @@ static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, stru desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader, &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -1293,7 +1290,6 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; memset(&so_desc, 0, sizeof(so_desc)); if (so_entries) @@ -1645,7 +1641,6 @@ static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader))) { @@ -1847,7 +1842,6 @@ static HRESULT d3d11_compute_shader_init(struct d3d11_compute_shader *shader, st desc.byte_code = byte_code; desc.byte_code_size = byte_code_length; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; if (FAILED(hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader, &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader))) { diff --git a/dlls/d3d8/shader.c b/dlls/d3d8/shader.c index 8a6881200e8b..2a4fbde88c09 100644 --- a/dlls/d3d8/shader.c +++ b/dlls/d3d8/shader.c @@ -117,10 +117,6 @@ HRESULT d3d8_vertex_shader_init(struct d3d8_vertex_shader *shader, struct d3d8_d desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, @@ -168,10 +164,6 @@ HRESULT d3d8_pixel_shader_init(struct d3d8_pixel_shader *shader, struct d3d8_dev desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, diff --git a/dlls/d3d9/shader.c b/dlls/d3d9/shader.c index 5fc356c8e8af..bc347386b85d 100644 --- a/dlls/d3d9/shader.c +++ b/dlls/d3d9/shader.c @@ -144,10 +144,6 @@ HRESULT vertexshader_init(struct d3d9_vertexshader *shader, struct d3d9_device * desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, @@ -297,10 +293,6 @@ HRESULT pixelshader_init(struct d3d9_pixelshader *shader, struct d3d9_device *de desc.byte_code = byte_code; desc.byte_code_size = ~(size_t)0; - desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - desc.input_signature.element_count = 0; - desc.output_signature.element_count = 0; - desc.patch_constant_signature.element_count = 0; wined3d_mutex_lock(); hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index ecff0bc299a6..ce45298b539d 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -3150,7 +3150,6 @@ static void shader_cleanup(struct wined3d_shader *shader) heap_free(shader->patch_constant_signature.elements); heap_free(shader->output_signature.elements); heap_free(shader->input_signature.elements); - heap_free(shader->signature_strings); shader->device->shader_backend->shader_destroy(shader); shader_cleanup_reg_maps(&shader->reg_maps); heap_free(shader->byte_code); @@ -3598,107 +3597,12 @@ BOOL vshader_get_input(const struct wined3d_shader *shader, return FALSE; } -static HRESULT shader_signature_calculate_strings_length(const struct wined3d_shader_signature *signature, - SIZE_T *total) -{ - struct wined3d_shader_signature_element *e; - unsigned int i; - SIZE_T len; - - for (i = 0; i < signature->element_count; ++i) - { - e = &signature->elements[i]; - len = strlen(e->semantic_name); - if (len >= ~(SIZE_T)0 - *total) - return E_OUTOFMEMORY; - - *total += len + 1; - } - return WINED3D_OK; -} - -static HRESULT shader_signature_copy(struct wined3d_shader_signature *dst, - const struct wined3d_shader_signature *src, char **signature_strings) -{ - struct wined3d_shader_signature_element *e; - unsigned int i; - SIZE_T len; - char *ptr; - - if (!src->element_count) - return WINED3D_OK; - - ptr = *signature_strings; - - dst->element_count = src->element_count; - if (!(dst->elements = heap_calloc(dst->element_count, sizeof(*dst->elements)))) - return E_OUTOFMEMORY; - - for (i = 0; i < src->element_count; ++i) - { - e = &src->elements[i]; - dst->elements[i] = *e; - - len = strlen(e->semantic_name); - memcpy(ptr, e->semantic_name, len + 1); - dst->elements[i].semantic_name = ptr; - ptr += len + 1; - } - - *signature_strings = ptr; - - return WINED3D_OK; -} - -static HRESULT shader_copy_signatures_from_shader_desc(struct wined3d_shader *shader, - const struct wined3d_shader_desc *desc) -{ - SIZE_T total; - HRESULT hr; - char *ptr; - - total = 0; - if (FAILED(hr = shader_signature_calculate_strings_length(&desc->input_signature, &total))) - return hr; - if (FAILED(hr = shader_signature_calculate_strings_length(&desc->output_signature, &total))) - return hr; - if (FAILED(hr = shader_signature_calculate_strings_length(&desc->patch_constant_signature, &total))) - return hr; - if (total && !(shader->signature_strings = heap_alloc(total))) - return E_OUTOFMEMORY; - ptr = shader->signature_strings; - - if (FAILED(hr = shader_signature_copy(&shader->input_signature, &desc->input_signature, &ptr))) - { - heap_free(shader->signature_strings); - return hr; - } - if (FAILED(hr = shader_signature_copy(&shader->output_signature, &desc->output_signature, &ptr))) - { - heap_free(shader->input_signature.elements); - heap_free(shader->signature_strings); - return hr; - } - if (FAILED(hr = shader_signature_copy(&shader->patch_constant_signature, &desc->patch_constant_signature, &ptr))) - { - heap_free(shader->output_signature.elements); - heap_free(shader->input_signature.elements); - heap_free(shader->signature_strings); - return hr; - } - - return S_OK; -} - static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops) { - enum wined3d_shader_byte_code_format format; - unsigned int max_version; HRESULT hr; - TRACE("byte_code %p, byte_code_size %#lx, format %#x.\n", - desc->byte_code, (long)desc->byte_code_size, desc->format); + TRACE("byte_code %p, byte_code_size %#lx.\n", desc->byte_code, (long)desc->byte_code_size); if (!desc->byte_code) return WINED3DERR_INVALIDCALL; @@ -3716,74 +3620,73 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device list_init(&shader->reg_maps.indexable_temps); list_init(&shader->shader_list_entry); - format = desc->format; - if (format == WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC) + if (desc->byte_code_size == ~(size_t)0) { - if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) + struct wined3d_shader_version shader_version; + const struct wined3d_shader_frontend *fe; + struct wined3d_shader_instruction ins; + const DWORD *ptr; + void *fe_data; + + if (!(shader->frontend = shader_select_frontend(WINED3D_SHADER_BYTE_CODE_FORMAT_SM1))) { - hr = E_OUTOFMEMORY; + FIXME("Unable to find frontend for shader.\n"); + hr = WINED3DERR_INVALIDCALL; goto fail; } - memcpy(shader->byte_code, desc->byte_code, desc->byte_code_size); - shader->byte_code_size = desc->byte_code_size; - - max_version = shader_max_version_from_feature_level(device->feature_level); - if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) - goto fail; - } - else if (FAILED(hr = shader_copy_signatures_from_shader_desc(shader, desc))) - { - goto fail; - } - - if (!(shader->frontend = shader_select_frontend(format))) - { - FIXME("Unable to find frontend for shader.\n"); - hr = WINED3DERR_INVALIDCALL; - goto fail; - } - - if (!shader->byte_code) - { - size_t byte_code_size = desc->byte_code_size; - if (byte_code_size == ~(size_t)0) + fe = shader->frontend; + if (!(fe_data = fe->shader_init(desc->byte_code, desc->byte_code_size, &shader->output_signature))) { - const struct wined3d_shader_frontend *fe = shader->frontend; - struct wined3d_shader_version shader_version; - struct wined3d_shader_instruction ins; - const DWORD *ptr; - void *fe_data; + WARN("Failed to initialise frontend data.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; + } - if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature))) - { - WARN("Failed to initialise frontend data.\n"); - hr = WINED3DERR_INVALIDCALL; - goto fail; - } + fe->shader_read_header(fe_data, &ptr, &shader_version); + while (!fe->shader_is_end(fe_data, &ptr)) + fe->shader_read_instruction(fe_data, &ptr, &ins); - fe->shader_read_header(fe_data, &ptr, &shader_version); - while (!fe->shader_is_end(fe_data, &ptr)) - fe->shader_read_instruction(fe_data, &ptr, &ins); + fe->shader_free(fe_data); - fe->shader_free(fe_data); + shader->byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); - byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); - } - - if (!(shader->byte_code = heap_alloc(byte_code_size))) + if (!(shader->byte_code = heap_alloc(shader->byte_code_size))) { hr = E_OUTOFMEMORY; goto fail; } - memcpy(shader->byte_code, desc->byte_code, byte_code_size); - shader->byte_code_size = byte_code_size; + memcpy(shader->byte_code, desc->byte_code, shader->byte_code_size); shader->function = shader->byte_code; shader->functionLength = shader->byte_code_size; } + else + { + enum wined3d_shader_byte_code_format format; + unsigned int max_version; - return hr; + if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) + { + hr = E_OUTOFMEMORY; + goto fail; + } + memcpy(shader->byte_code, desc->byte_code, desc->byte_code_size); + shader->byte_code_size = desc->byte_code_size; + + max_version = shader_max_version_from_feature_level(device->feature_level); + if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) + goto fail; + + if (!(shader->frontend = shader_select_frontend(format))) + { + FIXME("Unable to find frontend for shader.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; + } + } + + return WINED3D_OK; fail: shader_cleanup(shader); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 221b9472aa67..b5e3c79d4fc2 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -397,6 +397,12 @@ struct wined3d_settings extern struct wined3d_settings wined3d_settings DECLSPEC_HIDDEN; +enum wined3d_shader_byte_code_format +{ + WINED3D_SHADER_BYTE_CODE_FORMAT_SM1, + WINED3D_SHADER_BYTE_CODE_FORMAT_SM4, +}; + enum wined3d_shader_resource_type { WINED3D_SHADER_RESOURCE_NONE, @@ -4108,7 +4114,6 @@ struct wined3d_shader struct wined3d_shader_signature input_signature; struct wined3d_shader_signature output_signature; struct wined3d_shader_signature patch_constant_signature; - char *signature_strings; /* Pointer to the parent device */ struct wined3d_device *device; diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index 297192f7c703..8197a8682ae5 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -854,13 +854,6 @@ enum wined3d_display_rotation WINED3D_DISPLAY_ROTATION_270 = 4, }; -enum wined3d_shader_byte_code_format -{ - WINED3D_SHADER_BYTE_CODE_FORMAT_SM1 = 0, - WINED3D_SHADER_BYTE_CODE_FORMAT_SM4 = 1, - WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC = 2, -}; - enum wined3d_shader_type { WINED3D_SHADER_TYPE_PIXEL, @@ -2062,10 +2055,6 @@ struct wined3d_shader_desc { const DWORD *byte_code; size_t byte_code_size; - enum wined3d_shader_byte_code_format format; - struct wined3d_shader_signature input_signature; - struct wined3d_shader_signature output_signature; - struct wined3d_shader_signature patch_constant_signature; }; struct wined3d_stream_output_element -- 2.16.4

2 1

[PATCH 2/3] d3d11: Pass full DXBC to wined3d.
by Józef Kucia 05 Oct '18

05 Oct '18

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/d3d11/shader.c | 264 ++++++++++------------------------------------------ 1 file changed, 49 insertions(+), 215 deletions(-) diff --git a/dlls/d3d11/shader.c b/dlls/d3d11/shader.c index a1da9effc2b8..4b4969135387 100644 --- a/dlls/d3d11/shader.c +++ b/dlls/d3d11/shader.c @@ -24,156 +24,19 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d11); -struct aon9_header +static HRESULT osgn_handler(const char *data, DWORD data_size, DWORD tag, void *context) { - DWORD chunk_size; - DWORD shader_version; - DWORD unknown; - DWORD byte_code_offset; -}; - -struct shader_handler_context -{ - D3D_FEATURE_LEVEL feature_level; - struct wined3d_shader_desc *desc; -}; - -static HRESULT shdr_handler(const char *data, DWORD data_size, DWORD tag, void *context) -{ - const struct shader_handler_context *ctx = context; - struct wined3d_shader_desc *desc = ctx->desc; - HRESULT hr; - - switch (tag) - { - case TAG_ISGN: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - TRACE("Skipping shader input signature on feature level %#x.\n", ctx->feature_level); - break; - } - if (desc->input_signature.elements) - { - FIXME("Multiple input signatures.\n"); - break; - } - if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->input_signature))) - return hr; - break; - - case TAG_OSGN: - case TAG_OSG5: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - TRACE("Skipping shader output signature on feature level %#x.\n", ctx->feature_level); - break; - } - if (desc->output_signature.elements) - { - FIXME("Multiple output signatures.\n"); - break; - } - if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->output_signature))) - return hr; - break; - - case TAG_PCSG: - if (desc->patch_constant_signature.elements) - { - FIXME("Multiple patch constant signatures.\n"); - break; - } - if (FAILED(hr = shader_parse_signature(tag, data, data_size, &desc->patch_constant_signature))) - return hr; - break; - - case TAG_SHDR: - case TAG_SHEX: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - TRACE("Skipping SM4+ shader code on feature level %#x.\n", ctx->feature_level); - break; - } - if (desc->byte_code) - FIXME("Multiple shader code chunks.\n"); - desc->byte_code = (const DWORD *)data; - desc->byte_code_size = data_size; - desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4; - break; - - case TAG_AON9: - if (ctx->feature_level <= D3D_FEATURE_LEVEL_9_3) - { - const struct aon9_header *header = (const struct aon9_header *)data; - unsigned int unknown_dword_count; - const char *byte_code; - - if (data_size < sizeof(*header)) - { - WARN("Invalid Aon9 data size %#x.\n", data_size); - return E_FAIL; - } - byte_code = data + header->byte_code_offset; - unknown_dword_count = (header->byte_code_offset - sizeof(*header)) / sizeof(DWORD); - - if (data_size - 2 * sizeof(DWORD) < header->byte_code_offset) - { - WARN("Invalid byte code offset %#x (size %#x).\n", header->byte_code_offset, data_size); - return E_FAIL; - } - FIXME("Skipping %u unknown DWORDs.\n", unknown_dword_count); - - if (desc->byte_code) - FIXME("Multiple shader code chunks.\n"); - desc->byte_code = (const DWORD *)byte_code; - desc->byte_code_size = data_size - header->byte_code_offset; - desc->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; - TRACE("Feature level 9 shader version 0%08x, 0%08x.\n", header->shader_version, *desc->byte_code); - } - else - { - TRACE("Skipping feature level 9 shader code on feature level %#x.\n", ctx->feature_level); - } - break; - - default: - TRACE("Skipping chunk %s.\n", debugstr_an((const char *)&tag, 4)); - break; - } - - return S_OK; -} - -static void free_shader_desc(struct wined3d_shader_desc *desc) -{ - shader_free_signature(&desc->input_signature); - shader_free_signature(&desc->output_signature); - shader_free_signature(&desc->patch_constant_signature); -} - -static HRESULT shader_extract_from_dxbc(const void *dxbc, SIZE_T dxbc_length, - struct wined3d_shader_desc *desc, D3D_FEATURE_LEVEL feature_level) -{ - struct shader_handler_context ctx = {feature_level, desc}; - HRESULT hr; - - desc->byte_code = NULL; - desc->byte_code_size = 0; - memset(&desc->input_signature, 0, sizeof(desc->input_signature)); - memset(&desc->output_signature, 0, sizeof(desc->output_signature)); - memset(&desc->patch_constant_signature, 0, sizeof(desc->patch_constant_signature)); + struct wined3d_shader_signature *signature = context; - hr = parse_dxbc(dxbc, dxbc_length, shdr_handler, &ctx); - if (!desc->byte_code) - hr = E_INVALIDARG; + if (tag != TAG_OSGN && tag != TAG_OSG5) + return S_OK; - if (FAILED(hr)) + if (signature->elements) { - FIXME("Failed to parse shader, hr %#x.\n", hr); - free_shader_desc(desc); + FIXME("Multiple input signatures.\n"); + shader_free_signature(signature); } - - return hr; + return shader_parse_signature(tag, data, data_size, signature); } static const char *shader_get_string(const char *data, size_t data_size, DWORD offset) @@ -529,18 +392,11 @@ static HRESULT d3d_vertex_shader_init(struct d3d_vertex_shader *shader, struct d wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, - &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_vs(device->wined3d_device, &desc, shader, + &d3d_vertex_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d vertex shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -740,18 +596,11 @@ static HRESULT d3d11_hull_shader_init(struct d3d11_hull_shader *shader, struct d wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader, - &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_hs(device->wined3d_device, &desc, shader, + &d3d11_hull_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d hull shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -941,18 +790,11 @@ static HRESULT d3d11_domain_shader_init(struct d3d11_domain_shader *shader, stru wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader, - &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_ds(device->wined3d_device, &desc, shader, + &d3d11_domain_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d domain shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -1412,6 +1254,7 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, unsigned int rasterizer_stream) { struct wined3d_stream_output_desc so_desc; + struct wined3d_shader_signature signature; struct wined3d_shader_desc desc; unsigned int i; HRESULT hr; @@ -1448,11 +1291,9 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, } } - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - return hr; - } + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; memset(&so_desc, 0, sizeof(so_desc)); if (so_entries) @@ -1466,15 +1307,23 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, if (!(so_desc.elements = heap_calloc(so_entry_count, sizeof(*so_desc.elements)))) { ERR("Failed to allocate wined3d stream output element array memory.\n"); - free_shader_desc(&desc); return E_OUTOFMEMORY; } - if (FAILED(hr = wined3d_so_elements_from_d3d11_so_entries(so_desc.elements, + + memset(&signature, 0, sizeof(signature)); + if (FAILED(hr = parse_dxbc(byte_code, byte_code_length, osgn_handler, &signature))) + { + ERR("Failed to parse input signature.\n"); + heap_free(so_desc.elements); + return E_FAIL; + } + hr = wined3d_so_elements_from_d3d11_so_entries(so_desc.elements, so_entries, so_entry_count, buffer_strides, buffer_stride_count, - &desc.output_signature, device->feature_level))) + &signature, device->feature_level); + shader_free_signature(&signature); + if (FAILED(hr)) { heap_free(so_desc.elements); - free_shader_desc(&desc); return hr; } } @@ -1488,7 +1337,6 @@ static HRESULT d3d_geometry_shader_init(struct d3d_geometry_shader *shader, hr = wined3d_shader_create_gs(device->wined3d_device, &desc, so_entries ? &so_desc : NULL, shader, &d3d_geometry_shader_wined3d_parent_ops, &shader->wined3d_shader); heap_free(so_desc.elements); - free_shader_desc(&desc); if (FAILED(hr)) { WARN("Failed to create wined3d geometry shader, hr %#x.\n", hr); @@ -1795,18 +1643,11 @@ static HRESULT d3d_pixel_shader_init(struct d3d_pixel_shader *shader, struct d3d wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, - &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_ps(device->wined3d_device, &desc, shader, + &d3d_pixel_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d pixel shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); @@ -2004,18 +1845,11 @@ static HRESULT d3d11_compute_shader_init(struct d3d11_compute_shader *shader, st wined3d_mutex_lock(); wined3d_private_store_init(&shader->private_store); - if (FAILED(hr = shader_extract_from_dxbc(byte_code, byte_code_length, &desc, device->feature_level))) - { - WARN("Failed to extract shader, hr %#x.\n", hr); - wined3d_private_store_cleanup(&shader->private_store); - wined3d_mutex_unlock(); - return hr; - } - - hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader, - &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader); - free_shader_desc(&desc); - if (FAILED(hr)) + desc.byte_code = byte_code; + desc.byte_code_size = byte_code_length; + desc.format = WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC; + if (FAILED(hr = wined3d_shader_create_cs(device->wined3d_device, &desc, shader, + &d3d11_compute_shader_wined3d_parent_ops, &shader->wined3d_shader))) { WARN("Failed to create wined3d compute shader, hr %#x.\n", hr); wined3d_private_store_cleanup(&shader->private_store); -- 2.16.4

2 1

[PATCH 1/3] wined3d: Accept full DXBC.
by Józef Kucia 05 Oct '18

05 Oct '18

In order to make it easier to add shader backends based on external libraries, e.g. vkd3d-shader. Additionally, allows us to easily parse additional DXBC chunks in wined3d. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- dlls/wined3d/shader.c | 105 ++++++++----- dlls/wined3d/shader_sm4.c | 329 +++++++++++++++++++++++++++++++++++++++++ dlls/wined3d/wined3d_private.h | 9 +- include/wine/wined3d.h | 1 + 4 files changed, 404 insertions(+), 40 deletions(-) diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 9524757470eb..ecff0bc299a6 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -3153,7 +3153,7 @@ static void shader_cleanup(struct wined3d_shader *shader) heap_free(shader->signature_strings); shader->device->shader_backend->shader_destroy(shader); shader_cleanup_reg_maps(&shader->reg_maps); - heap_free(shader->function); + heap_free(shader->byte_code); shader_delete_constant_list(&shader->constantsF); shader_delete_constant_list(&shader->constantsB); shader_delete_constant_list(&shader->constantsI); @@ -3461,11 +3461,11 @@ HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader, if (!byte_code) { - *byte_code_size = shader->functionLength; + *byte_code_size = shader->byte_code_size; return WINED3D_OK; } - if (*byte_code_size < shader->functionLength) + if (*byte_code_size < shader->byte_code_size) { /* MSDN claims (for d3d8 at least) that if *byte_code_size is smaller * than the required size we should write the required size and @@ -3473,7 +3473,7 @@ HRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader, return WINED3DERR_INVALIDCALL; } - memcpy(byte_code, shader->function, shader->functionLength); + memcpy(byte_code, shader->byte_code, shader->byte_code_size); return WINED3D_OK; } @@ -3693,7 +3693,8 @@ static HRESULT shader_copy_signatures_from_shader_desc(struct wined3d_shader *sh static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device *device, const struct wined3d_shader_desc *desc, void *parent, const struct wined3d_parent_ops *parent_ops) { - size_t byte_code_size; + enum wined3d_shader_byte_code_format format; + unsigned int max_version; HRESULT hr; TRACE("byte_code %p, byte_code_size %#lx, format %#x.\n", @@ -3702,20 +3703,11 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device if (!desc->byte_code) return WINED3DERR_INVALIDCALL; - if (!(shader->frontend = shader_select_frontend(desc->format))) - { - FIXME("Unable to find frontend for shader.\n"); - return WINED3DERR_INVALIDCALL; - } - shader->ref = 1; shader->device = device; shader->parent = parent; shader->parent_ops = parent_ops; - if (FAILED(hr = shader_copy_signatures_from_shader_desc(shader, desc))) - return hr; - list_init(&shader->linked_programs); list_init(&shader->constantsF); list_init(&shader->constantsB); @@ -3724,40 +3716,78 @@ static HRESULT shader_init(struct wined3d_shader *shader, struct wined3d_device list_init(&shader->reg_maps.indexable_temps); list_init(&shader->shader_list_entry); - byte_code_size = desc->byte_code_size; - if (byte_code_size == ~(size_t)0) + format = desc->format; + if (format == WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC) { - const struct wined3d_shader_frontend *fe = shader->frontend; - struct wined3d_shader_version shader_version; - struct wined3d_shader_instruction ins; - const DWORD *ptr; - void *fe_data; - - if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature))) + if (!(shader->byte_code = heap_alloc(desc->byte_code_size))) { - WARN("Failed to initialise frontend data.\n"); - shader_cleanup(shader); - return WINED3DERR_INVALIDCALL; + hr = E_OUTOFMEMORY; + goto fail; } + memcpy(shader->byte_code, desc->byte_code, desc->byte_code_size); + shader->byte_code_size = desc->byte_code_size; - fe->shader_read_header(fe_data, &ptr, &shader_version); - while (!fe->shader_is_end(fe_data, &ptr)) - fe->shader_read_instruction(fe_data, &ptr, &ins); - - fe->shader_free(fe_data); + max_version = shader_max_version_from_feature_level(device->feature_level); + if (FAILED(hr = shader_extract_from_dxbc(shader, max_version, &format))) + goto fail; + } + else if (FAILED(hr = shader_copy_signatures_from_shader_desc(shader, desc))) + { + goto fail; + } - byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); + if (!(shader->frontend = shader_select_frontend(format))) + { + FIXME("Unable to find frontend for shader.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; } - if (!(shader->function = heap_alloc(byte_code_size))) + if (!shader->byte_code) { - shader_cleanup(shader); - return E_OUTOFMEMORY; + size_t byte_code_size = desc->byte_code_size; + + if (byte_code_size == ~(size_t)0) + { + const struct wined3d_shader_frontend *fe = shader->frontend; + struct wined3d_shader_version shader_version; + struct wined3d_shader_instruction ins; + const DWORD *ptr; + void *fe_data; + + if (!(fe_data = fe->shader_init(desc->byte_code, byte_code_size, &shader->output_signature))) + { + WARN("Failed to initialise frontend data.\n"); + hr = WINED3DERR_INVALIDCALL; + goto fail; + } + + fe->shader_read_header(fe_data, &ptr, &shader_version); + while (!fe->shader_is_end(fe_data, &ptr)) + fe->shader_read_instruction(fe_data, &ptr, &ins); + + fe->shader_free(fe_data); + + byte_code_size = (ptr - desc->byte_code) * sizeof(*ptr); + } + + if (!(shader->byte_code = heap_alloc(byte_code_size))) + { + hr = E_OUTOFMEMORY; + goto fail; + } + memcpy(shader->byte_code, desc->byte_code, byte_code_size); + shader->byte_code_size = byte_code_size; + + shader->function = shader->byte_code; + shader->functionLength = shader->byte_code_size; } - memcpy(shader->function, desc->byte_code, byte_code_size); - shader->functionLength = byte_code_size; return hr; + +fail: + shader_cleanup(shader); + return hr; } static HRESULT vertex_shader_init(struct wined3d_shader *shader, struct wined3d_device *device, @@ -3820,7 +3850,6 @@ static HRESULT geometry_shader_init_stream_output(struct wined3d_shader *shader, { case WINED3D_SHADER_TYPE_VERTEX: case WINED3D_SHADER_TYPE_DOMAIN: - heap_free(shader->function); shader->function = NULL; shader->functionLength = 0; break; diff --git a/dlls/wined3d/shader_sm4.c b/dlls/wined3d/shader_sm4.c index 7841686b8b4b..5f9dbecfebaa 100644 --- a/dlls/wined3d/shader_sm4.c +++ b/dlls/wined3d/shader_sm4.c @@ -1774,3 +1774,332 @@ const struct wined3d_shader_frontend sm4_shader_frontend = shader_sm4_read_instruction, shader_sm4_is_end, }; + +#define TAG_AON9 WINEMAKEFOURCC('A', 'o', 'n', '9') +#define TAG_DXBC WINEMAKEFOURCC('D', 'X', 'B', 'C') +#define TAG_ISGN WINEMAKEFOURCC('I', 'S', 'G', 'N') +#define TAG_OSG5 WINEMAKEFOURCC('O', 'S', 'G', '5') +#define TAG_OSGN WINEMAKEFOURCC('O', 'S', 'G', 'N') +#define TAG_PCSG WINEMAKEFOURCC('P', 'C', 'S', 'G') +#define TAG_SHDR WINEMAKEFOURCC('S', 'H', 'D', 'R') +#define TAG_SHEX WINEMAKEFOURCC('S', 'H', 'E', 'X') + +struct aon9_header +{ + DWORD chunk_size; + DWORD shader_version; + DWORD unknown; + DWORD byte_code_offset; +}; + +struct shader_handler_context +{ + struct wined3d_shader *shader; + enum wined3d_shader_byte_code_format *format; + unsigned int max_version; +}; + +static void read_dword(const char **ptr, DWORD *d) +{ + memcpy(d, *ptr, sizeof(*d)); + *ptr += sizeof(*d); +} + +static BOOL require_space(size_t offset, size_t count, size_t size, size_t data_size) +{ + return !count || (data_size - offset) / count >= size; +} + +static void skip_dword_unknown(const char **ptr, unsigned int count) +{ + unsigned int i; + DWORD d; + + WARN("Skipping %u unknown DWORDs:\n", count); + for (i = 0; i < count; ++i) + { + read_dword(ptr, &d); + WARN("\t0x%08x\n", d); + } +} + +static HRESULT parse_dxbc(const char *data, SIZE_T data_size, + HRESULT (*chunk_handler)(const char *data, DWORD data_size, DWORD tag, void *ctx), void *ctx) +{ + const char *ptr = data; + HRESULT hr = S_OK; + DWORD chunk_count; + DWORD total_size; + unsigned int i; + DWORD version; + DWORD tag; + + read_dword(&ptr, &tag); + TRACE("tag: %s.\n", debugstr_an((const char *)&tag, 4)); + + if (tag != TAG_DXBC) + { + WARN("Wrong tag.\n"); + return E_INVALIDARG; + } + + WARN("Ignoring DXBC checksum.\n"); + skip_dword_unknown(&ptr, 4); + + read_dword(&ptr, &version); + TRACE("version: %#x.\n", version); + if (version != 0x00000001) + { + WARN("Got unexpected DXBC version %#x.\n", version); + return E_INVALIDARG; + } + + read_dword(&ptr, &total_size); + TRACE("total size: %#x\n", total_size); + + read_dword(&ptr, &chunk_count); + TRACE("chunk count: %#x\n", chunk_count); + + for (i = 0; i < chunk_count; ++i) + { + DWORD chunk_tag, chunk_size; + const char *chunk_ptr; + DWORD chunk_offset; + + read_dword(&ptr, &chunk_offset); + TRACE("chunk %u at offset %#x\n", i, chunk_offset); + + if (chunk_offset >= data_size || !require_space(chunk_offset, 2, sizeof(DWORD), data_size)) + { + WARN("Invalid chunk offset %#x (data size %#lx).\n", chunk_offset, data_size); + return E_FAIL; + } + + chunk_ptr = data + chunk_offset; + + read_dword(&chunk_ptr, &chunk_tag); + read_dword(&chunk_ptr, &chunk_size); + + if (!require_space(chunk_ptr - data, 1, chunk_size, data_size)) + { + WARN("Invalid chunk size %#x (data size %#lx, chunk offset %#x).\n", + chunk_size, data_size, chunk_offset); + return E_FAIL; + } + + if (FAILED(hr = chunk_handler(chunk_ptr, chunk_size, chunk_tag, ctx))) + break; + } + + return hr; +} + +static const char *shader_get_string(const char *data, size_t data_size, DWORD offset) +{ + size_t len, max_len; + + if (offset >= data_size) + { + WARN("Invalid offset %#x (data size %#lx).\n", offset, (long)data_size); + return NULL; + } + + max_len = data_size - offset; + len = strnlen(data + offset, max_len); + + if (len == max_len) + return NULL; + + return data + offset; +} + +static HRESULT shader_parse_signature(DWORD tag, const char *data, DWORD data_size, + struct wined3d_shader_signature *s) +{ + struct wined3d_shader_signature_element *e; + const char *ptr = data; + unsigned int i; + DWORD count; + + if (!require_space(0, 2, sizeof(DWORD), data_size)) + { + WARN("Invalid data size %#x.\n", data_size); + return E_INVALIDARG; + } + + read_dword(&ptr, &count); + TRACE("%u elements.\n", count); + + skip_dword_unknown(&ptr, 1); /* It seems to always be 0x00000008. */ + + if (!require_space(ptr - data, count, 6 * sizeof(DWORD), data_size)) + { + WARN("Invalid count %#x (data size %#x).\n", count, data_size); + return E_INVALIDARG; + } + + if (!(e = heap_calloc(count, sizeof(*e)))) + { + ERR("Failed to allocate input signature memory.\n"); + return E_OUTOFMEMORY; + } + + for (i = 0; i < count; ++i) + { + DWORD name_offset; + + if (tag == TAG_OSG5) + read_dword(&ptr, &e[i].stream_idx); + else + e[i].stream_idx = 0; + read_dword(&ptr, &name_offset); + if (!(e[i].semantic_name = shader_get_string(data, data_size, name_offset))) + { + WARN("Invalid name offset %#x (data size %#x).\n", name_offset, data_size); + heap_free(e); + return E_INVALIDARG; + } + read_dword(&ptr, &e[i].semantic_idx); + read_dword(&ptr, &e[i].sysval_semantic); + read_dword(&ptr, &e[i].component_type); + read_dword(&ptr, &e[i].register_idx); + read_dword(&ptr, &e[i].mask); + + TRACE("Stream: %u, semantic: %s, semantic idx: %u, sysval_semantic %#x, " + "type %u, register idx: %u, use_mask %#x, input_mask %#x.\n", + e[i].stream_idx, debugstr_a(e[i].semantic_name), e[i].semantic_idx, e[i].sysval_semantic, + e[i].component_type, e[i].register_idx, (e[i].mask >> 8) & 0xff, e[i].mask & 0xff); + } + + s->elements = e; + s->element_count = count; + + return S_OK; +} + +static HRESULT shader_dxbc_chunk_handler(const char *data, DWORD data_size, DWORD tag, void *context) +{ + struct shader_handler_context *ctx = context; + struct wined3d_shader *shader = ctx->shader; + HRESULT hr; + + switch (tag) + { + case TAG_ISGN: + if (ctx->max_version < 4) + { + TRACE("Skipping shader input signature.\n"); + break; + } + if (shader->input_signature.elements) + { + FIXME("Multiple input signatures.\n"); + break; + } + if (FAILED(hr = shader_parse_signature(tag, data, data_size, &shader->input_signature))) + return hr; + break; + + case TAG_OSGN: + case TAG_OSG5: + if (ctx->max_version < 4) + { + TRACE("Skipping shader output signature.\n"); + break; + } + if (shader->output_signature.elements) + { + FIXME("Multiple output signatures.\n"); + break; + } + if (FAILED(hr = shader_parse_signature(tag, data, data_size, &shader->output_signature))) + return hr; + break; + + case TAG_PCSG: + if (shader->patch_constant_signature.elements) + { + FIXME("Multiple patch constant signatures.\n"); + break; + } + if (FAILED(hr = shader_parse_signature(tag, data, data_size, &shader->patch_constant_signature))) + return hr; + break; + + case TAG_SHDR: + case TAG_SHEX: + if (ctx->max_version < 4) + { + TRACE("Skipping SM4+ shader.\n"); + break; + } + if (shader->function) + FIXME("Multiple shader code chunks.\n"); + shader->function = (const DWORD *)data; + shader->functionLength = data_size; + *ctx->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM4; + break; + + case TAG_AON9: + if (ctx->max_version < 4) + { + const struct aon9_header *header = (const struct aon9_header *)data; + unsigned int unknown_dword_count; + const char *byte_code; + + if (data_size < sizeof(*header)) + { + WARN("Invalid Aon9 data size %#x.\n", data_size); + return E_FAIL; + } + byte_code = data + header->byte_code_offset; + unknown_dword_count = (header->byte_code_offset - sizeof(*header)) / sizeof(DWORD); + + if (data_size - 2 * sizeof(DWORD) < header->byte_code_offset) + { + WARN("Invalid byte code offset %#x (size %#x).\n", header->byte_code_offset, data_size); + return E_FAIL; + } + FIXME("Skipping %u unknown DWORDs.\n", unknown_dword_count); + + if (shader->function) + FIXME("Multiple shader code chunks.\n"); + shader->function = (const DWORD *)byte_code; + shader->functionLength = data_size - header->byte_code_offset; + *ctx->format = WINED3D_SHADER_BYTE_CODE_FORMAT_SM1; + TRACE("Feature level 9 shader version 0%08x, 0%08x.\n", + header->shader_version, *shader->function); + } + else + { + TRACE("Skipping feature level 9 shader code.\n"); + } + break; + + default: + TRACE("Skipping chunk %s.\n", debugstr_an((const char *)&tag, 4)); + break; + } + + return S_OK; +} + +HRESULT shader_extract_from_dxbc(struct wined3d_shader *shader, + unsigned int max_shader_version, enum wined3d_shader_byte_code_format *format) +{ + struct shader_handler_context ctx; + HRESULT hr; + + ctx.shader = shader; + ctx.format = format; + ctx.max_version = max_shader_version; + + hr = parse_dxbc(shader->byte_code, shader->byte_code_size, shader_dxbc_chunk_handler, &ctx); + if (!shader->function) + hr = E_INVALIDARG; + + if (FAILED(hr)) + WARN("Failed to parse DXBC, hr %#x.\n", hr); + + return hr; +} diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 9baefa6184dd..221b9472aa67 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1253,6 +1253,9 @@ struct wined3d_shader_frontend extern const struct wined3d_shader_frontend sm1_shader_frontend DECLSPEC_HIDDEN; extern const struct wined3d_shader_frontend sm4_shader_frontend DECLSPEC_HIDDEN; +HRESULT shader_extract_from_dxbc(struct wined3d_shader *shader, + unsigned int max_shader_version, enum wined3d_shader_byte_code_format *format); + typedef void (*SHADER_HANDLER)(const struct wined3d_shader_instruction *); #define WINED3D_SHADER_CAP_VS_CLIPPING 0x00000001 @@ -4080,8 +4083,10 @@ struct wined3d_shader { LONG ref; const struct wined3d_shader_limits *limits; - DWORD *function; - UINT functionLength; + const DWORD *function; + unsigned int functionLength; + void *byte_code; + unsigned int byte_code_size; BOOL load_local_constsF; const struct wined3d_shader_frontend *frontend; void *frontend_data; diff --git a/include/wine/wined3d.h b/include/wine/wined3d.h index cf44ca64a409..297192f7c703 100644 --- a/include/wine/wined3d.h +++ b/include/wine/wined3d.h @@ -858,6 +858,7 @@ enum wined3d_shader_byte_code_format { WINED3D_SHADER_BYTE_CODE_FORMAT_SM1 = 0, WINED3D_SHADER_BYTE_CODE_FORMAT_SM4 = 1, + WINED3D_SHADER_BYTE_CODE_FORMAT_DXBC = 2, }; enum wined3d_shader_type -- 2.16.4

2 1

[PATCH 1/2] d2d1: Add a helper to set error state.
by Nikolay Sivov 05 Oct '18

05 Oct '18

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d2d1/device.c | 47 ++++++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 22 deletions(-) diff --git a/dlls/d2d1/device.c b/dlls/d2d1/device.c index bfd14948b0..1e420514a8 100644 --- a/dlls/d2d1/device.c +++ b/dlls/d2d1/device.c @@ -195,6 +195,13 @@ static void d2d_device_context_draw(struct d2d_device_context *render_target, en WARN("Failed to apply stateblock, hr %#x.\n", hr); } +static void d2d_device_context_set_error(struct d2d_device_context *context, HRESULT code) +{ + context->error.code = code; + context->error.tag1 = context->drawing_state.tag1; + context->error.tag2 = context->drawing_state.tag2; +} + static inline struct d2d_device_context *impl_from_IUnknown(IUnknown *iface) { return CONTAINING_RECORD(iface, struct d2d_device_context, IUnknown_iface); @@ -969,23 +976,21 @@ static void STDMETHODCALLTYPE d2d_device_context_FillGeometry(ID2D1DeviceContext { const struct d2d_geometry *geometry_impl = unsafe_impl_from_ID2D1Geometry(geometry); struct d2d_brush *opacity_brush_impl = unsafe_impl_from_ID2D1Brush(opacity_brush); - struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); struct d2d_brush *brush_impl = unsafe_impl_from_ID2D1Brush(brush); TRACE("iface %p, geometry %p, brush %p, opacity_brush %p.\n", iface, geometry, brush, opacity_brush); - if (FAILED(render_target->error.code)) + if (FAILED(context->error.code)) return; if (opacity_brush && brush_impl->type != D2D_BRUSH_TYPE_BITMAP) { - render_target->error.code = D2DERR_INCOMPATIBLE_BRUSH_TYPES; - render_target->error.tag1 = render_target->drawing_state.tag1; - render_target->error.tag2 = render_target->drawing_state.tag2; + d2d_device_context_set_error(context, D2DERR_INCOMPATIBLE_BRUSH_TYPES); return; } - d2d_device_context_fill_geometry(render_target, geometry_impl, brush_impl, opacity_brush_impl); + d2d_device_context_fill_geometry(context, geometry_impl, brush_impl, opacity_brush_impl); } static void STDMETHODCALLTYPE d2d_device_context_FillMesh(ID2D1DeviceContext *iface, @@ -1076,7 +1081,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawBitmap(ID2D1DeviceContext * if (interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR && interpolation_mode != D2D1_BITMAP_INTERPOLATION_MODE_LINEAR) { - context->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); return; } @@ -1341,7 +1346,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext D2D1_POINT_2F baseline_origin, const DWRITE_GLYPH_RUN *glyph_run, ID2D1Brush *brush, DWRITE_MEASURING_MODE measuring_mode) { - struct d2d_device_context *render_target = impl_from_ID2D1DeviceContext(iface); + struct d2d_device_context *context = impl_from_ID2D1DeviceContext(iface); DWRITE_TEXT_ANTIALIAS_MODE antialias_mode = DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE; IDWriteRenderingParams *rendering_params; DWRITE_RENDERING_MODE rendering_mode; @@ -1350,12 +1355,12 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext TRACE("iface %p, baseline_origin %s, glyph_run %p, brush %p, measuring_mode %#x.\n", iface, debug_d2d_point_2f(&baseline_origin), glyph_run, brush, measuring_mode); - rendering_params = render_target->text_rendering_params ? render_target->text_rendering_params - : render_target->default_text_rendering_params; + rendering_params = context->text_rendering_params ? context->text_rendering_params + : context->default_text_rendering_params; rendering_mode = IDWriteRenderingParams_GetRenderingMode(rendering_params); - switch (render_target->drawing_state.textAntialiasMode) + switch (context->drawing_state.textAntialiasMode) { case D2D1_TEXT_ANTIALIAS_MODE_ALIASED: if (rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_NATURAL @@ -1363,29 +1368,29 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_NATURAL || rendering_mode == DWRITE_RENDERING_MODE_CLEARTYPE_GDI_CLASSIC) { - render_target->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); } break; case D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE: if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED || rendering_mode == DWRITE_RENDERING_MODE_OUTLINE) { - render_target->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); } break; case D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE: if (rendering_mode == DWRITE_RENDERING_MODE_ALIASED) - render_target->error.code = E_INVALIDARG; + d2d_device_context_set_error(context, E_INVALIDARG); break; default: ; } - if (FAILED(render_target->error.code)) + if (FAILED(context->error.code)) return; rendering_mode = DWRITE_RENDERING_MODE_DEFAULT; - switch (render_target->drawing_state.textAntialiasMode) + switch (context->drawing_state.textAntialiasMode) { case D2D1_TEXT_ANTIALIAS_MODE_DEFAULT: if (IDWriteRenderingParams_GetClearTypeLevel(rendering_params) > 0.0f) @@ -1404,7 +1409,7 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext if (rendering_mode == DWRITE_RENDERING_MODE_DEFAULT) { if (FAILED(hr = IDWriteFontFace_GetRecommendedRenderingMode(glyph_run->fontFace, glyph_run->fontEmSize, - max(render_target->desc.dpiX, render_target->desc.dpiY) / 96.0f, + max(context->desc.dpiX, context->desc.dpiY) / 96.0f, measuring_mode, rendering_params, &rendering_mode))) { ERR("Failed to get recommended rendering mode, hr %#x.\n", hr); @@ -1413,9 +1418,9 @@ static void STDMETHODCALLTYPE d2d_device_context_DrawGlyphRun(ID2D1DeviceContext } if (rendering_mode == DWRITE_RENDERING_MODE_OUTLINE) - d2d_device_context_draw_glyph_run_outline(render_target, baseline_origin, glyph_run, brush); + d2d_device_context_draw_glyph_run_outline(context, baseline_origin, glyph_run, brush); else - d2d_device_context_draw_glyph_run_bitmap(render_target, baseline_origin, glyph_run, brush, + d2d_device_context_draw_glyph_run_bitmap(context, baseline_origin, glyph_run, brush, rendering_mode, measuring_mode, antialias_mode); } @@ -2053,9 +2058,7 @@ static void STDMETHODCALLTYPE d2d_device_context_SetTarget(ID2D1DeviceContext *i if (!(bitmap_impl->options & D2D1_BITMAP_OPTIONS_TARGET)) { - context->error.code = D2DERR_INVALID_TARGET; - context->error.tag1 = context->drawing_state.tag1; - context->error.tag2 = context->drawing_state.tag2; + d2d_device_context_set_error(context, D2DERR_INVALID_TARGET); return; } -- 2.19.0

2 2