August 2021 - Wine-Devel - list.winehq.org

gst.h present but cannot be compiled
by Ozan Türkyılmaz Aug. 19, 2021

Aug. 19, 2021

Hello All, I was checking the latest git wine source and I had the below error message: checking gst/gst.h usability... no checking gst/gst.h presence... yes configure: WARNING: gst/gst.h: present but cannot be compiled configure: WARNING: gst/gst.h: check for missing prerequisite headers? configure: WARNING: gst/gst.h: see the Autoconf documentation configure: WARNING: gst/gst.h: section "Present But Cannot Be Compiled" configure: WARNING: gst/gst.h: proceeding with the compiler's result configure: WARNING: ## ------------------------------------ ## configure: WARNING: ## Report this to wine-devel(a)winehq.org ## configure: WARNING: ## ------------------------------------ ## checking for gst/gst.h... no As the error message said I should report this to wine-devel, I am writing this email. I use Slackware-current update (actually Slackware 15 RC1 now). My gstreamer version is 1.18.4 and I checked the build scripts and there's no upstream patches applied. Gcc version is 11.2.0 if any other questions, please ask and I will provide information. Regards, Ozan

2 1

[PATCH vkd3d] tests/vkd3d_api: Ignore llvmpipe device for testing.
by Giovanni Mascellani Aug. 19, 2021

Aug. 19, 2021

Creating a D3D12 device backed by a llvmpipe physical device fails because llvmpipe doesn't implement some required extensions. This is not a failure in vkd3d. --- tests/vkd3d_api.c | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index 8195c067..c32fc465 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -553,6 +553,14 @@ static void test_physical_device(void) { for (i = 0; i < count; ++i) { + VkPhysicalDeviceProperties vk_physical_device_properties; + vkGetPhysicalDeviceProperties(vk_physical_devices[i], &vk_physical_device_properties); + if (strncmp(vk_physical_device_properties.deviceName, "llvmpipe", 8) == 0) + { + trace("Ignoring llvmpipe device.\n"); + continue; + } + trace("Creating device for Vulkan physical device %p.\n", vk_physical_devices[i]); create_info.vk_physical_device = vk_physical_devices[i]; -- 2.33.0

1 0

[PATCH vkd3d v2 6/7] vkd3d-shader: Handle extended instruction operand fields.
by Conor McCarthy Aug. 19, 2021

Aug. 19, 2021

Prevents any non-zero value in fields starting at bit 14 from causing the modifier flags to be skipped, and emits proper warning and fixme messages. Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- Supersedes patch 211558. --- libs/vkd3d-shader/dxbc.c | 60 ++++++++++++++++++++++++++++------------ libs/vkd3d-shader/sm4.h | 25 +++++++++++++---- 2 files changed, 63 insertions(+), 22 deletions(-) diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index fab19046..338499cd 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -1123,8 +1123,9 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr } param->data_type = data_type; - if (token & VKD3D_SM4_REGISTER_MODIFIER) + if (token & VKD3D_SM4_EXTENDED_OPERAND) { + unsigned int type; DWORD m; if (*ptr >= end) @@ -1133,27 +1134,52 @@ static bool shader_sm4_read_param(struct vkd3d_sm4_data *priv, const DWORD **ptr return false; } m = *(*ptr)++; + type = m & VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK; - switch (m) + if (type == VKD3D_SM4_EXTENDED_OPERAND_MODIFIER) { - case VKD3D_SM4_REGISTER_MODIFIER_NEGATE: - *modifier = VKD3DSPSM_NEG; - break; + unsigned int min_precis = (m & VKD3D_SM4_REGISTER_MIN_PRECIS_MASK) >> VKD3D_SM4_REGISTER_MIN_PRECIS_SHIFT; + unsigned int op_mod = (m & VKD3D_SM4_REGISTER_MODIFIER_MASK) >> VKD3D_SM4_REGISTER_MODIFIER_SHIFT; + unsigned int non_uniform = + (m & VKD3D_SM4_REGISTER_NON_UNIFORM_MASK) >> VKD3D_SM4_REGISTER_NON_UNIFORM_SHIFT; - case VKD3D_SM4_REGISTER_MODIFIER_ABS: - *modifier = VKD3DSPSM_ABS; - break; + switch (op_mod & (VKD3D_SM4_REGISTER_MODIFIER_ABS | VKD3D_SM4_REGISTER_MODIFIER_NEGATE)) + { + case VKD3D_SM4_REGISTER_MODIFIER_NEGATE: + *modifier = VKD3DSPSM_NEG; + break; - case VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE: - *modifier = VKD3DSPSM_ABSNEG; - break; + case VKD3D_SM4_REGISTER_MODIFIER_ABS: + *modifier = VKD3DSPSM_ABS; + break; - default: - FIXME("Skipping modifier 0x%08x.\n", m); - /* fall-through */ - case VKD3D_SM4_REGISTER_MODIFIER_NONE: - *modifier = VKD3DSPSM_NONE; - break; + case VKD3D_SM4_REGISTER_MODIFIER_ABS | VKD3D_SM4_REGISTER_MODIFIER_NEGATE: + *modifier = VKD3DSPSM_ABSNEG; + break; + + default: + *modifier = VKD3DSPSM_NONE; + break; + } + op_mod &= ~(VKD3D_SM4_REGISTER_MODIFIER_ABS | VKD3D_SM4_REGISTER_MODIFIER_NEGATE); + if (op_mod) + FIXME("Skipping modifier flags %#x.\n", op_mod); + + if (min_precis) + WARN("Ignoring minimum precision %#x.\n", min_precis); + + if (non_uniform) + FIXME("Ignoring extended modifier NON_UNIFORM.\n"); + } + else if (type) + { + FIXME("Unhandled extended operand type %#x.\n", type); + } + + if (m & VKD3D_SM4_EXTENDED_OPERAND) + { + FIXME("Skipping second-order extended operand.\n"); + *ptr += *ptr < end; } } else diff --git a/libs/vkd3d-shader/sm4.h b/libs/vkd3d-shader/sm4.h index 335f0161..495582ca 100644 --- a/libs/vkd3d-shader/sm4.h +++ b/libs/vkd3d-shader/sm4.h @@ -93,7 +93,18 @@ #define VKD3D_SM4_OPCODE_MASK 0xff -#define VKD3D_SM4_REGISTER_MODIFIER (0x1u << 31) +#define VKD3D_SM4_EXTENDED_OPERAND (0x1u << 31) + +#define VKD3D_SM4_EXTENDED_OPERAND_TYPE_MASK 0x1fu + +#define VKD3D_SM4_REGISTER_MODIFIER_SHIFT 6 +#define VKD3D_SM4_REGISTER_MODIFIER_MASK (0xffu << VKD3D_SM4_REGISTER_MODIFIER_SHIFT) + +#define VKD3D_SM4_REGISTER_MIN_PRECIS_SHIFT 14 +#define VKD3D_SM4_REGISTER_MIN_PRECIS_MASK (0x7u << VKD3D_SM4_REGISTER_MIN_PRECIS_SHIFT) + +#define VKD3D_SM4_REGISTER_NON_UNIFORM_SHIFT 17 +#define VKD3D_SM4_REGISTER_NON_UNIFORM_MASK (0x1u << VKD3D_SM4_REGISTER_NON_UNIFORM_SHIFT) #define VKD3D_SM4_ADDRESSING_SHIFT2 28 #define VKD3D_SM4_ADDRESSING_MASK2 (0x3u << VKD3D_SM4_ADDRESSING_SHIFT2) @@ -381,12 +392,16 @@ enum vkd3d_sm4_register_type VKD3D_SM5_RT_DEPTHOUT_LESS_EQUAL = 0x27, }; +enum vkd3d_sm4_extended_operand_type +{ + VKD3D_SM4_EXTENDED_OPERAND_NONE = 0x0, + VKD3D_SM4_EXTENDED_OPERAND_MODIFIER = 0x1, +}; + enum vkd3d_sm4_register_modifier { - VKD3D_SM4_REGISTER_MODIFIER_NONE = 0x01, - VKD3D_SM4_REGISTER_MODIFIER_NEGATE = 0x41, - VKD3D_SM4_REGISTER_MODIFIER_ABS = 0x81, - VKD3D_SM4_REGISTER_MODIFIER_ABS_NEGATE = 0xc1, + VKD3D_SM4_REGISTER_MODIFIER_NEGATE = 0x1, + VKD3D_SM4_REGISTER_MODIFIER_ABS = 0x2, }; enum vkd3d_sm4_output_primitive_type -- 2.32.0

2 3

[PATCH vkd3d 1/7] tests: Add tests for unbounded descriptor arrays.
by Conor McCarthy Aug. 19, 2021

Aug. 19, 2021

Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- tests/d3d12.c | 325 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 325 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 2b1830bd..618c2291 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -34797,6 +34797,329 @@ done: destroy_test_context(&context); } +static void test_unbounded_resource_arrays(void) +{ + ID3D12Resource *constant_buffers[64], *input_buffers[64], *output_buffers[128]; + D3D12_ROOT_SIGNATURE_DESC root_signature_desc; + D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc; + D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc; + D3D12_CONSTANT_BUFFER_VIEW_DESC cbv_desc; + ID3D12GraphicsCommandList *command_list; + struct resource_readback rb; + struct test_context context; + ID3D12DescriptorHeap *heap; + ID3D12CommandQueue *queue; + ID3D12Device *device; + unsigned int i; + HRESULT hr; + + static const D3D12_DESCRIPTOR_RANGE descriptor_ranges[] = + { + {D3D12_DESCRIPTOR_RANGE_TYPE_CBV, UINT_MAX, 2, 1, 0}, + {D3D12_DESCRIPTOR_RANGE_TYPE_SRV, UINT_MAX, 2, 1, 64}, + {D3D12_DESCRIPTOR_RANGE_TYPE_UAV, UINT_MAX, 1, 1, 128}, + {D3D12_DESCRIPTOR_RANGE_TYPE_UAV, UINT_MAX, 1, 2, 127}, + {D3D12_DESCRIPTOR_RANGE_TYPE_UAV, UINT_MAX, 1, 3, 192}, + }; + + static const D3D12_ROOT_PARAMETER root_parameters[] = + { + {D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, + .DescriptorTable = {ARRAY_SIZE(descriptor_ranges), descriptor_ranges}}, + }; + + static const DWORD cs_code[] = + { + /* Compiled with /res_may_alias (but it has no effect on the output from fxc 10.1). */ +#if 0 + struct cb + { + uint value; + }; + ConstantBuffer<cb> c1[] : register(b2, space1); + + Buffer<uint> t1[] : register(t2, space1); + + RWBuffer<uint> u1[] : register(u1, space1); + RWBuffer<uint> u2[] : register(u2, space2); + RWBuffer<uint> u3[] : register(u1, space3); + + [numthreads(64, 1, 1)] + void main(uint id : SV_DispatchThreadID) + { + uint i = c1[NonUniformResourceIndex(id)].value; + if (id < 64) // Workaround for an fxc bug. + { + u1[NonUniformResourceIndex(id)][0] = t1[NonUniformResourceIndex(i)][0]; + // If u2 is an alias of u1, this should copy u1. + u3[NonUniformResourceIndex(id)][0] = u2[NonUniformResourceIndex(id)][0]; + } + } +#endif + 0x43425844, 0x82871767, 0x87353509, 0x8ccc50cb, 0x5006dd54, 0x00000001, 0x00000250, 0x00000003, + 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x000001fc, 0x00050051, 0x0000007f, 0x0100086a, + 0x07000859, 0x00308e46, 0x00000000, 0x00000002, 0xffffffff, 0x00000001, 0x00000001, 0x07000858, + 0x00307e46, 0x00000000, 0x00000002, 0xffffffff, 0x00004444, 0x00000001, 0x0700089c, 0x0031ee46, + 0x00000000, 0x00000001, 0xffffffff, 0x00004444, 0x00000001, 0x0700089c, 0x0031ee46, 0x00000001, + 0x00000002, 0xffffffff, 0x00004444, 0x00000002, 0x0700089c, 0x0031ee46, 0x00000002, 0x00000001, + 0xffffffff, 0x00004444, 0x00000003, 0x0200005f, 0x00020012, 0x02000068, 0x00000001, 0x0400009b, + 0x00000040, 0x00000001, 0x00000001, 0x0600004f, 0x00100012, 0x00000000, 0x0002000a, 0x00004001, + 0x00000040, 0x0304001f, 0x0010000a, 0x00000000, 0x04000036, 0x00100012, 0x00000000, 0x0002000a, + 0x0a000036, 0x00100022, 0x00000000, 0x8630800a, 0x00020001, 0x00000000, 0x00000002, 0x0010000a, + 0x00000000, 0x00000000, 0x0e00002d, 0x00100022, 0x00000000, 0x00004002, 0x00000000, 0x00000000, + 0x00000000, 0x00000000, 0x86207e16, 0x00020001, 0x00000000, 0x00000002, 0x0010001a, 0x00000000, + 0x0e0000a4, 0x8621e0f2, 0x00020001, 0x00000000, 0x00000001, 0x0010000a, 0x00000000, 0x00004002, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00100556, 0x00000000, 0x0e0000a3, 0x00100022, + 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x8621ee16, 0x00020001, + 0x00000001, 0x00000002, 0x0010000a, 0x00000000, 0x0e0000a4, 0x8621e0f2, 0x00020001, 0x00000002, + 0x00000001, 0x0010000a, 0x00000000, 0x00004002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x00100556, 0x00000000, 0x01000015, 0x0100003e, + }; + + if (!init_compute_test_context(&context)) + return; + device = context.device; + command_list = context.list; + queue = context.queue; + + memset(&root_signature_desc, 0, sizeof(root_signature_desc)); + root_signature_desc.NumParameters = ARRAY_SIZE(root_parameters); + root_signature_desc.pParameters = root_parameters; + hr = create_root_signature(device, &root_signature_desc, &context.root_signature); + todo + ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr); + if (FAILED(hr)) + goto done; + + heap = create_gpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 256); + + for (i = 0; i < ARRAY_SIZE(constant_buffers); ++i) + { + uint32_t cb_data = 63 - i; + constant_buffers[i] = create_default_buffer(device, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT, + D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_COPY_DEST); + upload_buffer_data(constant_buffers[i], 0, sizeof(cb_data), &cb_data, queue, command_list); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, constant_buffers[i], + D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + cbv_desc.BufferLocation = ID3D12Resource_GetGPUVirtualAddress(constant_buffers[i]); + cbv_desc.SizeInBytes = align(sizeof(cb_data), D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT); + ID3D12Device_CreateConstantBufferView(context.device, &cbv_desc, get_cpu_descriptor_handle(&context, heap, i)); + } + + for (i = 0; i < ARRAY_SIZE(input_buffers); ++i) + { + uint32_t srv_data = i ^ 0x35; + input_buffers[i] = create_default_buffer(device, sizeof(uint32_t), + D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_COPY_DEST); + upload_buffer_data(input_buffers[i], 0, sizeof(srv_data), &srv_data, queue, command_list); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, input_buffers[i], + D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + memset(&srv_desc, 0, sizeof(srv_desc)); + srv_desc.Format = DXGI_FORMAT_R32_UINT; + srv_desc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER; + srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; + srv_desc.Buffer.FirstElement = 0; + srv_desc.Buffer.NumElements = 1; + ID3D12Device_CreateShaderResourceView(device, input_buffers[i], &srv_desc, + get_cpu_descriptor_handle(&context, heap, ARRAY_SIZE(constant_buffers) + i)); + } + + 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(constant_buffers) + ARRAY_SIZE(input_buffers) + i)); + } + + context.pipeline_state = create_compute_pipeline_state(device, context.root_signature, + shader_bytecode(cs_code, sizeof(cs_code))); + + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_SetComputeRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(command_list, + 0, get_gpu_descriptor_handle(&context, heap, 0)); + + ID3D12GraphicsCommandList_Dispatch(command_list, 1, 1, 1); + + for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) + { + vkd3d_test_set_context("buffer %u", i); + transition_sub_resource_state(command_list, output_buffers[i], 0, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE); + get_buffer_readback_with_command_list(output_buffers[i], DXGI_FORMAT_R32_UINT, &rb, queue, command_list); + /* Buffers at index >= 64 are aliased. */ + check_readback_data_uint(&rb, NULL, (i < 64 ? 63 - i : 127 - i) ^ 0x35, 0); + release_resource_readback(&rb); + reset_command_list(command_list, context.allocator); + } + + for (i = 0; i < ARRAY_SIZE(output_buffers); ++i) + ID3D12Resource_Release(output_buffers[i]); + for (i = 0; i < ARRAY_SIZE(input_buffers); ++i) + ID3D12Resource_Release(input_buffers[i]); + for (i = 0; i < ARRAY_SIZE(constant_buffers); ++i) + ID3D12Resource_Release(constant_buffers[i]); + ID3D12DescriptorHeap_Release(heap); +done: + destroy_test_context(&context); +} + +static void test_unbounded_samplers(void) +{ + ID3D12DescriptorHeap *heap, *sampler_heap, *heaps[2]; + ID3D12Resource *input_texture, *output_buffer; + D3D12_ROOT_SIGNATURE_DESC root_signature_desc; + D3D12_SHADER_RESOURCE_VIEW_DESC srv_desc; + ID3D12GraphicsCommandList *command_list; + D3D12_SAMPLER_DESC sampler_desc; + D3D12_SUBRESOURCE_DATA data; + struct resource_readback rb; + struct test_context context; + ID3D12CommandQueue *queue; + ID3D12Device *device; + unsigned int i; + HRESULT hr; + + static const D3D12_DESCRIPTOR_RANGE descriptor_ranges[] = + { + {D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 1, 1, 1, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND}, + {D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER, UINT_MAX, 1, 1, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND}, + }; + + static const D3D12_ROOT_PARAMETER root_parameters[] = + { + {D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, .DescriptorTable = {1, &descriptor_ranges[0]}}, + {D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE, .DescriptorTable = {1, &descriptor_ranges[1]}}, + {D3D12_ROOT_PARAMETER_TYPE_UAV, .Descriptor = {1, 1}}, + }; + + static const DWORD cs_code[] = + { +#if 0 + Texture2D<float> t1 : register(t1, space1); + SamplerState s1[] : register(s1, space1); + RWByteAddressBuffer u1 : register(u1, space1); + + [numthreads(64, 1, 1)] + void main(uint id : SV_DispatchThreadID) + { + // Should alternate between wrap (address 0.1), or clamp (address 1.0). + uint value = t1.SampleLevel(s1[NonUniformResourceIndex(id)], float2(1.1, 1.1), 0.0); + u1.Store(4 * id, value); + } +#endif + 0x43425844, 0x19feacce, 0xef7000f7, 0xd6411d98, 0x890a6fa4, 0x00000001, 0x00000178, 0x00000003, + 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x00000124, 0x00050051, 0x00000049, 0x0100086a, + 0x0600005a, 0x00306e46, 0x00000000, 0x00000001, 0xffffffff, 0x00000001, 0x07001858, 0x00307e46, + 0x00000000, 0x00000001, 0x00000001, 0x00005555, 0x00000001, 0x0600009d, 0x0031ee46, 0x00000000, + 0x00000001, 0x00000001, 0x00000001, 0x0200005f, 0x00020012, 0x02000068, 0x00000001, 0x0400009b, + 0x00000040, 0x00000001, 0x00000001, 0x04000036, 0x00100012, 0x00000000, 0x0002000a, 0x13000048, + 0x00100012, 0x00000000, 0x00004002, 0x3f8ccccd, 0x3f8ccccd, 0x00000000, 0x00000000, 0x00207e46, + 0x00000000, 0x00000001, 0x86206000, 0x00020001, 0x00000000, 0x00000001, 0x0010000a, 0x00000000, + 0x00004001, 0x00000000, 0x0500001c, 0x00100012, 0x00000000, 0x0010000a, 0x00000000, 0x06000029, + 0x00100022, 0x00000000, 0x0002000a, 0x00004001, 0x00000002, 0x080000a6, 0x0021e012, 0x00000000, + 0x00000001, 0x0010001a, 0x00000000, 0x0010000a, 0x00000000, 0x0100003e, + }; + + static const float texture_data[] = {10.0f, 100.0f, 100.0f, 100.0f}; + + if (!init_compute_test_context(&context)) + return; + device = context.device; + command_list = context.list; + queue = context.queue; + + root_signature_desc.NumParameters = ARRAY_SIZE(root_parameters); + root_signature_desc.Flags = 0; + root_signature_desc.NumStaticSamplers = 0; + root_signature_desc.pStaticSamplers = NULL; + root_signature_desc.pParameters = root_parameters; + + hr = create_root_signature(device, &root_signature_desc, &context.root_signature); + todo + ok(SUCCEEDED(hr), "Failed to create root signature, hr %#x.\n", hr); + if (FAILED(hr)) + goto done; + + input_texture = create_default_texture2d(device, 2, 2, 1, 1, DXGI_FORMAT_R32_FLOAT, D3D12_RESOURCE_FLAG_NONE, + D3D12_RESOURCE_STATE_COPY_DEST); + data.pData = texture_data; + data.RowPitch = 2 * sizeof(uint32_t); + data.SlicePitch = 2 * data.RowPitch; + upload_texture_data(input_texture, &data, 1, queue, command_list); + reset_command_list(command_list, context.allocator); + transition_resource_state(command_list, input_texture, D3D12_RESOURCE_STATE_COPY_DEST, + D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE); + + output_buffer = create_default_buffer(device, 64 * sizeof(uint32_t), D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + + context.pipeline_state = create_compute_pipeline_state(device, + context.root_signature, shader_bytecode(cs_code, sizeof(cs_code))); + + heap = create_gpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1); + sampler_heap = create_gpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, 64); + + srv_desc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; + srv_desc.Format = DXGI_FORMAT_R32_FLOAT; + srv_desc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; + srv_desc.Texture2D.MipLevels = 1; + srv_desc.Texture2D.MostDetailedMip = 0; + srv_desc.Texture2D.PlaneSlice = 0; + srv_desc.Texture2D.ResourceMinLODClamp = 0; + ID3D12Device_CreateShaderResourceView(device, input_texture, &srv_desc, + ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(heap)); + + for (i = 0; i < 64; ++i) + { + memset(&sampler_desc, 0, sizeof(sampler_desc)); + sampler_desc.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT; + sampler_desc.AddressU = sampler_desc.AddressV = sampler_desc.AddressW + = (i & 1) ? D3D12_TEXTURE_ADDRESS_MODE_CLAMP : D3D12_TEXTURE_ADDRESS_MODE_WRAP; + ID3D12Device_CreateSampler(device, &sampler_desc, get_cpu_descriptor_handle(&context, sampler_heap, i)); + } + + ID3D12GraphicsCommandList_SetComputeRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + heaps[0] = heap; heaps[1] = sampler_heap; + ID3D12GraphicsCommandList_SetDescriptorHeaps(command_list, 2, heaps); + ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(command_list, 0, ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(heap)); + ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(command_list, 1, ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(sampler_heap)); + ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(command_list, 2, ID3D12Resource_GetGPUVirtualAddress(output_buffer)); + ID3D12GraphicsCommandList_Dispatch(command_list, 1, 1, 1); + + transition_resource_state(command_list, output_buffer, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE); + get_buffer_readback_with_command_list(output_buffer, DXGI_FORMAT_UNKNOWN, &rb, queue, command_list); + for (i = 0; i < 64; ++i) + { + unsigned int value = get_readback_uint(&rb, i, 0, 0); + unsigned int expected = (i & 1) ? 100 : 10; + ok(value == expected, "Got %u, expected %u at %u.\n", value, expected, i); + } + release_resource_readback(&rb); + + ID3D12Resource_Release(input_texture); + ID3D12Resource_Release(output_buffer); + ID3D12DescriptorHeap_Release(heap); + ID3D12DescriptorHeap_Release(sampler_heap); +done: + destroy_test_context(&context); +} + START_TEST(d3d12) { parse_args(argc, argv); @@ -34968,4 +35291,6 @@ START_TEST(d3d12) run_test(test_hull_shader_relative_addressing); run_test(test_hull_shader_patch_constant_inputs); run_test(test_resource_arrays); + run_test(test_unbounded_resource_arrays); + run_test(test_unbounded_samplers); } -- 2.32.0

4 12

[PATCH vkd3d v2 1/5] vkd3d-shader/glsl: Implement vkd3d_glsl_generator_generate().
by Atharva Nimbalkar Aug. 19, 2021

Aug. 19, 2021

Signed-off-by: Atharva Nimbalkar <atharvakn(a)gmail.com> --- Makefile.am | 1 + libs/vkd3d-shader/glsl.c | 118 +++++++++++++++++++++++ libs/vkd3d-shader/vkd3d_shader_main.c | 17 +++- libs/vkd3d-shader/vkd3d_shader_private.h | 9 ++ 4 files changed, 142 insertions(+), 3 deletions(-) create mode 100644 libs/vkd3d-shader/glsl.c diff --git a/Makefile.am b/Makefile.am index 9624485..18ba0fa 100644 --- a/Makefile.am +++ b/Makefile.am @@ -169,6 +169,7 @@ libvkd3d_shader_la_SOURCES = \ include/vkd3d_shader.h \ libs/vkd3d-shader/checksum.c \ libs/vkd3d-shader/dxbc.c \ + libs/vkd3d-shader/glsl.c \ libs/vkd3d-shader/hlsl.c \ libs/vkd3d-shader/hlsl.h \ libs/vkd3d-shader/hlsl_codegen.c \ diff --git a/libs/vkd3d-shader/glsl.c b/libs/vkd3d-shader/glsl.c new file mode 100644 index 0000000..5b4b62b --- /dev/null +++ b/libs/vkd3d-shader/glsl.c @@ -0,0 +1,118 @@ +/* + * Copyright 2021 Atharva Nimbalkar + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include "vkd3d_shader_private.h" + +struct vkd3d_glsl_generator +{ + struct vkd3d_string_buffer buffer; + struct vkd3d_shader_location location; + struct vkd3d_shader_message_context *message_context; + bool failed; +}; + +struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shader_compile_info *compile_info, + struct vkd3d_shader_message_context *message_context) +{ + struct vkd3d_glsl_generator *generator; + + if (!(generator = vkd3d_malloc(sizeof(*generator)))) + return NULL; + + memset(generator, 0, sizeof(*generator)); + generator->location.source_name = compile_info->source_name; + generator->location.line = 2; /* Line 1 is the version token. */ + generator->message_context = message_context; + return generator; +} + +static void VKD3D_PRINTF_FUNC(3, 4) vkd3d_glsl_compiler_error( + struct vkd3d_glsl_generator *generator, + enum vkd3d_shader_error error, const char *fmt, ...) +{ + va_list args; + + va_start(args, fmt); + vkd3d_shader_verror(generator->message_context, &generator->location, error, fmt, args); + va_end(args); + generator->failed = true; + return; +} + +static void vkd3d_glsl_handle_instruction(struct vkd3d_glsl_generator *generator, + const struct vkd3d_shader_instruction *instruction) +{ + switch (instruction->handler_idx) + { + default: + vkd3d_glsl_compiler_error(generator, + VKD3D_SHADER_ERROR_GLSL_INTERNAL, + "Unhandled instruction %#x", instruction->handler_idx); + break; + } + + ++generator->location.line; + return; +} + +int vkd3d_glsl_generator_generate(void *parser_data, const uint32_t *parser_ptr, + struct vkd3d_glsl_generator *generator, + struct vkd3d_shader_code *out) +{ + void *code; + struct vkd3d_shader_instruction ins; + + vkd3d_string_buffer_printf(&generator->buffer, "#version 440\n\n"); + vkd3d_string_buffer_printf(&generator->buffer, "void main()\n{\n"); + + while (!shader_sm4_is_end(parser_data, &parser_ptr)) + { + shader_sm4_read_instruction(parser_data, &parser_ptr, &ins); + + if (ins.handler_idx == VKD3DSIH_INVALID) + { + vkd3d_glsl_compiler_error(generator, + VKD3D_SHADER_ERROR_GLSL_INTERNAL, + "Encountered unrecognized or invalid instruction."); + break; + } + + vkd3d_glsl_handle_instruction(generator, &ins); + } + + if (generator->failed) + return VKD3D_ERROR; + + vkd3d_string_buffer_printf(&generator->buffer, "}\n"); + + if ((code = vkd3d_malloc(generator->buffer.buffer_size))) + { + memcpy(code, generator->buffer.buffer, generator->buffer.content_size); + out->size = generator->buffer.content_size; + out->code = code; + } + else return VKD3D_ERROR_OUT_OF_MEMORY; + + return VKD3D_OK; +} + +void vkd3d_glsl_generator_destroy(struct vkd3d_glsl_generator *generator) +{ + vkd3d_string_buffer_cleanup(&generator->buffer); + vkd3d_free(generator); +} diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index a9b5d0a..d2182e1 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -1034,11 +1034,22 @@ static int compile_dxbc_tpf(const struct vkd3d_shader_compile_info *compile_info if (compile_info->target_type == VKD3D_SHADER_TARGET_GLSL) { - vkd3d_shader_error(message_context, NULL, VKD3D_SHADER_ERROR_GLSL_INTERNAL, - "Internal compiler error: Unhandled instruction."); + struct vkd3d_glsl_generator *glsl_generator; + + if (!(glsl_generator = vkd3d_glsl_generator_create(compile_info, message_context))) + { + ERR("Failed to create GLSL generator.\n"); + vkd3d_shader_parser_destroy(&parser); + vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info); + return VKD3D_ERROR; + } + + ret = vkd3d_glsl_generator_generate(parser.data, parser.ptr, glsl_generator, out); + + vkd3d_glsl_generator_destroy(glsl_generator); vkd3d_shader_parser_destroy(&parser); vkd3d_shader_free_scan_descriptor_info(&scan_descriptor_info); - return VKD3D_ERROR; + return ret; } if (!(spirv_compiler = vkd3d_dxbc_compiler_create(&parser.shader_version, diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index b490b9c..3863797 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -984,6 +984,15 @@ void free_shader_desc(struct vkd3d_shader_desc *desc); int shader_parse_input_signature(const void *dxbc, size_t dxbc_length, struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature); +struct vkd3d_glsl_generator; + +struct vkd3d_glsl_generator *vkd3d_glsl_generator_create(const struct vkd3d_shader_compile_info *compile_info, + struct vkd3d_shader_message_context *message_context); +int vkd3d_glsl_generator_generate(void *parser_data, const uint32_t *parser_ptr, + struct vkd3d_glsl_generator *generator, + struct vkd3d_shader_code *out); +void vkd3d_glsl_generator_destroy(struct vkd3d_glsl_generator *generator); + struct vkd3d_dxbc_compiler; struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version, -- 2.32.0

2 9

[PATCH 1/5] msxml3: Do not depend on libxml2 for DOM implementation object.
by Nikolay Sivov Aug. 19, 2021

Aug. 19, 2021

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/msxml3/domimpl.c | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/dlls/msxml3/domimpl.c b/dlls/msxml3/domimpl.c index 74223d5d54e..52f2e40dc9e 100644 --- a/dlls/msxml3/domimpl.c +++ b/dlls/msxml3/domimpl.c @@ -20,13 +20,7 @@ #define COBJMACROS -#include "config.h" - #include <stdarg.h> -#ifdef HAVE_LIBXML2 -# include <libxml/parser.h> -# include <libxml/xmlerror.h> -#endif #include "windef.h" #include "winbase.h" @@ -34,12 +28,10 @@ #include "ole2.h" #include "msxml6.h" -#include "msxml_private.h" +#include "msxml_dispex.h" #include "wine/debug.h" -#ifdef HAVE_LIBXML2 - WINE_DEFAULT_DEBUG_CHANNEL(msxml); typedef struct _domimpl @@ -211,5 +203,3 @@ IUnknown* create_doc_Implementation(void) return (IUnknown*)&This->IXMLDOMImplementation_iface; } - -#endif -- 2.32.0

1 4

[PATCH v3 1/2] dsound: Commit next audio chunk between play cursor and write cursor to playing.
by Eduard Permyakov Aug. 19, 2021

Aug. 19, 2021

This region of the audio buffer is forbidden to be written to by the DirectSound specification. The documentation states: "The write cursor is the point after which it is safe to write data into the buffer. The block between the play cursor and the write cursor is already committed to be played, and cannot be changed safely." However, some applications still do this, which has lead to audio glitches only when using the Wine DirectSound implementation. Experiments showed that the native DirctSound implementation will still play the old audio the first time around when the buffer region gets overwritten. Use an approach of copying the next forbidden region into a "committed buffer" to add the same behavior to the Wine implementation. Signed-off-by: Eduard Permyakov <epermyakov(a)codeweavers.com> --- dlls/dsound/buffer.c | 20 ++++++++++++++++++++ dlls/dsound/dsound_convert.c | 30 ++++++++++++++++++++---------- dlls/dsound/dsound_private.h | 5 ++++- dlls/dsound/mixer.c | 19 +++++++++++++++++++ 4 files changed, 63 insertions(+), 11 deletions(-) diff --git a/dlls/dsound/buffer.c b/dlls/dsound/buffer.c index dc3b54906ce..bbc7de805a8 100644 --- a/dlls/dsound/buffer.c +++ b/dlls/dsound/buffer.c @@ -1081,6 +1081,13 @@ HRESULT secondarybuffer_create(DirectSoundDevice *device, const DSBUFFERDESC *ds /* calculate fragment size and write lead */ DSOUND_RecalcFormat(dsb); + dsb->committedbuff = HeapAlloc(GetProcessHeap(), 0, dsb->writelead); + if(!dsb->committedbuff) { + IDirectSoundBuffer8_Release(&dsb->IDirectSoundBuffer8_iface); + return DSERR_OUTOFMEMORY; + } + FillMemory(dsb->committedbuff, dsb->writelead, dsbd->lpwfxFormat->wBitsPerSample == 8 ? 128 : 0); + if (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D) { dsb->ds3db_ds3db.dwSize = sizeof(DS3DBUFFER); dsb->ds3db_ds3db.vPosition.x = 0.0; @@ -1135,6 +1142,7 @@ void secondarybuffer_destroy(IDirectSoundBufferImpl *This) HeapFree(GetProcessHeap(), 0, This->notifies); HeapFree(GetProcessHeap(), 0, This->pwfx); + HeapFree(GetProcessHeap(), 0, This->committedbuff); if (This->filters) { int i; @@ -1157,6 +1165,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( { IDirectSoundBufferImpl *dsb; HRESULT hres = DS_OK; + VOID *committedbuff; TRACE("(%p,%p,%p)\n", device, ppdsb, pdsb); dsb = HeapAlloc(GetProcessHeap(),0,sizeof(*dsb)); @@ -1166,6 +1175,14 @@ HRESULT IDirectSoundBufferImpl_Duplicate( return DSERR_OUTOFMEMORY; } + committedbuff = HeapAlloc(GetProcessHeap(),0,pdsb->writelead); + if (committedbuff == NULL) { + HeapFree(GetProcessHeap(),0,dsb); + *ppdsb = NULL; + return DSERR_OUTOFMEMORY; + } + FillMemory(committedbuff, pdsb->writelead, pdsb->pwfx->wBitsPerSample == 8 ? 128 : 0); + AcquireSRWLockShared(&pdsb->lock); CopyMemory(dsb, pdsb, sizeof(*dsb)); @@ -1175,6 +1192,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( ReleaseSRWLockShared(&pdsb->lock); if (dsb->pwfx == NULL) { + HeapFree(GetProcessHeap(),0,committedbuff); HeapFree(GetProcessHeap(),0,dsb); *ppdsb = NULL; return DSERR_OUTOFMEMORY; @@ -1192,6 +1210,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( dsb->notifies = NULL; dsb->nrofnotifies = 0; dsb->device = device; + dsb->committedbuff = committedbuff; DSOUND_RecalcFormat(dsb); InitializeSRWLock(&dsb->lock); @@ -1202,6 +1221,7 @@ HRESULT IDirectSoundBufferImpl_Duplicate( list_remove(&dsb->entry); dsb->buffer->ref--; HeapFree(GetProcessHeap(),0,dsb->pwfx); + HeapFree(GetProcessHeap(),0,dsb->committedbuff); HeapFree(GetProcessHeap(),0,dsb); dsb = NULL; }else diff --git a/dlls/dsound/dsound_convert.c b/dlls/dsound/dsound_convert.c index 4735178a9a8..fc2b0cd0797 100644 --- a/dlls/dsound/dsound_convert.c +++ b/dlls/dsound/dsound_convert.c @@ -55,17 +55,27 @@ WINE_DEFAULT_DEBUG_CHANNEL(dsound); #define le32(x) (x) #endif +static BYTE *buff_byte(const IDirectSoundBufferImpl *dsb, DWORD offset) +{ + if(offset >= dsb->sec_mixpos && offset < dsb->sec_mixpos + dsb->writelead) { + return (BYTE*)dsb->committedbuff + (offset - dsb->sec_mixpos); + }else if(offset < (dsb->sec_mixpos + dsb->writelead) % dsb->buflen) { + return (BYTE*)dsb->committedbuff + (dsb->buflen - dsb->sec_mixpos + offset); + }else{ + return dsb->buffer->memory + offset; + } +} + static float get8(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - buf += pos + channel; + const BYTE *buf = buff_byte(dsb, pos + channel); return (buf[0] - 0x80) / (float)0x80; } static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - const SHORT *sbuf = (const SHORT*)(buf + pos + 2 * channel); + const BYTE *buf = buff_byte(dsb, pos + 2 * channel); + const SHORT *sbuf = (const SHORT*)(buf); SHORT sample = (SHORT)le16(*sbuf); return sample / (float)0x8000; } @@ -73,8 +83,8 @@ static float get16(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { LONG sample; - const BYTE* buf = dsb->buffer->memory; - buf += pos + 3 * channel; + const BYTE *buf = buff_byte(dsb, pos + 3 * channel); + /* The next expression deliberately has an overflow for buf[2] >= 0x80, this is how negative values are made. */ @@ -84,16 +94,16 @@ static float get24(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) static float get32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - const LONG *sbuf = (const LONG*)(buf + pos + 4 * channel); + const BYTE *buf = buff_byte(dsb, pos + 4 * channel); + const LONG *sbuf = (const LONG*)(buf); LONG sample = le32(*sbuf); return sample / (float)0x80000000U; } static float getieee32(const IDirectSoundBufferImpl *dsb, DWORD pos, DWORD channel) { - const BYTE* buf = dsb->buffer->memory; - const float *sbuf = (const float*)(buf + pos + 4 * channel); + const BYTE *buf = buff_byte(dsb, pos + 4 * channel); + const float *sbuf = (const float*)(buf); /* The value will be clipped later, when put into some non-float buffer */ return *sbuf; } diff --git a/dlls/dsound/dsound_private.h b/dlls/dsound/dsound_private.h index bdb9ebee544..a79d62c54da 100644 --- a/dlls/dsound/dsound_private.h +++ b/dlls/dsound/dsound_private.h @@ -153,7 +153,10 @@ struct IDirectSoundBufferImpl LONG64 freqAccNum; /* used for mixing */ DWORD sec_mixpos; - + /* Holds a copy of the next 'writelead' bytes, to be used for mixing. This makes it + * so that these bytes get played once even if this region of the buffer gets overwritten, + * which is more in-line with native DirectSound behavior. */ + LPVOID committedbuff; /* IDirectSoundNotify fields */ LPDSBPOSITIONNOTIFY notifies; int nrofnotifies; diff --git a/dlls/dsound/mixer.c b/dlls/dsound/mixer.c index 124d1e4fba1..32656fbd618 100644 --- a/dlls/dsound/mixer.c +++ b/dlls/dsound/mixer.c @@ -391,6 +391,18 @@ static void cp_fields(IDirectSoundBufferImpl *dsb, UINT count, LONG64 *freqAccNu dsb->sec_mixpos = ipos; } +static void copy_circular(VOID *dstbuff, VOID *srcbuff, DWORD srcoff, DWORD srcsize, DWORD cpysize) +{ + DWORD overflow; + if(cpysize > srcsize - srcoff) { + overflow = cpysize - (srcsize - srcoff); + memcpy(dstbuff, (BYTE*)srcbuff + srcoff, srcsize - srcoff); + memcpy((BYTE*)dstbuff + (srcsize - srcoff), srcbuff, overflow); + }else{ + memcpy(dstbuff, (BYTE*)srcbuff + srcoff, cpysize); + } +} + /** * Calculate the distance between two buffer offsets, taking wraparound * into account. @@ -518,6 +530,8 @@ static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, float *mix_buffer, INT ilen = DSOUND_BufPtrDiff(dsb->buflen, dsb->sec_mixpos, oldpos); DSOUND_CheckEvent(dsb, oldpos, ilen); } + TRACE("committing %u bytes from offset %u\n", dsb->writelead, dsb->sec_mixpos); + copy_circular(dsb->committedbuff, dsb->buffer->memory, dsb->sec_mixpos, dsb->buflen, dsb->writelead); return frames; } @@ -551,6 +565,11 @@ static DWORD DSOUND_MixOne(IDirectSoundBufferImpl *dsb, float *mix_buffer, DWORD } } + if(dsb->leadin) { + TRACE("committing %u bytes from offset %u\n", dsb->writelead, dsb->sec_mixpos); + copy_circular(dsb->committedbuff, dsb->buffer->memory, dsb->sec_mixpos, dsb->buflen, dsb->writelead); + } + dsb->leadin = FALSE; TRACE("frames (primary) = %i\n", frames); -- 2.17.1

2 2

[PATCH 9/9] gdi32: Move GetCharacterPlacementW to text.c.
by Jacek Caban Aug. 19, 2021

Aug. 19, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/gdi32/font.c | 181 ------------------------------- dlls/gdi32/ntgdi_private.h | 17 --- dlls/gdi32/text.c | 212 ++++++++++++++++++++++++++++++++++--- 3 files changed, 198 insertions(+), 212 deletions(-)

2 1

[PATCH 8/9] gdi32: Move bidi text reordering to ExtTextOutW.
by Jacek Caban Aug. 19, 2021

Aug. 19, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/gdi32/font.c | 36 +++++------------------------------- dlls/gdi32/gdidc.c | 15 --------------- dlls/gdi32/text.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 48 insertions(+), 46 deletions(-)

2 1

[PATCH 7/9] gdi32: Rename bidi.c to text.c.
by Jacek Caban Aug. 19, 2021

Aug. 19, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/gdi32/Makefile.in | 2 +- dlls/gdi32/{bidi.c => text.c} | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename dlls/gdi32/{bidi.c => text.c} (99%)

2 1