wine-devel December 2021

wine-devel@winehq.org

85 participants
585 discussions

[PATCH 1/2] qedit/tests: Check the Sample Grabber's buffer during and after flushing.
by Gabriel Ivăncescu 04 Oct '22

04 Oct '22

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/qedit/tests/samplegrabber.c | 234 +++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/dlls/qedit/tests/samplegrabber.c b/dlls/qedit/tests/samplegrabber.c index 8e68e3e..e66180f 100644 --- a/dlls/qedit/tests/samplegrabber.c +++ b/dlls/qedit/tests/samplegrabber.c @@ -1036,6 +1036,239 @@ static void test_connect_pin(void) ok(!ref, "Got outstanding refcount %d.\n", ref); } +struct frame_thread_params +{ + IMemInputPin *sink; + IMediaSample *sample; + DWORD delay; +}; + +static DWORD WINAPI frame_thread(void *arg) +{ + struct frame_thread_params *params = arg; + HRESULT hr; + + if (params->delay) + { + if (winetest_debug > 1) trace("%04x: Sleeping %u ms.\n", GetCurrentThreadId(), params->delay); + Sleep(params->delay); + } + if (winetest_debug > 1) trace("%04x: Sending frame.\n", GetCurrentThreadId()); + hr = IMemInputPin_Receive(params->sink, params->sample); + if (winetest_debug > 1) trace("%04x: Returned %#x.\n", GetCurrentThreadId(), hr); + IMediaSample_Release(params->sample); + free(params); + return hr; +} + +static HANDLE send_frame_time(IMemInputPin *sink, REFERENCE_TIME start_time, unsigned char color, DWORD delay) +{ + struct frame_thread_params *params = malloc(sizeof(*params)); + IMemAllocator *allocator; + REFERENCE_TIME end_time; + IMediaSample *sample; + HANDLE thread; + HRESULT hr; + BYTE *data; + + hr = IMemInputPin_GetAllocator(sink, &allocator); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + if (hr == VFW_E_NOT_COMMITTED) + { + IMemAllocator_Commit(allocator); + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + } + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSample_GetPointer(sample, &data); + ok(hr == S_OK, "Got hr %#x.\n", hr); + memset(data, 0x55, 32 * 16 * 2); + + hr = IMediaSample_SetActualDataLength(sample, 32 * 16 * 2); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + start_time *= 10000000; + end_time = start_time + 10000000; + hr = IMediaSample_SetTime(sample, &start_time, &end_time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + params->sink = sink; + params->sample = sample; + params->delay = delay; + thread = CreateThread(NULL, 0, frame_thread, params, 0, NULL); + + IMemAllocator_Release(allocator); + return thread; +} + +static HANDLE send_frame(IMemInputPin *sink, DWORD delay) +{ + return send_frame_time(sink, 0, 0x55, delay); /* purple */ +} + +static HRESULT join_thread_(int line, HANDLE thread) +{ + DWORD ret; + ok_(__FILE__, line)(!WaitForSingleObject(thread, 1000), "Wait failed.\n"); + GetExitCodeThread(thread, &ret); + CloseHandle(thread); + return ret; +} +#define join_thread(a) join_thread_(__LINE__, a) + +static void test_buffer_flush(void) +{ + AM_MEDIA_TYPE req_mt = + { + .majortype = MEDIATYPE_Video, + .subtype = MEDIASUBTYPE_RGB565, + .formattype = FORMAT_VideoInfo, + .bTemporalCompression = TRUE, + }; + LONG buf[(32 * 16 * 2) / sizeof(LONG)], size = sizeof(buf); + IPin *sink, *source, *renderer_pin; + struct testfilter testsource; + ISampleGrabber *grabber; + IMediaControl *control; + IFilterGraph2 *graph; + IMemInputPin *input; + IBaseFilter *filter; + OAFilterState state; + IMediaFilter *mf; + HANDLE thread; + DWORD ticks; + unsigned i; + HRESULT hr; + ULONG ref; + + testfilter_init(&testsource); + CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, + &IID_IFilterGraph2, (void **)&graph); + CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter); + IFilterGraph2_AddFilter(graph, filter, L"sink"); + IBaseFilter_FindPin(filter, L"In", &renderer_pin); + IBaseFilter_Release(filter); + + filter = create_sample_grabber(); + IFilterGraph2_AddFilter(graph, &testsource.filter.IBaseFilter_iface, L"source"); + IFilterGraph2_AddFilter(graph, filter, L"sample grabber"); + IBaseFilter_FindPin(filter, L"In", &sink); + IBaseFilter_FindPin(filter, L"Out", &source); + IBaseFilter_QueryInterface(filter, &IID_ISampleGrabber, (void **)&grabber); + IFilterGraph2_QueryInterface(graph, &IID_IMediaControl, (void **)&control); + IPin_QueryInterface(sink, &IID_IMemInputPin, (void **)&input); + + ISampleGrabber_SetMediaType(grabber, &req_mt); + ISampleGrabber_SetBufferSamples(grabber, TRUE); + + testsource.sink_mt = &req_mt; + hr = IFilterGraph2_ConnectDirect(graph, &testsource.source.pin.IPin_iface, sink, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IFilterGraph2_ConnectDirect(graph, source, renderer_pin, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_Release(renderer_pin); + + IFilterGraph2_QueryInterface(graph, &IID_IMediaFilter, (void **)&mf); + IMediaFilter_SetSyncSource(mf, NULL); + IMediaFilter_Release(mf); + + hr = IMemInputPin_ReceiveCanBlock(input); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == VFW_E_WRONG_STATE, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %d.\n", state); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + IPin_BeginFlush(sink); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_EndFlush(sink); + + hr = IMediaControl_GetState(control, 0, &state); + todo_wine ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + ticks = GetTickCount(); + thread = send_frame(input, 150); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + IPin_Release(sink); + IPin_Release(source); + IMemInputPin_Release(input); + IMediaControl_Release(control); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ISampleGrabber_Release(grabber); + ref = IBaseFilter_Release(filter); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ref = IBaseFilter_Release(&testsource.filter.IBaseFilter_iface); + ok(!ref, "Got outstanding refcount %d.\n", ref); +} + START_TEST(samplegrabber) { IBaseFilter *filter; @@ -1059,6 +1292,7 @@ START_TEST(samplegrabber) test_aggregation(); test_media_types(); test_connect_pin(); + test_buffer_flush(); CoUninitialize(); } -- 2.21.0

5 7

[PATCH 1/4] riched20: draw OLE object in richedit with OleDraw
by Dongwan Kim 30 Mar '22

30 Mar '22

When OLE object provides IViewObject::Draw, Richedit can draw it even though the OLE object does not support CF_BITMAP nor CF_ENHMETAFILE. Signed-off-by: Dongwan Kim <kdw6485(a)gmail.com> --- dlls/riched20/richole.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/dlls/riched20/richole.c b/dlls/riched20/richole.c index 03572511ff7..1a62f0b9f36 100644 --- a/dlls/riched20/richole.c +++ b/dlls/riched20/richole.c @@ -5653,6 +5653,7 @@ void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize) STGMEDIUM stgm; DIBSECTION dibsect; ENHMETAHEADER emh; + int pixs; assert(run->nFlags & MERF_GRAPHICS); assert(run->reobj); @@ -5691,8 +5692,13 @@ void ME_GetOLEObjectSize(const ME_Context *c, ME_Run *run, SIZE *pSize) fmt.tymed = TYMED_ENHMF; if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK) { - FIXME("unsupported format\n"); - pSize->cx = pSize->cy = 0; + if( IOleObject_GetExtent(run->reobj->obj.poleobj, DVASPECT_CONTENT, pSize) != S_OK){ + FIXME("unsupported format\n"); + pSize->cx = pSize->cy = 0; + } + pixs = GetDeviceCaps(c->hDC, LOGPIXELSX); + pSize->cx = MulDiv(pSize->cx, pixs , 2540); + pSize->cy = MulDiv(pSize->cy, pixs , 2540); IDataObject_Release(ido); return; } @@ -5735,6 +5741,8 @@ void draw_ole( ME_Context *c, int x, int y, ME_Run *run, BOOL selected ) BOOL has_size; HBITMAP old_bm; RECT rc; + HRESULT hr; + int pixs; assert(run->nFlags & MERF_GRAPHICS); assert(run->reobj); @@ -5755,7 +5763,17 @@ void draw_ole( ME_Context *c, int x, int y, ME_Run *run, BOOL selected ) fmt.tymed = TYMED_ENHMF; if (IDataObject_GetData(ido, &fmt, &stgm) != S_OK) { - FIXME("Couldn't get storage medium\n"); + IOleObject_GetExtent(run->reobj->obj.poleobj, DVASPECT_CONTENT, &sz); + pixs = GetDeviceCaps(c->hDC, LOGPIXELSX); + rc.left = x; + rc.top = y - MulDiv(sz.cy, pixs, 2540); + rc.right = x + MulDiv(sz.cx, pixs, 2540); + rc.bottom = y ; + hr = OleDraw(run->reobj->obj.poleobj, DVASPECT_CONTENT, c->hDC, &rc); + if (FAILED(hr)) + { + FIXME("Couldn't draw ole object\n"); + } IDataObject_Release(ido); return; } -- 2.30.2

3 8

[PATCH 1/2] api-ms-win-core-privateprofile-l1-1-0: Add dll.
by Mohamad Al-Jaf 30 Mar '22

30 Mar '22

Needed for native mfc42u.dll. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51850 Signed-off-by: Mohamad Al-Jaf <mohamadaljaf(a)gmail.com> --- The bug report does not mention that the tool cannot run without mfc42u.dll, which requires this API set. --- configure.ac | 1 + .../Makefile.in | 1 + .../api-ms-win-core-privateprofile-l1-1-0.spec | 14 ++++++++++++++ 3 files changed, 16 insertions(+) create mode 100644 dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in create mode 100644 dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec diff --git a/configure.ac b/configure.ac index 9b2c111119f..9630405bfcd 100644 --- a/configure.ac +++ b/configure.ac @@ -2416,6 +2416,7 @@ WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-namedpipe-l1-2-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-namespace-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-normalization-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-path-l1-1-0) +WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-privateprofile-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-privateprofile-l1-1-1) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-processenvironment-l1-1-0) WINE_CONFIG_MAKEFILE(dlls/api-ms-win-core-processenvironment-l1-2-0) diff --git a/dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in b/dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in new file mode 100644 index 00000000000..c8b8ef84aef --- /dev/null +++ b/dlls/api-ms-win-core-privateprofile-l1-1-0/Makefile.in @@ -0,0 +1 @@ +MODULE = api-ms-win-core-privateprofile-l1-1-0.dll diff --git a/dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec b/dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec new file mode 100644 index 00000000000..c8153c3a296 --- /dev/null +++ b/dlls/api-ms-win-core-privateprofile-l1-1-0/api-ms-win-core-privateprofile-l1-1-0.spec @@ -0,0 +1,14 @@ +@ stdcall GetPrivateProfileIntA(str str long str) kernel32.GetPrivateProfileIntA +@ stdcall GetPrivateProfileIntW(wstr wstr long wstr) kernel32.GetPrivateProfileIntW +@ stdcall GetPrivateProfileSectionW(wstr ptr long wstr) kernel32.GetPrivateProfileSectionW +@ stdcall GetPrivateProfileStringA(str str str ptr long str) kernel32.GetPrivateProfileStringA +@ stdcall GetPrivateProfileStringW(wstr wstr wstr ptr long wstr) kernel32.GetPrivateProfileStringW +@ stdcall GetProfileIntA(str str long) kernel32.GetProfileIntA +@ stdcall GetProfileIntW(wstr wstr long) kernel32.GetProfileIntW +@ stdcall GetProfileSectionA(str ptr long) kernel32.GetProfileSectionA +@ stdcall GetProfileSectionW(wstr ptr long) kernel32.GetProfileSectionW +@ stdcall GetProfileStringA(str str str ptr long) kernel32.GetProfileStringA +@ stdcall GetProfileStringW(wstr wstr wstr ptr long) kernel32.GetProfileStringW +@ stdcall WritePrivateProfileSectionA(str str str) kernel32.WritePrivateProfileSectionA +@ stdcall WritePrivateProfileStringA(str str str str) kernel32.WritePrivateProfileStringA +@ stdcall WritePrivateProfileStringW(wstr wstr wstr wstr) kernel32.WritePrivateProfileStringW -- 2.34.1

5 15

[PATCH vkd3d 01/13] vkd3d-shader/hlsl: Handle objects in copy propagation.
by Zebediah Figura 26 Jan '22

26 Jan '22

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.c | 3 ++ libs/vkd3d-shader/hlsl_codegen.c | 49 +++++++++++++++++++++++++------- 2 files changed, 42 insertions(+), 10 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index d2ea4c34a..3a571b946 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -196,6 +196,8 @@ static void hlsl_type_calculate_reg_size(struct hlsl_ctx *ctx, struct hlsl_type } case HLSL_CLASS_OBJECT: + /* For convenience when performing copy propagation. */ + type->reg_size = 1; break; } } @@ -273,6 +275,7 @@ struct hlsl_type *hlsl_new_texture_type(struct hlsl_ctx *ctx, enum hlsl_sampler_ type->dimy = 1; type->sampler_dim = dim; type->e.resource_format = format; + hlsl_type_calculate_reg_size(ctx, type); list_add_tail(&ctx->types, &type->entry); return type; } diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index e43e6378e..e426101fa 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -394,9 +394,26 @@ static bool copy_propagation_analyze_load(struct hlsl_ctx *ctx, struct hlsl_ir_l struct hlsl_deref *src = &load->src; struct hlsl_ir_var *var = src->var; unsigned int offset, swizzle; + unsigned int dimx = 0; - if (type->type != HLSL_CLASS_SCALAR && type->type != HLSL_CLASS_VECTOR) - return false; + switch (type->type) + { + case HLSL_CLASS_SCALAR: + case HLSL_CLASS_VECTOR: + dimx = type->dimx; + break; + + case HLSL_CLASS_OBJECT: + dimx = 1; + break; + + case HLSL_CLASS_MATRIX: + case HLSL_CLASS_ARRAY: + case HLSL_CLASS_STRUCT: + /* FIXME: Actually we shouldn't even get here, but we don't split + * matrices yet. */ + return false; + } if (!hlsl_offset_from_deref(src, &offset)) return false; @@ -404,18 +421,22 @@ static bool copy_propagation_analyze_load(struct hlsl_ctx *ctx, struct hlsl_ir_l if (!(var_def = copy_propagation_get_var_def(state, var))) return false; - if (!(new_node = copy_propagation_compute_replacement(var_def, offset, type->dimx, &swizzle))) + if (!(new_node = copy_propagation_compute_replacement(var_def, offset, dimx, &swizzle))) { - TRACE("No single source for propagating load from %s[%u-%u].\n", var->name, offset, offset + type->dimx); + TRACE("No single source for propagating load from %s[%u-%u].\n", var->name, offset, offset + dimx); return false; } TRACE("Load from %s[%u-%u] propagated as instruction %p%s.\n", - var->name, offset, offset + type->dimx, new_node, debug_hlsl_swizzle(swizzle, 4)); - if (!(swizzle_node = hlsl_new_swizzle(ctx, swizzle, type->dimx, new_node, &node->loc))) - return false; - list_add_before(&node->entry, &swizzle_node->node.entry); - replace_node(node, &swizzle_node->node); + var->name, offset, offset + dimx, new_node, debug_hlsl_swizzle(swizzle, 4)); + if (type->type != HLSL_CLASS_OBJECT) + { + if (!(swizzle_node = hlsl_new_swizzle(ctx, swizzle, dimx, new_node, &node->loc))) + return false; + list_add_before(&node->entry, &swizzle_node->node.entry); + new_node = &swizzle_node->node; + } + replace_node(node, new_node); return true; } @@ -431,9 +452,17 @@ static void copy_propagation_record_store(struct hlsl_ctx *ctx, struct hlsl_ir_s return; if (hlsl_offset_from_deref(lhs, &offset)) - copy_propagation_set_value(var_def, offset, store->writemask, store->rhs.node); + { + unsigned int writemask = store->writemask; + + if (store->rhs.node->data_type->type == HLSL_CLASS_OBJECT) + writemask = VKD3DSP_WRITEMASK_0; + copy_propagation_set_value(var_def, offset, writemask, store->rhs.node); + } else + { copy_propagation_invalidate_whole_variable(var_def); + } } static bool copy_propagation_transform_block(struct hlsl_ctx *ctx, struct hlsl_block *block, -- 2.34.1

4 37

[v2 PATCH vkd3d 1/4] tests: Fix shader tests crashes on WARP driver.
by Nikolay Sivov 25 Jan '22

25 Jan '22

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- tests/d3d12_test_utils.h | 13 +++++++++++++ tests/shader_runner_d3d12.c | 7 ++++--- 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/tests/d3d12_test_utils.h b/tests/d3d12_test_utils.h index 5d900f8..f2ce922 100644 --- a/tests/d3d12_test_utils.h +++ b/tests/d3d12_test_utils.h @@ -956,6 +956,8 @@ struct test_context ID3D12CommandQueue *queue; ID3D12CommandAllocator *allocator; ID3D12GraphicsCommandList *list; + ID3D12PipelineState **pso; + size_t pso_count, pso_capacity; D3D12_RESOURCE_DESC render_target_desc; ID3D12Resource *render_target; @@ -1074,6 +1076,15 @@ static inline bool init_test_context_(unsigned int line, struct test_context *co return true; } +static inline void destroy_pipeline_state_objects(struct test_context *context) +{ + size_t i; + + for (i = 0; i < context->pso_count; ++i) + ID3D12PipelineState_Release(context->pso[i]); + context->pso_count = 0; +} + #define destroy_test_context(context) destroy_test_context_(__LINE__, context) static inline void destroy_test_context_(unsigned int line, struct test_context *context) { @@ -1092,6 +1103,8 @@ static inline void destroy_test_context_(unsigned int line, struct test_context ID3D12CommandAllocator_Release(context->allocator); ID3D12CommandQueue_Release(context->queue); ID3D12GraphicsCommandList_Release(context->list); + destroy_pipeline_state_objects(context); + free(context->pso); refcount = ID3D12Device_Release(context->device); ok_(line)(!refcount, "ID3D12Device has %u references left.\n", (unsigned int)refcount); diff --git a/tests/shader_runner_d3d12.c b/tests/shader_runner_d3d12.c index d404895..47f419b 100644 --- a/tests/shader_runner_d3d12.c +++ b/tests/shader_runner_d3d12.c @@ -419,10 +419,12 @@ static void parse_test_directive(struct shader_context *context, const char *lin hr = create_root_signature(context->c.device, &root_signature_desc, &context->c.root_signature); ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr); - pso = create_pipeline_state(context->c.device, context->c.root_signature, - context->c.render_target_desc.Format, NULL, &ps, NULL); + pso = create_pipeline_state(context->c.device, context->c.root_signature, context->c.render_target_desc.Format, + NULL, &ps, NULL); if (!pso) return; + vkd3d_array_reserve((void **)&context->c.pso, &context->c.pso_capacity, context->c.pso_count + 1, sizeof(*context->c.pso)); + context->c.pso[context->c.pso_count++] = pso; ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context->c.root_signature); if (context->uniform_count) @@ -439,7 +441,6 @@ static void parse_test_directive(struct shader_context *context, const char *lin ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context->c.rtv, clear_color, 0, NULL); ID3D12GraphicsCommandList_SetPipelineState(command_list, pso); ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); - ID3D12PipelineState_Release(pso); transition_resource_state(command_list, context->c.render_target, D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); } -- 2.34.1

5 17

[PATCH] tools: Add gdbinit helper with LoadSymbolFiles command.
by Rémi Bernon 24 Jan '22

24 Jan '22

To help gdb reload symbol files from /proc/<pid>/maps, making it possible to load debug info for ELF and PE modules for Wine processes. When sourced (from ~/.gdbinit for instance), this adds a new "load-symbol-files" command (with an "lsf" alias), which automatically calls add-symbol-file on every mapped file that can be read as ELF or PE, with the correct section offset. The command has to be run manually, for instance after executing for a while, to load new modules that may have been loaded, as there's no way for gdb to be notified of such changes automatically. Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- This is some script I've been using for a while, and more or less broken versions are also used by other people, so I figured maybe it would be better to have a proper working version officially distributed with Wine source instead, as it's pretty useful for debugging Wine under gdb. It's still a bit manual to use, as gdb cannot easily be notified of dynamic library loading [1], but I think it's much better than having nothing. [1] in theory there's ways to do it using systemtap probes, but it's going to be hard to make it work, especially for PE modules. tools/gdbinit.py | 108 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 tools/gdbinit.py diff --git a/tools/gdbinit.py b/tools/gdbinit.py new file mode 100644 index 00000000000..265d97722b7 --- /dev/null +++ b/tools/gdbinit.py @@ -0,0 +1,108 @@ +#!/bin/env python3 + +# Copyright 2021 Rémi Bernon for CodeWeavers +# +# 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 + +from __future__ import print_function + +import gdb +import re +import subprocess +import sys + +class LoadSymbolFiles(gdb.Command): + 'Command to load symbol files directly from /proc/<pid>/maps.' + + def __init__(self): + sup = super(LoadSymbolFiles, self) + sup.__init__('load-symbol-files', gdb.COMMAND_FILES, gdb.COMPLETE_NONE, + False) + + self.libs = {} + gdb.execute('alias -a lsf = load-symbol-files', True) + + def invoke(self, arg, from_tty): + pid = gdb.selected_inferior().pid + if not pid in self.libs: self.libs[pid] = {} + + def command(cmd, confirm=from_tty): + to_string = not from_tty + gdb.execute(cmd, from_tty=confirm, to_string=to_string) + + def execute(cmd): + return subprocess.check_output(cmd, stderr=subprocess.STDOUT) \ + .decode('utf-8') + + # load mappings addresses + libs = {} + with open('/proc/{}/maps'.format(pid), 'r') as maps: + for line in maps: + addr, _, _, _, node, path = re.split(r'\s+', line, 5) + path = path.strip() + if node == '0': continue + if path in libs: continue + libs[path] = int(addr.split('-')[0], 16) + + # unload symbol file if address changed + for k in set(libs) & set(self.libs[pid]): + if libs[k] != self.libs[pid][k]: + command('remove-symbol-file "{}"'.format(k), confirm=False) + del self.libs[k] + + # load symbol file for new mappings + for k in set(libs) - set(self.libs[pid]): + if arg is not None and re.search(arg, k) is None: continue + addr = self.libs[pid][k] = libs[k] + offs = None + + try: + out = execute(['file', k]) + except: + continue + + # try loading mapping as ELF + try: + out = execute(['readelf', '-l', k]) + for line in out.split('\n'): + if not 'LOAD' in line: continue + base = int(line.split()[2], 16) + break + + out = execute(['objdump', '-h', k]) + for line in out.split('\n'): + if not '.text' in line: continue + offs = int(line.split()[3], 16) - base + break + if offs is None: continue + + # try again, assuming mapping is PE + except: + try: + out = execute(['objdump', '-h', k]) + for line in out.split('\n'): + if not '.text' in line: continue + offs = int(line.split()[5], 16) + break + if offs is None: continue + + except: + continue + + command('add-symbol-file "{}" 0x{:x}'.format(k, addr + offs), + confirm=False) + + +LoadSymbolFiles() -- 2.31.0

3 7

[PATCH v9 1/3] ntdll: sock_recv keeps message ordered
by Dongwan Kim 22 Jan '22

22 Jan '22

Calling try_recv could make messages misordered. Suppose that a server program calls a overlapped WSARecv and its operation is pending. Another program sends a message and wineserver is busy. The server program calls another overlapped WSARecv and it intercepts the message for the pending WSARecv. The problem already had been discussed here https://www.winehq.org/pipermail/wine-devel/2021-May/186612.html To avoid this situation, this kind of approach can be applied. The server program needs to know if there are pending asyncs before calling try_recv. Signed-off-by: Dongwan Kim <kdw6485(a)gmail.com> --- dlls/ntdll/unix/socket.c | 20 +++++++++++++++++++- include/wine/server_protocol.h | 16 ++++++++++++++++ server/request.h | 7 +++++++ server/sock.c | 26 ++++++++++++++++++++++++++ server/trace.c | 13 +++++++++++++ 5 files changed, 81 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/unix/socket.c b/dlls/ntdll/unix/socket.c index f82c7ae1ddf..8823e99901b 100644 --- a/dlls/ntdll/unix/socket.c +++ b/dlls/ntdll/unix/socket.c @@ -673,6 +673,21 @@ static BOOL async_recv_proc( void *user, ULONG_PTR *info, NTSTATUS *status ) release_fileio( &async->io ); return TRUE; } +static int query_asyncs_queued( HANDLE sock, int type ) +{ + int result=0; + + SERVER_START_REQ( query_async_waiting ) + { + req->handle = wine_server_obj_handle( sock ); + req->type = type; + wine_server_call(req); + result = reply->state; + } + SERVER_END_REQ; + return result; + +} static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user, IO_STATUS_BLOCK *io, int fd, const void *buffers_ptr, unsigned int count, WSABUF *control, @@ -735,7 +750,10 @@ static NTSTATUS sock_recv( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, voi } } - status = try_recv( fd, async, &information ); + if( force_async && query_asyncs_queued( handle , ASYNC_TYPE_READ )) + status = STATUS_DEVICE_NOT_READY; + else + status = try_recv( fd, async, &information ); if (status != STATUS_SUCCESS && status != STATUS_BUFFER_OVERFLOW && status != STATUS_DEVICE_NOT_READY) { diff --git a/include/wine/server_protocol.h b/include/wine/server_protocol.h index 1d17a40530f..104e3b4cd3c 100644 --- a/include/wine/server_protocol.h +++ b/include/wine/server_protocol.h @@ -5404,7 +5404,20 @@ struct get_next_thread_reply obj_handle_t handle; char __pad_12[4]; }; +struct query_async_waiting_request +{ + struct request_header __header; + obj_handle_t handle; + int type; + char __pad_20[4]; +}; +struct query_async_waiting_reply +{ + struct reply_header __header; + int state; + char __pad_12[4]; +}; enum request { @@ -5682,6 +5695,7 @@ enum request REQ_suspend_process, REQ_resume_process, REQ_get_next_thread, + REQ_query_async_waiting, REQ_NB_REQUESTS }; @@ -5963,6 +5977,7 @@ union generic_request struct suspend_process_request suspend_process_request; struct resume_process_request resume_process_request; struct get_next_thread_request get_next_thread_request; + struct query_async_waiting_request query_async_waiting_request; }; union generic_reply { @@ -6242,6 +6257,7 @@ union generic_reply struct suspend_process_reply suspend_process_reply; struct resume_process_reply resume_process_reply; struct get_next_thread_reply get_next_thread_reply; + struct query_async_waiting_reply query_async_waiting_reply; }; /* ### protocol_version begin ### */ diff --git a/server/request.h b/server/request.h index 3c455799d54..e26dbaae0f3 100644 --- a/server/request.h +++ b/server/request.h @@ -393,6 +393,7 @@ DECL_HANDLER(terminate_job); DECL_HANDLER(suspend_process); DECL_HANDLER(resume_process); DECL_HANDLER(get_next_thread); +DECL_HANDLER(query_async_waiting); #ifdef WANT_REQUEST_HANDLERS @@ -673,6 +674,7 @@ static const req_handler req_handlers[REQ_NB_REQUESTS] = (req_handler)req_suspend_process, (req_handler)req_resume_process, (req_handler)req_get_next_thread, + (req_handler)req_query_async_waiting, }; C_ASSERT( sizeof(abstime_t) == 8 ); @@ -2244,6 +2246,11 @@ C_ASSERT( FIELD_OFFSET(struct get_next_thread_request, flags) == 28 ); C_ASSERT( sizeof(struct get_next_thread_request) == 32 ); C_ASSERT( FIELD_OFFSET(struct get_next_thread_reply, handle) == 8 ); C_ASSERT( sizeof(struct get_next_thread_reply) == 16 ); +C_ASSERT( FIELD_OFFSET(struct query_async_waiting_request, handle) == 12 ); +C_ASSERT( FIELD_OFFSET(struct query_async_waiting_request, type) == 16 ); +C_ASSERT( sizeof(struct query_async_waiting_request) == 24 ); +C_ASSERT( FIELD_OFFSET(struct query_async_waiting_reply, state) == 8 ); +C_ASSERT( sizeof(struct query_async_waiting_reply) == 16 ); #endif /* WANT_REQUEST_HANDLERS */ diff --git a/server/sock.c b/server/sock.c index 2df4f3d3056..d3e3b4cd847 100644 --- a/server/sock.c +++ b/server/sock.c @@ -3520,3 +3520,29 @@ DECL_HANDLER(send_socket) } release_object( sock ); } + +DECL_HANDLER( query_async_waiting ) +{ + struct sock *sock; + struct async *async; + reply->state = 0; + + if (!(sock = (struct sock *)get_handle_obj( current->process, req->handle, + FILE_READ_ATTRIBUTES, &sock_ops))) return; + if (get_unix_fd( sock->fd ) == -1) return; + + if (is_fd_overlapped( sock->fd )) + { + if(req->type == ASYNC_TYPE_READ && ( async = find_pending_async(&sock->read_q) )) { + reply->state = 1; + release_object(async); + } + if(req->type == ASYNC_TYPE_WRITE && ( async = find_pending_async(&sock->write_q )) ) + { + reply->state = 1; + release_object(async); + } + } + release_object( &sock->obj ); + +} diff --git a/server/trace.c b/server/trace.c index a48f00258fe..32f236b2b5a 100644 --- a/server/trace.c +++ b/server/trace.c @@ -4516,6 +4516,16 @@ static void dump_get_next_thread_reply( const struct get_next_thread_reply *req { fprintf( stderr, " handle=%04x", req->handle ); } +static void dump_query_async_waiting_request( const struct query_async_waiting_request *req ) +{ + fprintf( stderr, " handle=%04x", req->handle ); + fprintf( stderr, ", type=%d", req->type ); +} +static void dump_query_async_waiting_reply( const struct query_async_waiting_reply *req ) +{ + fprintf( stderr, " state=%d", req->state ); +} + static const dump_func req_dumpers[REQ_NB_REQUESTS] = { (dump_func)dump_new_process_request, @@ -4792,6 +4802,7 @@ static const dump_func req_dumpers[REQ_NB_REQUESTS] = { (dump_func)dump_suspend_process_request, (dump_func)dump_resume_process_request, (dump_func)dump_get_next_thread_request, + (dump_func)dump_query_async_waiting_request, }; static const dump_func reply_dumpers[REQ_NB_REQUESTS] = { @@ -5069,6 +5080,7 @@ static const dump_func reply_dumpers[REQ_NB_REQUESTS] = { NULL, NULL, (dump_func)dump_get_next_thread_reply, + (dump_func)dump_query_async_waiting_reply, }; static const char * const req_names[REQ_NB_REQUESTS] = { @@ -5346,6 +5358,7 @@ static const char * const req_names[REQ_NB_REQUESTS] = { "suspend_process", "resume_process", "get_next_thread", + "query_async_waiting", }; static const struct -- 2.30.2

2 3

[PATCH vkd3d v3 01/12] vkd3d-shader/hlsl: Add support for sm4 instruction modifiers.
by Francisco Casas 19 Jan '22

19 Jan '22

Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_sm4.c | 54 ++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index 2458018f..07bbd376 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -727,6 +727,46 @@ static enum vkd3d_sm4_resource_type sm4_resource_dimension(const struct hlsl_typ } } +struct sm4_instruction_modifier +{ + enum vkd3d_sm4_instruction_modifier type; + + union + { + struct + { + int u,v,w; + } aoffimmi; + }; +}; + +static uint32_t sm4_encode_instruction_modifier(struct sm4_instruction_modifier imod) +{ + uint32_t word = 0; + + word |= VKD3D_SM4_MODIFIER_MASK & imod.type; + + switch (imod.type) + { + case VKD3D_SM4_MODIFIER_AOFFIMMI: + assert(-8 <= imod.aoffimmi.u && imod.aoffimmi.u <= 7); + assert(-8 <= imod.aoffimmi.v && imod.aoffimmi.v <= 7); + assert(-8 <= imod.aoffimmi.w && imod.aoffimmi.w <= 7); + word |= ((uint32_t)imod.aoffimmi.u & 0xf) << VKD3D_SM4_AOFFIMMI_U_SHIFT; + word |= ((uint32_t)imod.aoffimmi.v & 0xf) << VKD3D_SM4_AOFFIMMI_V_SHIFT; + word |= ((uint32_t)imod.aoffimmi.w & 0xf) << VKD3D_SM4_AOFFIMMI_W_SHIFT; + break; + + default: + FIXME("Unhandled instruction modifier %#x.\n", imod.type); + return 0; + break; + } + + return word; +} + + struct sm4_register { enum vkd3d_sm4_register_type type; @@ -741,6 +781,9 @@ struct sm4_instruction { enum vkd3d_sm4_opcode opcode; + struct sm4_instruction_modifier modifiers[1]; + unsigned int modifier_count; + struct { struct sm4_register reg; @@ -913,6 +956,7 @@ static void write_sm4_instruction(struct vkd3d_bytecode_buffer *buffer, const st uint32_t token = instr->opcode; unsigned int size = 1, i, j; + size += instr->modifier_count; for (i = 0; i < instr->dst_count; ++i) size += sm4_register_order(&instr->dsts[i].reg); for (i = 0; i < instr->src_count; ++i) @@ -920,8 +964,18 @@ static void write_sm4_instruction(struct vkd3d_bytecode_buffer *buffer, const st size += instr->idx_count; token |= (size << VKD3D_SM4_INSTRUCTION_LENGTH_SHIFT); + + token |= ((0 < instr->modifier_count) << 31); + put_u32(buffer, token); + for (i = 0; i < instr->modifier_count; i++) + { + token = sm4_encode_instruction_modifier(instr->modifiers[i]); + token |= ((i + 1 < instr->modifier_count) << 31); + put_u32(buffer, token); + } + for (i = 0; i < instr->dst_count; ++i) { token = sm4_encode_register(&instr->dsts[i].reg); -- 2.25.1

5 7

[PATCH vkd3d v2 1/5] vkd3d-shader/hlsl: Write SM4 equality instructions.
by Giovanni Mascellani 19 Jan '22

19 Jan '22

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- v2: Add hlsl_fixme(). --- libs/vkd3d-shader/hlsl_sm4.c | 34 ++++++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index 2458018f..26ff019c 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -1489,6 +1489,40 @@ static void write_sm4_expr(struct hlsl_ctx *ctx, break; } + case HLSL_TYPE_BOOL: + { + switch (expr->op) + { + case HLSL_OP2_EQUAL: + { + const struct hlsl_type *src_type = arg1->data_type; + + switch (src_type->base_type) + { + case HLSL_TYPE_FLOAT: + write_sm4_binary_op(buffer, VKD3D_SM4_OP_EQ, &expr->node, arg1, arg2); + break; + + case HLSL_TYPE_BOOL: + case HLSL_TYPE_INT: + case HLSL_TYPE_UINT: + write_sm4_binary_op(buffer, VKD3D_SM4_OP_IEQ, &expr->node, arg1, arg2); + break; + + default: + hlsl_fixme(ctx, &expr->node.loc, "SM4 equality between \"%s\".\n", debug_hlsl_type(ctx, src_type)); + break; + } + break; + } + + default: + hlsl_fixme(ctx, &expr->node.loc, "SM4 bool \"%s\" expression.\n", debug_hlsl_expr_op(expr->op)); + break; + } + break; + } + default: { struct vkd3d_string_buffer *string; -- 2.34.1

3 11

[PATCH vkd3d v4 05/10] vkd3d-shader/hlsl: Add Gather methods with offset and tests.
by Francisco Casas 19 Jan '22

19 Jan '22

Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- Makefile.am | 4 + libs/vkd3d-shader/hlsl.c | 4 + libs/vkd3d-shader/hlsl.h | 4 + libs/vkd3d-shader/hlsl.y | 106 ++++++++++++++++++++++++++ libs/vkd3d-shader/hlsl_sm4.c | 61 +++++++++++++++ tests/hlsl-gather-offset.shader_test | 93 +++++++++++++++++++++++ tests/hlsl-gather.shader_test | 107 +++++++++++++++++++++++++++ 7 files changed, 379 insertions(+) create mode 100644 tests/hlsl-gather-offset.shader_test create mode 100644 tests/hlsl-gather.shader_test diff --git a/Makefile.am b/Makefile.am index 16848f5a..749df363 100644 --- a/Makefile.am +++ b/Makefile.am @@ -68,6 +68,8 @@ vkd3d_shader_tests = \ tests/hlsl-duplicate-modifiers.shader_test \ tests/hlsl-for.shader_test \ tests/hlsl-function-overload.shader_test \ + tests/hlsl-gather-offset.shader_test \ + tests/hlsl-gather.shader_test \ tests/hlsl-invalid.shader_test \ tests/hlsl-majority-pragma.shader_test \ tests/hlsl-majority-typedef.shader_test \ @@ -294,6 +296,8 @@ XFAIL_TESTS = \ tests/hlsl-duplicate-modifiers.shader_test \ tests/hlsl-for.shader_test \ tests/hlsl-function-overload.shader_test \ + tests/hlsl-gather-offset.shader_test \ + tests/hlsl-gather.shader_test \ tests/hlsl-majority-pragma.shader_test \ tests/hlsl-majority-typedef.shader_test \ tests/hlsl-nested-arrays.shader_test \ diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index b426e461..3ace7462 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1277,6 +1277,10 @@ static void dump_ir_resource_load(struct vkd3d_string_buffer *buffer, const stru { [HLSL_RESOURCE_LOAD] = "load_resource", [HLSL_RESOURCE_SAMPLE] = "sample", + [HLSL_RESOURCE_GATHER_RED] = "gather_red", + [HLSL_RESOURCE_GATHER_GREEN] = "gather_green", + [HLSL_RESOURCE_GATHER_BLUE] = "gather_blue", + [HLSL_RESOURCE_GATHER_ALPHA] = "gather_alpha", }; vkd3d_string_buffer_printf(buffer, "%s(resource = ", type_names[load->load_type]); diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 2396adb4..49fa8d9d 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -378,6 +378,10 @@ enum hlsl_resource_load_type { HLSL_RESOURCE_LOAD, HLSL_RESOURCE_SAMPLE, + HLSL_RESOURCE_GATHER_RED, + HLSL_RESOURCE_GATHER_GREEN, + HLSL_RESOURCE_GATHER_BLUE, + HLSL_RESOURCE_GATHER_ALPHA, }; struct hlsl_ir_resource_load diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 3a0ddb93..a321789c 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1930,6 +1930,112 @@ static bool add_method_call(struct hlsl_ctx *ctx, struct list *instrs, struct hl list_add_tail(instrs, &load->node.entry); return true; } + else if (!strcmp(name, "Gather") || !strcmp(name, "GatherRed") || !strcmp(name, "GatherBlue") + || !strcmp(name, "GatherGreen") || !strcmp(name, "GatherAlpha")) + { + const unsigned int sampler_dim = sampler_dim_count(object_type->sampler_dim); + enum hlsl_resource_load_type load_type; + const struct hlsl_type *sampler_type; + struct hlsl_ir_resource_load *load; + struct hlsl_ir_node *offset = NULL; + struct hlsl_ir_load *sampler_load; + struct hlsl_type *result_type; + struct hlsl_ir_node *coords; + int status_out_arg; + int read_channel; + + if (!strcmp(name, "GatherGreen")) + { + load_type = HLSL_RESOURCE_GATHER_GREEN; + read_channel = 1; + } + else if (!strcmp(name, "GatherBlue")) + { + load_type = HLSL_RESOURCE_GATHER_BLUE; + read_channel = 2; + } + else if (!strcmp(name, "GatherAlpha")) + { + load_type = HLSL_RESOURCE_GATHER_ALPHA; + read_channel = 3; + } + else + { + load_type = HLSL_RESOURCE_GATHER_RED; + read_channel = 0; + } + + + if (!strcmp(name, "Gather")) + { + if (params->args_count != 2 && params->args_count != 3) + { + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT, + "Wrong number of arguments to method 'Gather': expected 2 or 3, but got %u.", params->args_count); + return false; + } + } + else if (params->args_count < 2 || params->args_count == 5 || params->args_count > 7) + { + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT, + "Wrong number of arguments to method '%s': expected 2,3,4,6 or 7, but got %u.", name, params->args_count); + return false; + } + + status_out_arg = -1; + if (params->args_count == 4) + status_out_arg = 3; + if (params->args_count == 7) + status_out_arg = 6; + if (status_out_arg != -1) + hlsl_fixme(ctx, loc, "Ignoring 'status' output parameter.\n"); + + if (params->args_count == 6 || params->args_count == 7) + hlsl_fixme(ctx, loc, "Ignoring multiple offset parameters.\n"); + + if (params->args_count == 3 || params->args_count == 4) + { + if (!(offset = add_implicit_conversion(ctx, instrs, params->args[2], + hlsl_get_vector_type(ctx, HLSL_TYPE_INT, sampler_dim), loc))) + return false; + } + + sampler_type = params->args[0]->data_type; + if (sampler_type->type != HLSL_CLASS_OBJECT || sampler_type->base_type != HLSL_TYPE_SAMPLER + || sampler_type->sampler_dim != HLSL_SAMPLER_DIM_GENERIC) + { + struct vkd3d_string_buffer *string; + + if ((string = hlsl_type_to_string(ctx, sampler_type))) + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, + "Wrong type for argument 0 of %s(): expected 'sampler', but got '%s'.", name, string->buffer); + hlsl_release_string_buffer(ctx, string); + return false; + } + + if (read_channel >= object_type->e.resource_format->dimx) + { + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, + "Method %s() requires at least %d channels.", name, read_channel+1); + return false; + } + + result_type = hlsl_get_vector_type(ctx, object_type->e.resource_format->base_type, 4); + + /* Only HLSL_IR_LOAD can return an object. */ + sampler_load = hlsl_ir_load(params->args[0]); + + if (!(coords = add_implicit_conversion(ctx, instrs, params->args[1], + hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, sampler_dim), loc))) + return false; + + if (!(load = hlsl_new_resource_load(ctx, result_type, + load_type, object_load->src.var, object_load->src.offset.node, + sampler_load->src.var, sampler_load->src.offset.node, coords, offset, loc))) + return false; + list_add_tail(instrs, &load->node.entry); + return true; + } else { struct vkd3d_string_buffer *string; diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index d55815f1..61247031 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -1661,6 +1661,50 @@ static void write_sm4_loop(struct hlsl_ctx *ctx, write_sm4_instruction(buffer, &instr); } + +static void write_sm4_gather(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, + const struct hlsl_type *resource_type, const struct hlsl_ir_node *dst, + const struct hlsl_deref *resource, const struct hlsl_deref *sampler, const struct hlsl_ir_node *coords, + unsigned int swizzle, const struct hlsl_ir_node *texel_offset) +{ + struct sm4_instruction instr; + unsigned int writemask; + + memset(&instr, 0, sizeof(instr)); + + /* TODO: possible optimization, if the offset ranges from -8 to 7, an VKD3D_SM4_OP_GATHER4 with + an aoffimmi modifier can be used. */ + instr.opcode = texel_offset? VKD3D_SM5_OP_GATHER4_PO : VKD3D_SM4_OP_GATHER4; + + sm4_register_from_node(&instr.dsts[0].reg, &instr.dsts[0].writemask, NULL, dst); + instr.dst_count = 1; + + instr.src_count = (instr.opcode == VKD3D_SM5_OP_GATHER4_PO)? 4 : 3; + + sm4_register_from_node(&instr.srcs[0].reg, &writemask, &instr.srcs[0].swizzle_type, coords); + instr.srcs[0].swizzle = hlsl_swizzle_from_writemask(writemask); + + if (texel_offset) + { + sm4_register_from_node(&instr.srcs[1].reg, &writemask, &instr.srcs[1].swizzle_type, texel_offset); + instr.srcs[1].swizzle = hlsl_swizzle_from_writemask(writemask); + } + + sm4_register_from_deref(ctx, &instr.srcs[instr.src_count-2].reg, &writemask, + &instr.srcs[instr.src_count-2].swizzle_type, resource, resource_type); + instr.srcs[instr.src_count-2].swizzle = hlsl_map_swizzle(hlsl_swizzle_from_writemask(writemask), instr.dsts[0].writemask); + + sm4_register_from_deref(ctx, &instr.srcs[instr.src_count-1].reg, &writemask, NULL, + sampler, sampler->var->data_type); + instr.srcs[instr.src_count-1].reg.type = VKD3D_SM4_RT_SAMPLER; + instr.srcs[instr.src_count-1].reg.dim = VKD3D_SM4_DIMENSION_VEC4; + instr.srcs[instr.src_count-1].swizzle_type = VKD3D_SM4_SWIZZLE_SCALAR; + instr.srcs[instr.src_count-1].swizzle = swizzle; + + write_sm4_instruction(buffer, &instr); +} + + static void write_sm4_resource_load(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, const struct hlsl_ir_resource_load *load) { @@ -1701,6 +1745,23 @@ static void write_sm4_resource_load(struct hlsl_ctx *ctx, write_sm4_sample(ctx, buffer, resource_type, &load->node, &load->resource, &load->sampler, coords, texel_offset); break; + + case HLSL_RESOURCE_GATHER_RED: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(X, X, X, X), texel_offset); + break; + case HLSL_RESOURCE_GATHER_GREEN: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(Y, Y, Y, Y), texel_offset); + break; + case HLSL_RESOURCE_GATHER_BLUE: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(Z, Z, Z, Z), texel_offset); + break; + case HLSL_RESOURCE_GATHER_ALPHA: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(W, W, W, W), texel_offset); + break; } } diff --git a/tests/hlsl-gather-offset.shader_test b/tests/hlsl-gather-offset.shader_test new file mode 100644 index 00000000..d7e1a233 --- /dev/null +++ b/tests/hlsl-gather-offset.shader_test @@ -0,0 +1,93 @@ +[sampler 0] +filter linear linear linear +address clamp clamp clamp + +[texture 0] +size (3, 3) +0.0 0.0 0.0 0.4 0.1 0.0 0.5 0.0 0.2 0.0 0.0 0.4 +0.0 0.1 0.5 0.0 0.1 0.1 0.0 0.4 0.2 0.1 0.5 0.0 +0.0 0.2 0.0 0.4 0.1 0.2 0.5 0.0 0.2 0.2 0.0 0.4 + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.Gather(s, float2(0.2, 0.2), int2(1, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.2, 0.2, 0.1) + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherRed(s, float2(0.6, 0.6), int2(-1, 0)); +} + +[test] +draw quad +probe all rgba (0.0, 0.1, 0.1, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.2, 0.2), int2(0, 1)); +} + +[test] +draw quad +probe all rgba (0.2, 0.2, 0.1, 0.1) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.8, 0.8), int2(-1, -1)); +} + +[test] +draw quad +probe all rgba (0.1, 0.1, 0.0, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherBlue(s, float2(0.2, 0.8), int2(1, 0)); +} + +[test] +draw quad +probe all rgba (0.5, 0.0, 0.5, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherAlpha(s, float2(0.2, 0.8), int2(0, -1)); +} + +[test] +draw quad +probe all rgba (0.0, 0.4, 0.0, 0.4) diff --git a/tests/hlsl-gather.shader_test b/tests/hlsl-gather.shader_test new file mode 100644 index 00000000..2682c6ef --- /dev/null +++ b/tests/hlsl-gather.shader_test @@ -0,0 +1,107 @@ +[sampler 0] +filter linear linear linear +address clamp clamp clamp + +[texture 0] +size (3, 3) +0.0 0.0 0.0 0.4 0.1 0.0 0.5 0.0 0.2 0.0 0.0 0.4 +0.0 0.1 0.5 0.0 0.1 0.1 0.0 0.4 0.2 0.1 0.5 0.0 +0.0 0.2 0.0 0.4 0.1 0.2 0.5 0.0 0.2 0.2 0.0 0.4 + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.Gather(s, float2(0.2, 0.2)); +} + +[test] +draw quad +probe all rgba (0.0, 0.1, 0.1, 0.0) + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherRed(s, float2(0.6, 0.6), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.2, 0.2, 0.1) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.2, 0.2), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.1, 0.0, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.8, 0.8)); +} + +[test] +draw quad +probe all rgba (0.2, 0.2, 0.1, 0.1) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.2, 0.2), int2(0, 0), int2(0, 0), int2(0, 0), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.1, 0.0, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherBlue(s, float2(0.2, 0.8), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.0, 0.5, 0.0, 0.5) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherAlpha(s, float2(0.2, 0.8), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.4, 0.0, 0.4, 0.0) -- 2.25.1

2 1

[PATCH vkd3d v3 10/12] vkd3d-shader/hlsl: Include new texture dimension types in sampler_dim_count().
by Francisco Casas 19 Jan '22

19 Jan '22

This function is also moved from hlsl.y to hlsl.h, since it can be useful in other files. Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- This is done in preparation for changing write_sm4_ld() in hlsl_sm4.c. Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.h | 23 +++++++++++++++++++++++ libs/vkd3d-shader/hlsl.y | 17 ----------------- 2 files changed, 23 insertions(+), 17 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 334610df..927dca02 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -107,6 +107,29 @@ enum hlsl_sampler_dim HLSL_SAMPLER_DIM_MAX = HLSL_SAMPLER_DIM_CUBEARRAY, }; +static inline unsigned int sampler_dim_count(enum hlsl_sampler_dim dim) +{ + switch (dim) + { + case HLSL_SAMPLER_DIM_1D: + return 1; + case HLSL_SAMPLER_DIM_1DARRAY: + case HLSL_SAMPLER_DIM_2D: + case HLSL_SAMPLER_DIM_2DMS: + return 2; + case HLSL_SAMPLER_DIM_2DARRAY: + case HLSL_SAMPLER_DIM_2DMSARRAY: + case HLSL_SAMPLER_DIM_3D: + case HLSL_SAMPLER_DIM_CUBE: + return 3; + case HLSL_SAMPLER_DIM_CUBEARRAY: + return 4; + default: + assert(0); + return 0; + } +} + enum hlsl_matrix_majority { HLSL_COLUMN_MAJOR, diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index b7446454..389ff057 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1513,23 +1513,6 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t return statements_list; } -static unsigned int sampler_dim_count(enum hlsl_sampler_dim dim) -{ - switch (dim) - { - case HLSL_SAMPLER_DIM_1D: - return 1; - case HLSL_SAMPLER_DIM_2D: - return 2; - case HLSL_SAMPLER_DIM_3D: - case HLSL_SAMPLER_DIM_CUBE: - return 3; - default: - assert(0); - return 0; - } -} - struct find_function_call_args { const struct parse_initializer *params; -- 2.25.1

3 3

[PATCH vkd3d] vkd3d-shader/hlsl: Support casts between all numeric types on constant folding.
by Francisco Casas 18 Jan '22

18 Jan '22

Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- This is a proposal to handle all numeric constants in the same way. Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- Makefile.am | 1 - libs/vkd3d-shader/hlsl.c | 54 ++++++++++++++++++++++++++++++++ libs/vkd3d-shader/hlsl.h | 3 ++ libs/vkd3d-shader/hlsl_codegen.c | 48 ++++++++++------------------ 4 files changed, 73 insertions(+), 33 deletions(-) diff --git a/Makefile.am b/Makefile.am index 20fee06d..39003dfa 100644 --- a/Makefile.am +++ b/Makefile.am @@ -304,7 +304,6 @@ XFAIL_TESTS = \ tests/hlsl-storage-qualifiers.shader_test \ tests/hlsl-vector-indexing.shader_test \ tests/hlsl-vector-indexing-uniform.shader_test \ - tests/max.shader_test \ tests/sampler.shader_test \ tests/texture-load.shader_test \ tests/texture-load-typed.shader_test \ diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index d2ea4c34..a44b638e 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1663,6 +1663,60 @@ unsigned int hlsl_combine_swizzles(unsigned int first, unsigned int second, unsi return ret; } +void hlsl_cast_constant_value(struct hlsl_ir_constant *con, enum hlsl_base_type current, + enum hlsl_base_type target){ + uint32_t u; int32_t i; float f; double d; + + assert(con); + for (int k = 0; k < 4; k++) + { + switch (current) + { + case HLSL_TYPE_FLOAT: + case HLSL_TYPE_HALF: + u = con->value[k].f; i = con->value[k].f; f = con->value[k].f; d = con->value[k].f; + break; + case HLSL_TYPE_DOUBLE: + u = con->value[k].d; i = con->value[k].d; f = con->value[k].d; d = con->value[k].d; + break; + case HLSL_TYPE_INT: + u = con->value[k].i; i = con->value[k].i; f = con->value[k].i; d = con->value[k].i; + break; + case HLSL_TYPE_UINT: + u = con->value[k].u; i = con->value[k].u; f = con->value[k].u; d = con->value[k].u; + break; + case HLSL_TYPE_BOOL: + u = !!con->value[k].u; i = !!con->value[k].u; f = !!con->value[k].u; d = !!con->value[k].u; + break; + default: + assert(0); + break; + } + switch (target) + { + case HLSL_TYPE_FLOAT: + case HLSL_TYPE_HALF: + con->value[k].f = f; + break; + case HLSL_TYPE_DOUBLE: + con->value[k].d = d; + break; + case HLSL_TYPE_INT: + con->value[k].i = i; + break; + case HLSL_TYPE_UINT: + con->value[k].u = u; + break; + case HLSL_TYPE_BOOL: + con->value[k].u = (!!u) * 0xffffffff; + break; + default: + assert(0); + break; + } + } +} + static const struct hlsl_profile_info *get_target_info(const char *target) { unsigned int i; diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 57acf3a0..a07ccf17 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -755,6 +755,9 @@ unsigned int hlsl_combine_writemasks(unsigned int first, unsigned int second); unsigned int hlsl_map_swizzle(unsigned int swizzle, unsigned int writemask); unsigned int hlsl_swizzle_from_writemask(unsigned int writemask); +void hlsl_cast_constant_value(struct hlsl_ir_constant *con, enum hlsl_base_type current, + enum hlsl_base_type target); + bool hlsl_offset_from_deref(const struct hlsl_deref *deref, unsigned int *offset); unsigned int hlsl_offset_from_deref_safe(struct hlsl_ctx *ctx, const struct hlsl_deref *deref); struct hlsl_reg hlsl_reg_from_deref(struct hlsl_ctx *ctx, const struct hlsl_deref *deref, diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 75716bdf..ef627f2b 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -656,7 +656,7 @@ static bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, voi { struct hlsl_ir_constant *arg1, *arg2 = NULL, *res; struct hlsl_ir_expr *expr; - unsigned int i, dimx; + unsigned int i; if (instr->type != HLSL_IR_EXPR) return false; @@ -670,48 +670,32 @@ static bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, voi arg1 = hlsl_ir_constant(expr->operands[0].node); if (expr->operands[1].node) arg2 = hlsl_ir_constant(expr->operands[1].node); - dimx = instr->data_type->dimx; if (!(res = hlsl_alloc(ctx, sizeof(*res)))) return false; init_node(&res->node, HLSL_IR_CONSTANT, instr->data_type, instr->loc); + if (expr->op == HLSL_OP1_CAST && instr->data_type->base_type <= HLSL_TYPE_LAST_SCALAR) + { + if (instr->data_type->dimx != arg1->node.data_type->dimx + || instr->data_type->dimy != arg1->node.data_type->dimy) + { + WARN("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), + debug_hlsl_type(ctx, instr->data_type)); + } + memcpy(res->value, arg1->value, sizeof(res->value)); + hlsl_cast_constant_value(res, arg1->node.data_type->base_type, instr->data_type->base_type); + list_add_before(&expr->node.entry, &res->node.entry); + replace_node(&expr->node, &res->node); + return res; + } + switch (instr->data_type->base_type) { case HLSL_TYPE_FLOAT: { switch (expr->op) { - case HLSL_OP1_CAST: - if (instr->data_type->dimx != arg1->node.data_type->dimx - || instr->data_type->dimy != arg1->node.data_type->dimy) - { - FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), - debug_hlsl_type(ctx, instr->data_type)); - vkd3d_free(res); - return false; - } - - switch (arg1->node.data_type->base_type) - { - case HLSL_TYPE_INT: - for (i = 0; i < dimx; ++i) - res->value[i].f = arg1->value[i].i; - break; - - case HLSL_TYPE_UINT: - for (i = 0; i < dimx; ++i) - res->value[i].f = arg1->value[i].u; - break; - - default: - FIXME("Cast from %s to %s.\n", debug_hlsl_type(ctx, arg1->node.data_type), - debug_hlsl_type(ctx, instr->data_type)); - vkd3d_free(res); - return false; - } - break; - default: FIXME("Fold float op %#x.\n", expr->op); vkd3d_free(res); -- 2.25.1

3 8

[PATCH 1/2] dwrite/tests: Add some tests for Segoe UI font family.
by Dmitry Timoshkov 13 Jan '22

13 Jan '22

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/dwrite/tests/layout.c | 139 +++++++++++++++++++++++++++++++++++++ 1 file changed, 139 insertions(+) diff --git a/dlls/dwrite/tests/layout.c b/dlls/dwrite/tests/layout.c index 3fe149927ca..c242155cce3 100644 --- a/dlls/dwrite/tests/layout.c +++ b/dlls/dwrite/tests/layout.c @@ -6489,6 +6489,144 @@ if (SUCCEEDED(hr)) IDWriteFactory_Release(factory); } +#define get_font_name(a, b, c) get_font_name_(a, b, c, __LINE__) +static void get_font_name_(IDWriteFont *font, WCHAR *name, UINT32 size, int line) +{ + HRESULT hr; + IDWriteFontFamily *family; + IDWriteLocalizedStrings *names; + UINT32 index; + BOOL exists; + + hr = IDWriteFont_GetFontFamily(font, &family); + ok_(__FILE__, line)(hr == S_OK, "got %#x\n", hr); + + hr = IDWriteFontFamily_GetFamilyNames(family, &names); + ok_(__FILE__, line)(hr == S_OK, "got %#x\n", hr); + + hr = IDWriteLocalizedStrings_FindLocaleName(names, L"en-us", &index, &exists); + ok_(__FILE__, line)(hr == S_OK, "got %#x\n", hr); + ok_(__FILE__, line)(index != UINT_MAX && exists, "name was not found\n"); + hr = IDWriteLocalizedStrings_GetString(names, index, name, size); + ok_(__FILE__, line)(hr == S_OK, "got %#x\n", hr); + + IDWriteLocalizedStrings_Release(names); + IDWriteFontFamily_Release(family); +} + +static void test_SegoeUI(void) +{ + static const WCHAR *families[] = { L"Tahoma", L"Segoe UI", NULL }; + static const WCHAR text[] = { 0x25d4, 0 }; + HRESULT hr; + IDWriteFactory2 *factory; + IDWriteFontCollection *collection; + IDWriteFontFamily *family; + IDWriteFont *font; + IDWriteFontFallback *fallback; + UINT32 index, count, i, mappedlength; + WCHAR name[256]; + BOOL exists, found; + FLOAT scale; + + hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, &IID_IDWriteFactory2, (IUnknown **)&factory); + if (hr != S_OK) + { + win_skip("IDWriteFactory2 is not supported\n"); + return; + } + + hr = IDWriteFactory2_GetSystemFontCollection(factory, &collection, FALSE); + ok(hr == S_OK, "got %#x\n", hr); + + hr = IDWriteFontCollection_FindFamilyName(collection, L"Segoe UI", &index, &exists); + ok(hr == S_OK, "got %#x\n", hr); + if (!exists) + { + skip("Segoe UI is not installed\n"); + IDWriteFontCollection_Release(collection); + IDWriteFactory2_Release(factory); + return; + } + ok(index != UINT_MAX && exists, "Segoe UI was not found\n"); + + hr = IDWriteFontCollection_GetFontFamily(collection, index, &family); + ok(hr == S_OK, "got %#x\n", hr); + + count = IDWriteFontFamily_GetFontCount(family); + trace("family Segoe UI has %u fonts\n", count); + + found = FALSE; + + for (i = 0; i < count; i++) + { + hr = IDWriteFontFamily_GetFont(family, i, &font); + ok(hr == S_OK, "got %#x\n", hr); + + get_font_name(font, name, ARRAY_SIZE(name)); + if (!wcscmp(name, L"Segoe UI Symbol")) + found = TRUE; + + hr = IDWriteFont_HasCharacter(font, 0x25d4, &exists); + ok(hr == S_OK, "got %#x\n", hr); + ok(!exists, "%u: %s has character 0x25d4\n", i, wine_dbgstr_w(name)); + + IDWriteFont_Release(font); + } + + ok(!found, "Segoe UI Symbol should not be part of Segoe UI family\n"); + + IDWriteFontFamily_Release(family); + + hr = IDWriteFactory2_GetSystemFontFallback(factory, &fallback); + ok(hr == S_OK, "got %#x\n", hr); + + g_source = text; + + hr = IDWriteFontFallback_MapCharacters(fallback, &analysissource, 0, 1, collection, L"Segoe UI", DWRITE_FONT_WEIGHT_NORMAL, + DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, &mappedlength, &font, &scale); + ok(hr == S_OK, "got %#x\n", hr); + ok(mappedlength == 1, "got %u\n", mappedlength); + ok(scale == 1.0f, "got %f\n", scale); + + get_font_name(font, name, ARRAY_SIZE(name)); +todo_wine + ok(!wcscmp(name, L"Segoe UI Symbol"), "got %s\n", wine_dbgstr_w(name)); + + hr = IDWriteFont_HasCharacter(font, 0x25d4, &exists); + ok(hr == S_OK, "got %#x\n", hr); +todo_wine + ok(exists, "%s should have character 0x25d4\n", wine_dbgstr_w(name)); + + IDWriteFont_Release(font); + + for (i = 0; i < ARRAY_SIZE(families); i++) + { + hr = IDWriteFontFallback_MapCharacters(fallback, &analysissource, 0, 1, collection, families[i], DWRITE_FONT_WEIGHT_NORMAL, + DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, &mappedlength, &font, &scale); +todo_wine_if(families[i] == NULL) + ok(hr == S_OK, "%u: %s - got %#x\n", i, wine_dbgstr_w(families[i]), hr); + if (hr != S_OK) continue; + ok(mappedlength == 1, "got %u\n", mappedlength); + ok(scale == 1.0f, "got %f\n", scale); + + get_font_name(font, name, ARRAY_SIZE(name)); +todo_wine + ok(!wcscmp(name, L"Segoe UI Symbol"), "got %s\n", wine_dbgstr_w(name)); + + hr = IDWriteFont_HasCharacter(font, 0x25d4, &exists); + ok(hr == S_OK, "got %#x\n", hr); +todo_wine + ok(exists, "%s should have character 0x25d4\n", wine_dbgstr_w(name)); + + IDWriteFont_Release(font); + } + + IDWriteFontFallback_Release(fallback); + IDWriteFontCollection_Release(collection); + IDWriteFactory2_Release(factory); +} + START_TEST(layout) { IDWriteFactory *factory; @@ -6544,6 +6682,7 @@ START_TEST(layout) test_text_format_axes(); test_layout_range_length(); test_HitTestTextRange(); + test_SegoeUI(); IDWriteFactory_Release(factory); } -- 2.34.1

2 6

[PATCH v4] combase: Reorder hstring_private elements.
by Bernhard Kölbl 12 Jan '22

12 Jan '22

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51017 Debugging sessions and the official WinRT SDK show, that hstrings are aligned differently in memory, than they are currently used in Wine. E.g. The string buffer is stored at the end of hstring_private. Also if a string reference is created with WindowsCreateStringReference, a seperate pointer is used to point at the string-source. Signed-off-by: Bernhard Kölbl <besentv(a)gmail.com> --- v4: Remove leftover debugging TRACE and minor style changes. v3: Add nested hstring_header struct to hstring_private and add a test for both. v2: I was mistaken about no reference counting being used. --- dlls/combase/string.c | 126 ++++++++++++++++++++++-------------- dlls/combase/tests/string.c | 73 ++++++++++++++++++++- 2 files changed, 150 insertions(+), 49 deletions(-) diff --git a/dlls/combase/string.c b/dlls/combase/string.c index 2092e4360a3..1677915c244 100644 --- a/dlls/combase/string.c +++ b/dlls/combase/string.c @@ -26,44 +26,58 @@ WINE_DEFAULT_DEBUG_CHANNEL(winstring); -struct hstring_private +#define HSTRING_REFERENCE_FLAG 1 + +struct hstring_header { - LPWSTR buffer; + UINT32 flags; UINT32 length; - BOOL reference; - LONG refcount; + UINT32 padding1; + UINT32 padding2; + const WCHAR *ptr; }; +struct hstring_private +{ + struct hstring_header header; + LONG refcount; + WCHAR buffer[1]; +}; + + static const WCHAR empty[1]; -C_ASSERT(sizeof(struct hstring_private) <= sizeof(HSTRING_HEADER)); +C_ASSERT(sizeof(struct hstring_header) <= sizeof(HSTRING_HEADER)); static inline struct hstring_private *impl_from_HSTRING(HSTRING string) { - return (struct hstring_private *)string; + return (struct hstring_private *)string; } static inline struct hstring_private *impl_from_HSTRING_HEADER(HSTRING_HEADER *header) { - return (struct hstring_private *)header; + return CONTAINING_RECORD(header, struct hstring_private, header); } static inline struct hstring_private *impl_from_HSTRING_BUFFER(HSTRING_BUFFER buffer) { - return (struct hstring_private *)buffer; + return CONTAINING_RECORD(buffer, struct hstring_private, buffer); } static BOOL alloc_string(UINT32 len, HSTRING *out) { struct hstring_private *priv; - priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv) + (len + 1) * sizeof(*priv->buffer)); + priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv) + len * sizeof(*priv->buffer)); if (!priv) return FALSE; - priv->buffer = (LPWSTR)(priv + 1); - priv->length = len; - priv->reference = FALSE; + + priv->header.flags = 0; + priv->header.length = len; + priv->header.ptr = priv->buffer; + priv->refcount = 1; priv->buffer[len] = '\0'; + *out = (HSTRING)priv; return TRUE; } @@ -115,10 +129,12 @@ HRESULT WINAPI WindowsCreateStringReference(LPCWSTR ptr, UINT32 len, } if (ptr == NULL) return E_POINTER; - priv->buffer = (LPWSTR)ptr; - priv->length = len; - priv->reference = TRUE; - *out = (HSTRING)header; + + priv->header.ptr = (LPWSTR)ptr; + priv->header.length = len; + priv->header.flags = HSTRING_REFERENCE_FLAG; + + *out = (HSTRING)priv; return S_OK; } @@ -127,16 +143,21 @@ HRESULT WINAPI WindowsCreateStringReference(LPCWSTR ptr, UINT32 len, */ HRESULT WINAPI WindowsDeleteString(HSTRING str) { - struct hstring_private *priv = impl_from_HSTRING(str); + struct hstring_private *priv; TRACE("(%p)\n", str); if (str == NULL) return S_OK; - if (priv->reference) + + priv = impl_from_HSTRING(str); + + if(priv->header.flags == HSTRING_REFERENCE_FLAG) return S_OK; + if (InterlockedDecrement(&priv->refcount) == 0) HeapFree(GetProcessHeap(), 0, priv); + return S_OK; } @@ -156,8 +177,8 @@ HRESULT WINAPI WindowsDuplicateString(HSTRING str, HSTRING *out) *out = NULL; return S_OK; } - if (priv->reference) - return WindowsCreateString(priv->buffer, priv->length, out); + if (priv->header.flags == HSTRING_REFERENCE_FLAG) + return WindowsCreateString(priv->header.ptr, priv->header.length, out); InterlockedIncrement(&priv->refcount); *out = str; return S_OK; @@ -187,7 +208,7 @@ HRESULT WINAPI WindowsPreallocateStringBuffer(UINT32 len, WCHAR **outptr, return E_OUTOFMEMORY; priv = impl_from_HSTRING(str); *outptr = priv->buffer; - *out = (HSTRING_BUFFER)str; + *out = (HSTRING_BUFFER)&priv->buffer; return S_OK; } @@ -196,9 +217,17 @@ HRESULT WINAPI WindowsPreallocateStringBuffer(UINT32 len, WCHAR **outptr, */ HRESULT WINAPI WindowsDeleteStringBuffer(HSTRING_BUFFER buf) { + + struct hstring_private *priv; + TRACE("(%p)\n", buf); - return WindowsDeleteString((HSTRING)buf); + if(buf) + priv = impl_from_HSTRING_BUFFER(buf); + else + priv = NULL; + + return WindowsDeleteString((HSTRING)priv); } /*********************************************************************** @@ -217,9 +246,9 @@ HRESULT WINAPI WindowsPromoteStringBuffer(HSTRING_BUFFER buf, HSTRING *out) *out = NULL; return S_OK; } - if (priv->buffer[priv->length] != 0 || priv->reference || priv->refcount != 1) + if (priv->buffer[priv->header.length] != 0 || priv->header.flags == HSTRING_REFERENCE_FLAG || priv->refcount != 1) return E_INVALIDARG; - *out = (HSTRING)buf; + *out = (HSTRING)priv; return S_OK; } @@ -234,7 +263,7 @@ UINT32 WINAPI WindowsGetStringLen(HSTRING str) if (str == NULL) return 0; - return priv->length; + return priv->header.length; } /*********************************************************************** @@ -253,8 +282,9 @@ LPCWSTR WINAPI WindowsGetStringRawBuffer(HSTRING str, UINT32 *len) return empty; } if (len) - *len = priv->length; - return priv->buffer; + *len = priv->header.length; + + return priv->header.ptr; } /*********************************************************************** @@ -274,9 +304,9 @@ HRESULT WINAPI WindowsStringHasEmbeddedNull(HSTRING str, BOOL *out) *out = FALSE; return S_OK; } - for (i = 0; i < priv->length; i++) + for (i = 0; i < (priv->header.length); i++) { - if (priv->buffer[i] == '\0') + if (priv->header.ptr[i] == '\0') { *out = TRUE; return S_OK; @@ -305,7 +335,7 @@ HRESULT WINAPI WindowsSubstring(HSTRING str, UINT32 start, HSTRING *out) *out = NULL; return S_OK; } - return WindowsCreateString(&priv->buffer[start], len - start, out); + return WindowsCreateString(&priv->header.ptr[start], len - start, out); } /*********************************************************************** @@ -327,7 +357,7 @@ HRESULT WINAPI WindowsSubstringWithSpecifiedLength(HSTRING str, UINT32 start, UI *out = NULL; return S_OK; } - return WindowsCreateString(&priv->buffer[start], len, out); + return WindowsCreateString(&priv->header.ptr[start], len, out); } /*********************************************************************** @@ -347,16 +377,16 @@ HRESULT WINAPI WindowsConcatString(HSTRING str1, HSTRING str2, HSTRING *out) return WindowsDuplicateString(str2, out); if (str2 == NULL) return WindowsDuplicateString(str1, out); - if (!priv1->length && !priv2->length) + if (!priv1->header.length && !priv2->header.length) { *out = NULL; return S_OK; } - if (!alloc_string(priv1->length + priv2->length, out)) + if (!alloc_string(priv1->header.length + priv2->header.length, out)) return E_OUTOFMEMORY; priv = impl_from_HSTRING(*out); - memcpy(priv->buffer, priv1->buffer, priv1->length * sizeof(*priv1->buffer)); - memcpy(priv->buffer + priv1->length, priv2->buffer, priv2->length * sizeof(*priv2->buffer)); + memcpy(priv->buffer, priv1->header.ptr, priv1->header.length * sizeof(*priv1->buffer)); + memcpy(priv->buffer + priv1->header.length, priv2->header.ptr, priv2->header.length * sizeof(*priv2->buffer)); return S_OK; } @@ -371,7 +401,7 @@ BOOL WINAPI WindowsIsStringEmpty(HSTRING str) if (str == NULL) return TRUE; - return priv->length == 0; + return priv->header.length == 0; } /*********************************************************************** @@ -395,13 +425,13 @@ HRESULT WINAPI WindowsCompareStringOrdinal(HSTRING str1, HSTRING str2, INT32 *re } if (str1) { - buf1 = priv1->buffer; - len1 = priv1->length; + buf1 = priv1->header.ptr; + len1 = priv1->header.length; } if (str2) { - buf2 = priv2->buffer; - len2 = priv2->length; + buf2 = priv2->header.ptr; + len2 = priv2->header.length; } *res = CompareStringOrdinal(buf1, len1, buf2, len2, FALSE) - CSTR_EQUAL; return S_OK; @@ -418,19 +448,19 @@ HRESULT WINAPI WindowsTrimStringStart(HSTRING str1, HSTRING str2, HSTRING *out) TRACE("(%p, %p, %p)\n", str1, str2, out); - if (!out || !str2 || !priv2->length) + if (!out || !str2 || !priv2->header.length) return E_INVALIDARG; if (!str1) { *out = NULL; return S_OK; } - for (start = 0; start < priv1->length; start++) + for (start = 0; start < priv1->header.length; start++) { - if (!wmemchr(priv2->buffer, priv1->buffer[start], priv2->length)) + if (!wmemchr(priv2->header.ptr, priv1->header.ptr[start], priv2->header.length)) break; } - return start ? WindowsCreateString(&priv1->buffer[start], priv1->length - start, out) : + return start ? WindowsCreateString(&priv1->header.ptr[start], priv1->header.length - start, out) : WindowsDuplicateString(str1, out); } @@ -445,18 +475,18 @@ HRESULT WINAPI WindowsTrimStringEnd(HSTRING str1, HSTRING str2, HSTRING *out) TRACE("(%p, %p, %p)\n", str1, str2, out); - if (!out || !str2 || !priv2->length) + if (!out || !str2 || !priv2->header.length) return E_INVALIDARG; if (!str1) { *out = NULL; return S_OK; } - for (len = priv1->length; len > 0; len--) + for (len = priv1->header.length; len > 0; len--) { - if (!wmemchr(priv2->buffer, priv1->buffer[len - 1], priv2->length)) + if (!wmemchr(priv2->header.ptr, priv1->header.ptr[len - 1], priv2->header.length)) break; } - return (len < priv1->length) ? WindowsCreateString(priv1->buffer, len, out) : + return (len < priv1->header.length) ? WindowsCreateString(priv1->header.ptr, len, out) : WindowsDuplicateString(str1, out); } diff --git a/dlls/combase/tests/string.c b/dlls/combase/tests/string.c index 5ebf669a426..bb477503a4b 100644 --- a/dlls/combase/tests/string.c +++ b/dlls/combase/tests/string.c @@ -37,7 +37,7 @@ static void _check_string(int line, HSTRING str, LPCWSTR content, UINT32 length, ok_(__FILE__, line)(WindowsIsStringEmpty(str) == empty, "WindowsIsStringEmpty failed\n"); ok_(__FILE__, line)(WindowsStringHasEmbeddedNull(str, &out_null) == S_OK, "WindowsStringHasEmbeddedNull failed\n"); - ok_(__FILE__, line)(out_null == has_null, "WindowsStringHasEmbeddedNull failed\n"); + ok_(__FILE__, line)(out_null == has_null, "WindowsStringHasEmbeddedNull failed. %d != %d \n", out_null, has_null); ok_(__FILE__, line)(WindowsGetStringLen(str) == length, "WindowsGetStringLen failed\n"); ptr = WindowsGetStringRawBuffer(str, &out_length); /* WindowsGetStringRawBuffer should return a non-null, null terminated empty string @@ -479,6 +479,76 @@ static void test_trim(void) ok(WindowsDeleteString(str1) == S_OK, "Failed to delete string\n"); } +static void test_hstring_struct(void) +{ + struct hstring_header + { + UINT32 flags; + UINT32 length; + UINT32 padding1; + UINT32 padding2; + const WCHAR *ptr; + }; + + struct hstring_private + { + struct hstring_header header; + LONG refcount; + WCHAR buffer[1]; + }; + + HSTRING str; + HSTRING str2; + HSTRING_HEADER hdr; + struct hstring_private* prv; + struct hstring_private* prv2; + + BOOL arch64 = (sizeof(void*) == 8); + + ok(arch64 ? (sizeof(prv->header) == 24) : (sizeof(prv->header) == 20), "hstring_header size incorrect.\n"); + + ok(WindowsCreateString(input_string, 6, &str) == S_OK, "Failed to create string.\n"); + + prv = CONTAINING_RECORD(str, struct hstring_private, header); + + ok(prv->header.flags == 0, "Expected 0 in flags field, got 0x%x.\n", prv->header.flags); + ok(prv->header.length == 6, "Expected 6 in length field, got %d.\n", prv->header.length); + ok(prv->header.ptr != NULL, "Unexpected nullptr in ptr field.\n"); + ok(prv->refcount == 1, "Expected 1 in refcount, got %d.\n", prv->refcount); + ok(prv->header.ptr == prv->buffer, "Expected ptr to point at buffer, instead pointing at %p.\n", prv->header.ptr); + ok(wcscmp(input_string, prv->buffer) == 0, "Strings didn't match.\n"); + + trace("hstr ptr(%p), flags(%d), length(%d), padding1(%p), padding2(%p), ptr(%p), refcount(%d), str(%ls)->addr(%p)\n", + prv, prv->header.flags, prv->header.length, &prv->header.padding1, &prv->header.padding2, + prv->header.ptr, prv->refcount, prv->buffer, prv->buffer); + + ok(WindowsDuplicateString(str, &str2) == S_OK, "Failed to duplicate string.\n"); + + prv2 = CONTAINING_RECORD(str2, struct hstring_private, header); + + ok(prv->refcount == 2, "Expected 2 in refcount, got %d.\n", prv->refcount); + ok(prv2->refcount == 2, "Expected 2 in refcount, got %d.\n", prv2->refcount); + ok(wcscmp(input_string, prv2->buffer) == 0, "Strings didn't match.\n"); + + ok(WindowsDeleteString(str) == S_OK, "Failed to delete string.\n"); + + ok(prv->refcount == 1, "Expected 1 in refcount, got %d.\n", prv->refcount); + + ok(WindowsDeleteString(str) == S_OK, "Failed to delete string.\n"); + + ok(WindowsCreateStringReference(input_string, 6, &hdr, &str) == S_OK, "Failed to create string ref.\n"); + + prv = CONTAINING_RECORD(&hdr, struct hstring_private, header); + prv2 = CONTAINING_RECORD(str, struct hstring_private, header); + + ok(prv == prv2, "Pointers not identical.\n"); + ok(prv2->header.flags == 1, "HSTRING_REFERENCE_FLAG not set.\n"); + ok(prv2->header.length == 6, "Length incorrect.\n"); + ok(prv2->header.ptr == input_string, "Pointer not pointing at input string.\n"); + + ok(WindowsDeleteString(str) == S_OK, "Failed to delete string ref.\n"); +} + START_TEST(string) { test_create_delete(); @@ -489,4 +559,5 @@ START_TEST(string) test_concat(); test_compare(); test_trim(); + test_hstring_struct(); } -- 2.34.1

2 1

[PATCH vkd3d 1/5] vkd3d-shader/hlsl: Use list_empty() instead of comparing list_count() against zero.
by Zebediah Figura 11 Jan '22

11 Jan '22

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 636882c4b..5a17449a3 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -326,7 +326,7 @@ static bool append_conditional_break(struct hlsl_ctx *ctx, struct list *cond_lis struct hlsl_ir_if *iff; /* E.g. "for (i = 0; ; ++i)". */ - if (!list_count(cond_list)) + if (list_empty(cond_list)) return true; condition = node_from_list(cond_list); -- 2.34.1

5 13

[PATCH vkd3d 1/4] vkd3d-shader: Do not validate the target type in vkd3d_shader_scan().
by Zebediah Figura 11 Jan '22

11 Jan '22

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/vkd3d_shader_main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 3982d0730..47fe3d60d 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -1025,7 +1025,7 @@ int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char if (messages) *messages = NULL; - if ((ret = vkd3d_shader_validate_compile_info(compile_info, true)) < 0) + if ((ret = vkd3d_shader_validate_compile_info(compile_info, false)) < 0) return ret; vkd3d_shader_message_context_init(&message_context, compile_info->log_level); -- 2.34.1

5 11

[PATCH vkd3d] vkd3d-shader: Add tiled resource opcode definitions.
by Zebediah Figura 10 Jan '22

10 Jan '22

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/sm4.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/libs/vkd3d-shader/sm4.h b/libs/vkd3d-shader/sm4.h index f6b4b612d..62bb4d12b 100644 --- a/libs/vkd3d-shader/sm4.h +++ b/libs/vkd3d-shader/sm4.h @@ -354,6 +354,22 @@ enum vkd3d_sm4_opcode VKD3D_SM5_OP_DTOU = 0xd7, VKD3D_SM5_OP_ITOD = 0xd8, VKD3D_SM5_OP_UTOD = 0xd9, + VKD3D_SM5_OP_GATHER4_S = 0xdb, + VKD3D_SM5_OP_GATHER4_C_S = 0xdc, + VKD3D_SM5_OP_GATHER4_PO_S = 0xdd, + VKD3D_SM5_OP_GATHER4_PO_C_S = 0xde, + VKD3D_SM5_OP_LD_S = 0xdf, + VKD3D_SM5_OP_LD2DMS_S = 0xe0, + VKD3D_SM5_OP_LD_UAV_TYPED_S = 0xe1, + VKD3D_SM5_OP_LD_RAW_S = 0xe2, + VKD3D_SM5_OP_LD_STRUCTURED_S = 0xe3, + VKD3D_SM5_OP_SAMPLE_LOD_S = 0xe4, + VKD3D_SM5_OP_SAMPLE_C_LZ_S = 0xe5, + VKD3D_SM5_OP_SAMPLE_CL_S = 0xe6, + VKD3D_SM5_OP_SAMPLE_B_CL_S = 0xe7, + VKD3D_SM5_OP_SAMPLE_GRAD_CL_S = 0xe8, + VKD3D_SM5_OP_SAMPLE_C_CL_S = 0xe9, + VKD3D_SM5_OP_CHECK_ACCESS_FULLY_MAPPED = 0xea, }; enum vkd3d_sm4_instruction_modifier -- 2.34.1

4 3

[PATCH v3 1/2] server: Terminating '\' in the registry root name is optional.
by Dmitry Timoshkov 10 Jan '22

10 Jan '22

v3: Check the length and reject invalid root name. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/ntdll/tests/reg.c | 2 -- server/registry.c | 62 ++++++++++++++++++++++++++++++++++++++---- 2 files changed, 56 insertions(+), 8 deletions(-) diff --git a/dlls/ntdll/tests/reg.c b/dlls/ntdll/tests/reg.c index 91b752ac069..74d82b85be4 100644 --- a/dlls/ntdll/tests/reg.c +++ b/dlls/ntdll/tests/reg.c @@ -417,7 +417,6 @@ todo_wine pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry" ); status = pNtOpenKey(&key, KEY_READ, &attr); - todo_wine ok( status == STATUS_SUCCESS, "NtOpenKey failed: 0x%08x\n", status ); pNtClose( key ); pRtlFreeUnicodeString( &str ); @@ -569,7 +568,6 @@ static void test_NtCreateKey(void) pRtlCreateUnicodeStringFromAsciiz( &str, "\\Registry" ); status = pNtCreateKey( &subkey, am, &attr, 0, 0, 0, 0 ); - todo_wine ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED, "NtCreateKey failed: 0x%08x\n", status ); if (!status) pNtClose( subkey ); diff --git a/server/registry.c b/server/registry.c index b00abdbc004..4ed3ee9896e 100644 --- a/server/registry.c +++ b/server/registry.c @@ -127,7 +127,7 @@ static const timeout_t save_period = 30 * -TICKS_PER_SEC; /* delay between peri static struct timeout_user *save_timeout_user; /* saving timer */ static enum prefix_type { PREFIX_UNKNOWN, PREFIX_32BIT, PREFIX_64BIT } prefix_type; -static const WCHAR root_name[] = { '\\','R','e','g','i','s','t','r','y','\\' }; +static const WCHAR root_name[] = { '\\','R','e','g','i','s','t','r','y' }; static const WCHAR wow6432node[] = {'W','o','w','6','4','3','2','N','o','d','e'}; static const WCHAR symlink_value[] = {'S','y','m','b','o','l','i','c','L','i','n','k','V','a','l','u','e'}; static const struct unicode_str symlink_str = { symlink_value, sizeof(symlink_value) }; @@ -411,7 +411,7 @@ static WCHAR *key_get_full_name( struct object *obj, data_size_t *ret_len ) { static const WCHAR backslash = '\\'; struct key *key = (struct key *) obj; - data_size_t len = sizeof(root_name) - sizeof(WCHAR); + data_size_t len = sizeof(root_name); char *ret; if (key->flags & KEY_DELETED) @@ -431,7 +431,7 @@ static WCHAR *key_get_full_name( struct object *obj, data_size_t *ret_len ) len -= key->namelen + sizeof(WCHAR); memcpy( ret + len, &backslash, sizeof(WCHAR) ); } - memcpy( ret, root_name, sizeof(root_name) - sizeof(WCHAR) ); + memcpy( ret, root_name, sizeof(root_name) ); return (WCHAR *)ret; } @@ -474,7 +474,7 @@ static void key_destroy( struct object *obj ) } /* get the request vararg as registry path */ -static inline void get_req_path( struct unicode_str *str, int skip_root ) +static inline struct unicode_str *get_req_path( struct unicode_str *str, int skip_root ) { str->str = get_req_data(); str->len = (get_req_data_size() / sizeof(WCHAR)) * sizeof(WCHAR); @@ -483,7 +483,19 @@ static inline void get_req_path( struct unicode_str *str, int skip_root ) { str->str += ARRAY_SIZE( root_name ); str->len -= sizeof(root_name); + if (str->len) + { + if (str->str[0] != '\\') + { + set_error( STATUS_OBJECT_PATH_INVALID ); + return NULL; + } + + str->str++; + str->len -= sizeof(WCHAR); + } } + return str; } /* return the next token in a given path */ @@ -734,6 +746,12 @@ static struct key *follow_symlink( struct key *key, int iteration ) if (memicmp_strW( path.str, root_name, sizeof(root_name) )) return NULL; path.str += ARRAY_SIZE( root_name ); path.len -= sizeof(root_name); + if (path.len) + { + if (path.str[0] != '\\') return NULL; + path.str++; + path.len -= sizeof(WCHAR); + } key = root_key; token.str = NULL; @@ -2156,6 +2174,17 @@ DECL_HANDLER(create_key) { name.str += ARRAY_SIZE( root_name ); name.len -= sizeof(root_name); + if (name.len) + { + if (name.str[0] != '\\') + { + set_error( STATUS_OBJECT_PATH_INVALID ); + return; + } + + name.str++; + name.len -= sizeof(WCHAR); + } } /* NOTE: no access rights are required from the parent handle to create a key */ @@ -2184,7 +2213,12 @@ DECL_HANDLER(open_key) /* NOTE: no access rights are required to open the parent key, only the child key */ if ((parent = get_parent_hkey_obj( req->parent ))) { - get_req_path( &name, !req->parent ); + if (!get_req_path( &name, !req->parent )) + { + release_object( parent ); + return; + } + if ((key = open_key( parent, &name, access, req->attributes ))) { reply->hkey = alloc_handle( current->process, key, access, req->attributes ); @@ -2314,6 +2348,17 @@ DECL_HANDLER(load_registry) { name.str += ARRAY_SIZE( root_name ); name.len -= sizeof(root_name); + if (name.len) + { + if (name.str[0] != '\\') + { + set_error( STATUS_OBJECT_PATH_INVALID ); + return; + } + + name.str++; + name.len -= sizeof(WCHAR); + } } if ((parent = get_parent_hkey_obj( objattr->rootdir ))) @@ -2344,7 +2389,12 @@ DECL_HANDLER(unload_registry) if ((parent = get_parent_hkey_obj( req->parent ))) { - get_req_path( &name, !req->parent ); + if (!get_req_path( &name, !req->parent )) + { + release_object( parent ); + return; + } + if ((key = open_key( parent, &name, access, req->attributes ))) { if (key->obj.handle_count) -- 2.34.1

2 2

[PATCH v2 1/2] user32/tests: Add some tests for WM_NCCALCSIZE.
by Dmitry Timoshkov 10 Jan '22

10 Jan '22

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/user32/tests/win.c | 70 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 0156987f529..b93839e40b5 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -12328,6 +12328,75 @@ static void test_DragDetect(void) ok(!(GetKeyState( VK_LBUTTON ) & 0x8000), "got VK_LBUTTON\n"); } +static void test_WM_NCCALCSIZE(void) +{ + WNDCLASSA cls; + HWND hwnd; + NCCALCSIZE_PARAMS params; + WINDOWPOS winpos; + RECT client_rect, window_rect; + LRESULT ret; + + cls.style = CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW; + cls.lpfnWndProc = DefWindowProcA; + cls.cbClsExtra = 0; + cls.cbWndExtra = 0; + cls.hInstance = GetModuleHandleA(0); + cls.hIcon = 0; + cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW); + cls.hbrBackground = GetStockObject(WHITE_BRUSH); + cls.lpszMenuName = NULL; + cls.lpszClassName = "dummy_window_class"; + ret = RegisterClassA(&cls); + ok(ret, "RegisterClass error %u\n", GetLastError()); + + hwnd = CreateWindowExA(0, "dummy_window_class", NULL, + WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP, + 100, 100, 200, 200, 0, 0, GetModuleHandleA(NULL), NULL); + ok(hwnd != 0, "CreateWindowEx error %u\n", GetLastError()); + + GetWindowRect(hwnd, &window_rect); + params.rgrc[0] = window_rect; + params.rgrc[1] = window_rect; + GetClientRect(hwnd, &client_rect); + MapWindowPoints(hwnd, 0, (POINT *)&client_rect, 2); + params.rgrc[2] = client_rect; + + winpos.hwnd = hwnd; + winpos.hwndInsertAfter = HWND_TOP; + winpos.x = window_rect.left; + winpos.y = window_rect.top; + winpos.cx = window_rect.right - window_rect.left; + winpos.cy = window_rect.bottom - window_rect.top; + winpos.flags = SWP_NOMOVE; + params.lppos = &winpos; + + ret = SendMessageW(hwnd, WM_NCCALCSIZE, TRUE, (LPARAM)&params); +todo_wine + ok(!ret, "got %08x\n", ret); + ok(EqualRect(&params.rgrc[0], &client_rect), "got %s\n", wine_dbgstr_rect(&params.rgrc[0])); + + params.rgrc[0] = window_rect; + ret = DefWindowProcA(hwnd, WM_NCCALCSIZE, TRUE, (LPARAM)&params); +todo_wine + ok(!ret, "got %08x\n", ret); + ok(EqualRect(&params.rgrc[0], &client_rect), "got %s\n", wine_dbgstr_rect(&params.rgrc[0])); + + GetWindowRect(hwnd, &window_rect); + ret = SendMessageW(hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&window_rect); +todo_wine + ok(!ret, "got %08x\n", ret); + ok(EqualRect(&window_rect, &client_rect), "got %s\n", wine_dbgstr_rect(&window_rect)); + + GetWindowRect(hwnd, &window_rect); + ret = DefWindowProcA(hwnd, WM_NCCALCSIZE, FALSE, (LPARAM)&window_rect); +todo_wine + ok(!ret, "got %08x\n", ret); + ok(EqualRect(&window_rect, &client_rect), "got %s\n", wine_dbgstr_rect(&window_rect)); + + DestroyWindow(hwnd); +} + START_TEST(win) { char **argv; @@ -12497,6 +12566,7 @@ START_TEST(win) test_SC_SIZE(); test_cancel_mode(); test_DragDetect(); + test_WM_NCCALCSIZE(); /* add the tests above this line */ if (hhook) UnhookWindowsHookEx(hhook); -- 2.34.1

2 2

[PATCH] d3d10/tests: Increase size of array expected_i_a in test_scalar_array_methods (cppcheck)
by Alex Henrie 07 Jan '22

07 Jan '22

This array is accessed at index 5 on line 5138. Signed-off-by: Alex Henrie <alexhenrie24(a)gmail.com> --- dlls/d3d10/tests/effect.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/d3d10/tests/effect.c b/dlls/d3d10/tests/effect.c index ddc24d66e20..51675bcdab3 100644 --- a/dlls/d3d10/tests/effect.c +++ b/dlls/d3d10/tests/effect.c @@ -4974,7 +4974,7 @@ static void test_scalar_array_methods(ID3D10EffectScalarVariable *var, D3D10_SHA const char *name) { float set_f[2], ret_f[2], expected_f; - int set_i[6], ret_i[6], expected_i, expected_i_a[2]; + int set_i[6], ret_i[6], expected_i, expected_i_a[6]; BOOL set_b[2], ret_b[2], expected_b, expected_b_a[6]; unsigned int i; HRESULT hr; -- 2.34.1

2 1

[PATCH v2] darwin: Fix non-Metal build
by Keno Fischer 06 Jan '22

06 Jan '22

The build was relying on QuartzCore definitions even if Metal was not found, so move the appropriate import out of the ifdef and add the QuartzCore framework to the make line. Signed-off-by: Keno Fischer <keno(a)juliacomputing.com> --- v2: Drop `-framework QuartzCore` from configure.ac as suggested by Dean Greer <gcenx83(a)gmail.com>. configure | 2 +- configure.ac | 2 +- dlls/winemac.drv/Makefile.in | 2 +- dlls/winemac.drv/cocoa_window.m | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/configure b/configure index d57fc6cf43b..bf65b916b7d 100755 --- a/configure +++ b/configure @@ -10321,7 +10321,7 @@ fi fi if test "$ac_cv_header_Metal_Metal_h" = "yes" then - METAL_LIBS="-framework Metal -framework QuartzCore" + METAL_LIBS="-framework Metal" fi diff --git a/configure.ac b/configure.ac index de79b47ea2a..1a36e98f3e8 100644 --- a/configure.ac +++ b/configure.ac @@ -757,7 +757,7 @@ case $host_os in fi if test "$ac_cv_header_Metal_Metal_h" = "yes" then - AC_SUBST(METAL_LIBS,"-framework Metal -framework QuartzCore") + AC_SUBST(METAL_LIBS,"-framework Metal") fi dnl Check for MTLDevice registryID property diff --git a/dlls/winemac.drv/Makefile.in b/dlls/winemac.drv/Makefile.in index 6329e8e76c8..fc3dddbdae7 100644 --- a/dlls/winemac.drv/Makefile.in +++ b/dlls/winemac.drv/Makefile.in @@ -1,7 +1,7 @@ MODULE = winemac.drv IMPORTS = uuid rpcrt4 user32 gdi32 advapi32 win32u DELAYIMPORTS = ole32 shell32 imm32 -EXTRALIBS = -framework AppKit -framework Carbon -framework Security -framework OpenGL -framework IOKit -framework CoreVideo $(METAL_LIBS) +EXTRALIBS = -framework AppKit -framework Carbon -framework Security -framework OpenGL -framework IOKit -framework CoreVideo -framework QuartzCore $(METAL_LIBS) EXTRADLLFLAGS = -mcygwin diff --git a/dlls/winemac.drv/cocoa_window.m b/dlls/winemac.drv/cocoa_window.m index d0672b7fb06..a18fc069604 100644 --- a/dlls/winemac.drv/cocoa_window.m +++ b/dlls/winemac.drv/cocoa_window.m @@ -25,8 +25,8 @@ #import <CoreVideo/CoreVideo.h> #ifdef HAVE_METAL_METAL_H #import <Metal/Metal.h> -#import <QuartzCore/QuartzCore.h> #endif +#import <QuartzCore/QuartzCore.h> #import "cocoa_window.h" -- 2.25.1

7 16

[PATCH 2/2] win32u: Allow selecting 32-bit DDBs into display compatible DCs.
by Zhiyi Zhang 06 Jan '22

06 Jan '22

Device context bit depths other than 32-bit are emulated and the real bit depth for display DCs is still 32-bit. Thus, a 32-bit DDB should be allowed to be selected into a display compatible DC even if the DC reports a different bit depth. Fix a regression from d171d11. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51805 Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/user32/tests/monitor.c | 2 -- dlls/win32u/bitmap.c | 4 +++- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/dlls/user32/tests/monitor.c b/dlls/user32/tests/monitor.c index e745fb9c7b3..a857b295849 100644 --- a/dlls/user32/tests/monitor.c +++ b/dlls/user32/tests/monitor.c @@ -2301,7 +2301,6 @@ static void test_display_dc(void) bpp = GetDeviceCaps(mem_dc, BITSPIXEL); ok(bpp == dm2.dmBitsPerPel, "Expected bpp %d, got %d.\n", dm2.dmBitsPerPel, bpp); old_hbitmap = SelectObject(mem_dc, hbitmap); - todo_wine ok(!!old_hbitmap, "Failed to select bitmap.\n"); bpp = GetDeviceCaps(mem_dc, BITSPIXEL); ok(bpp == dm2.dmBitsPerPel, "Expected bpp %d, got %d.\n", dm2.dmBitsPerPel, bpp); @@ -2329,7 +2328,6 @@ static void test_display_dc(void) ok(!old_hbitmap || broken(!!old_hbitmap) /* Win7 dual-QXL test bot and XP */, "Selecting bitmap succeeded.\n"); else - todo_wine_if(bpps[i] == 32) ok(!!old_hbitmap || broken(!old_hbitmap) /* Win7 dual-QXL test bot and XP */, "Failed to select bitmap.\n"); diff --git a/dlls/win32u/bitmap.c b/dlls/win32u/bitmap.c index 00c8b347af5..2be88715948 100644 --- a/dlls/win32u/bitmap.c +++ b/dlls/win32u/bitmap.c @@ -401,7 +401,9 @@ HGDIOBJ WINAPI NtGdiSelectBitmap( HDC hdc, HGDIOBJ handle ) if (!is_bitmapobj_dib( bitmap ) && bitmap->dib.dsBm.bmBitsPixel != 1 && - bitmap->dib.dsBm.bmBitsPixel != NtGdiGetDeviceCaps( hdc, BITSPIXEL )) + bitmap->dib.dsBm.bmBitsPixel != NtGdiGetDeviceCaps( hdc, BITSPIXEL ) && + /* Display compatible DCs should accept 32-bit DDBs because other color depths are emulated */ + !(NtGdiGetDeviceCaps( hdc, TECHNOLOGY ) == DT_RASDISPLAY && bitmap->dib.dsBm.bmBitsPixel == 32)) { WARN( "Wrong format bitmap %u bpp\n", bitmap->dib.dsBm.bmBitsPixel ); GDI_ReleaseObj( handle ); -- 2.32.0

2 1

[PATCH 1/2] user32/tests: Test selecting DDBs of different depth into display compatible DCs.
by Zhiyi Zhang 06 Jan '22

06 Jan '22

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/user32/tests/monitor.c | 110 +++++++++++++++++++++++++++++++++++- 1 file changed, 107 insertions(+), 3 deletions(-) diff --git a/dlls/user32/tests/monitor.c b/dlls/user32/tests/monitor.c index bd348576726..e745fb9c7b3 100644 --- a/dlls/user32/tests/monitor.c +++ b/dlls/user32/tests/monitor.c @@ -2180,13 +2180,17 @@ static void _check_display_dc(INT line, HDC hdc, const DEVMODEA *dm, BOOL allow_ static void test_display_dc(void) { + static const INT bpps[] = {1, 4, 8, 16, 24, 32}; + HBITMAP hbitmap, old_hbitmap; + INT count, old_count, i, bpp; DWORD device_idx, mode_idx; DEVMODEA dm, dm2, dm3; - INT count, old_count; DISPLAY_DEVICEA dd; + HDC hdc, mem_dc; + DIBSECTION dib; + BITMAP bitmap; BOOL ret; LONG res; - HDC hdc; /* Test DCs covering the entire virtual screen */ hdc = CreateDCA("DISPLAY", NULL, NULL, NULL); @@ -2199,6 +2203,51 @@ static void test_display_dc(void) check_display_dc(hdc, &dm, FALSE); + /* Test that CreateCompatibleBitmap() for display DCs creates DDBs */ + hbitmap = CreateCompatibleBitmap(hdc, dm.dmPelsWidth, dm.dmPelsHeight); + ok(!!hbitmap, "CreateCompatibleBitmap failed, error %d.\n", GetLastError()); + count = GetObjectW(hbitmap, sizeof(dib), &dib); + ok(count == sizeof(BITMAP), "GetObject failed, count %d.\n", count); + count = GetObjectW(hbitmap, sizeof(bitmap), &bitmap); + ok(count == sizeof(BITMAP), "GetObject failed, count %d.\n", count); + ok(bitmap.bmBitsPixel == dm.dmBitsPerPel, "Expected %d, got %d.\n", dm.dmBitsPerPel, + bitmap.bmBitsPixel); + DeleteObject(hbitmap); + + /* Test selecting a DDB of a different depth into a display compatible DC */ + for (i = 0; i < ARRAY_SIZE(bpps); ++i) + { + winetest_push_context("bpp %d", bpps[i]); + + mem_dc = CreateCompatibleDC(hdc); + hbitmap = CreateBitmap(dm.dmPelsWidth, dm.dmPelsHeight, 1, bpps[i], NULL); + ok(!!hbitmap, "CreateBitmap failed, error %d.\n", GetLastError()); + old_hbitmap = SelectObject(mem_dc, hbitmap); + if (bpps[i] != 1 && bpps[i] != 32) + ok(!old_hbitmap, "Selecting bitmap succeeded.\n"); + else + ok(!!old_hbitmap, "Failed to select bitmap.\n"); + + SelectObject(mem_dc, old_hbitmap); + DeleteObject(hbitmap); + DeleteDC(mem_dc); + + winetest_pop_context(); + } + + /* Test selecting a DDB of the same color depth into a display compatible DC */ + mem_dc = CreateCompatibleDC(hdc); + bpp = GetDeviceCaps(mem_dc, BITSPIXEL); + ok(bpp == dm.dmBitsPerPel, "Expected bpp %d, got %d.\n", dm.dmBitsPerPel, bpp); + hbitmap = CreateCompatibleBitmap(hdc, dm.dmPelsWidth, dm.dmPelsHeight); + count = GetObjectW(hbitmap, sizeof(bitmap), &bitmap); + ok(count == sizeof(BITMAP), "GetObject failed, count %d.\n", count); + ok(bitmap.bmBitsPixel == dm.dmBitsPerPel, "Expected %d, got %d.\n", dm.dmBitsPerPel, bitmap.bmBitsPixel); + old_hbitmap = SelectObject(mem_dc, hbitmap); + ok(!!old_hbitmap, "Failed to select bitmap.\n"); + SelectObject(mem_dc, old_hbitmap); + DeleteDC(mem_dc); + /* Tests after mode changes to a different resolution */ memset(&dm2, 0, sizeof(dm2)); dm2.dmSize = sizeof(dm2); @@ -2226,7 +2275,7 @@ static void test_display_dc(void) dm2.dmSize = sizeof(dm2); for (mode_idx = 0; EnumDisplaySettingsA(NULL, mode_idx, &dm2); ++mode_idx) { - if (dm2.dmBitsPerPel != dm.dmBitsPerPel) + if (dm2.dmBitsPerPel != dm.dmBitsPerPel && dm2.dmBitsPerPel != 1) break; } if (dm2.dmBitsPerPel && dm2.dmBitsPerPel != dm.dmBitsPerPel) @@ -2239,6 +2288,59 @@ static void test_display_dc(void) { check_display_dc(hdc, &dm2, FALSE); + /* Test selecting a compatible bitmap of a different color depth previously created for + * a display DC into a new compatible DC */ + count = GetObjectW(hbitmap, sizeof(bitmap), &bitmap); + ok(count == sizeof(BITMAP), "GetObject failed, count %d.\n", count); + ok(bitmap.bmBitsPixel == dm.dmBitsPerPel, "Expected %d, got %d.\n", dm.dmBitsPerPel, + bitmap.bmBitsPixel); + + /* Note that hbitmap is of a different color depth and it can be successfully selected + * into the new compatible DC */ + mem_dc = CreateCompatibleDC(hdc); + bpp = GetDeviceCaps(mem_dc, BITSPIXEL); + ok(bpp == dm2.dmBitsPerPel, "Expected bpp %d, got %d.\n", dm2.dmBitsPerPel, bpp); + old_hbitmap = SelectObject(mem_dc, hbitmap); + todo_wine + ok(!!old_hbitmap, "Failed to select bitmap.\n"); + bpp = GetDeviceCaps(mem_dc, BITSPIXEL); + ok(bpp == dm2.dmBitsPerPel, "Expected bpp %d, got %d.\n", dm2.dmBitsPerPel, bpp); + SelectObject(mem_dc, old_hbitmap); + DeleteDC(mem_dc); + DeleteObject(hbitmap); + + /* Test selecting a DDB of a different color depth into a display compatible DC */ + for (i = 0; i < ARRAY_SIZE(bpps); ++i) + { + winetest_push_context("bpp %d", bpps[i]); + + mem_dc = CreateCompatibleDC(hdc); + hbitmap = CreateBitmap(dm2.dmPelsWidth, dm2.dmPelsHeight, 1, bpps[i], NULL); + ok(!!hbitmap, "CreateBitmap failed, error %d.\n", GetLastError()); + old_hbitmap = SelectObject(mem_dc, hbitmap); + /* On Win7 dual-QXL test bot and XP, only 1-bit DDBs and DDBs with the same color + * depth can be selected to the compatible DC. On newer versions of Windows, only + * 1-bit and 32-bit DDBs can be selected into the compatible DC even if + * GetDeviceCaps(BITSPIXEL) reports a different color depth, for example, 16-bit. + * It's most likely due to the fact that lower color depth are emulated on newer + * versions of Windows as the real color depth is still 32-bit */ + if (bpps[i] != 1 && bpps[i] != 32) + todo_wine_if(bpps[i] == dm2.dmBitsPerPel) + ok(!old_hbitmap || broken(!!old_hbitmap) /* Win7 dual-QXL test bot and XP */, + "Selecting bitmap succeeded.\n"); + else + todo_wine_if(bpps[i] == 32) + ok(!!old_hbitmap || broken(!old_hbitmap) /* Win7 dual-QXL test bot and XP */, + "Failed to select bitmap.\n"); + + SelectObject(mem_dc, old_hbitmap); + DeleteObject(hbitmap); + DeleteDC(mem_dc); + + winetest_pop_context(); + } + hbitmap = NULL; + res = ChangeDisplaySettingsExA(NULL, NULL, NULL, 0, NULL); ok(res == DISP_CHANGE_SUCCESSFUL, "ChangeDisplaySettingsExA returned unexpected %d.\n", res); } @@ -2248,6 +2350,8 @@ static void test_display_dc(void) win_skip("Failed to find a different color depth other than %u.\n", dm.dmBitsPerPel); } + if (hbitmap) + DeleteObject(hbitmap); DeleteDC(hdc); /* Test DCs covering a specific monitor */ -- 2.32.0

2 1

[PATCH vkd3d v3 1/3] vkd3d-compiler: Print usage instructions only if --help is specified.
by Zebediah Figura 06 Jan '22

06 Jan '22

vkd3d-compiler is hardly the only program to print usage instructions on all invalid invocations, but it's rather annoying to have one's whole screen wiped due to a typo. It also makes it hard to notice the actual error messages printed on e.g. `vkd3d-compiler -x`. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- programs/vkd3d-compiler/main.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/programs/vkd3d-compiler/main.c b/programs/vkd3d-compiler/main.c index 4d7d628ca..4e56e8fa5 100644 --- a/programs/vkd3d-compiler/main.c +++ b/programs/vkd3d-compiler/main.c @@ -209,6 +209,7 @@ struct options enum vkd3d_shader_source_type source_type; enum vkd3d_shader_target_type target_type; bool preprocess_only; + bool print_help; bool print_version; bool print_source_types; bool print_target_types; @@ -446,6 +447,11 @@ static bool parse_command_line(int argc, char **argv, struct options *options) options->preprocess_only = true; break; + case 'h': + case OPTION_HELP: + options->print_help = true; + return true; + case OPTION_OUTPUT: case 'o': options->output_filename = optarg; @@ -623,9 +629,12 @@ int main(int argc, char **argv) int ret; if (!parse_command_line(argc, argv, &options)) + return 1; + + if (options.print_help) { print_usage(argv[0]); - return 1; + return 0; } if (options.print_version) -- 2.34.1

5 13

[PATCH vkd3d v3 05/12] vkd3d-shader/hlsl: Add Gather methods with offset and tests.
by Francisco Casas 06 Jan '22

06 Jan '22

Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- Makefile.am | 4 + libs/vkd3d-shader/hlsl.c | 4 + libs/vkd3d-shader/hlsl.h | 4 + libs/vkd3d-shader/hlsl.y | 109 +++++++++++++++++++++++++++ libs/vkd3d-shader/hlsl_sm4.c | 67 ++++++++++++++++ tests/hlsl-gather-offset.shader_test | 93 +++++++++++++++++++++++ tests/hlsl-gather.shader_test | 107 ++++++++++++++++++++++++++ 7 files changed, 388 insertions(+) create mode 100644 tests/hlsl-gather-offset.shader_test create mode 100644 tests/hlsl-gather.shader_test diff --git a/Makefile.am b/Makefile.am index 16848f5a..749df363 100644 --- a/Makefile.am +++ b/Makefile.am @@ -68,6 +68,8 @@ vkd3d_shader_tests = \ tests/hlsl-duplicate-modifiers.shader_test \ tests/hlsl-for.shader_test \ tests/hlsl-function-overload.shader_test \ + tests/hlsl-gather-offset.shader_test \ + tests/hlsl-gather.shader_test \ tests/hlsl-invalid.shader_test \ tests/hlsl-majority-pragma.shader_test \ tests/hlsl-majority-typedef.shader_test \ @@ -294,6 +296,8 @@ XFAIL_TESTS = \ tests/hlsl-duplicate-modifiers.shader_test \ tests/hlsl-for.shader_test \ tests/hlsl-function-overload.shader_test \ + tests/hlsl-gather-offset.shader_test \ + tests/hlsl-gather.shader_test \ tests/hlsl-majority-pragma.shader_test \ tests/hlsl-majority-typedef.shader_test \ tests/hlsl-nested-arrays.shader_test \ diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index b426e461..82820daf 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1277,6 +1277,10 @@ static void dump_ir_resource_load(struct vkd3d_string_buffer *buffer, const stru { [HLSL_RESOURCE_LOAD] = "load_resource", [HLSL_RESOURCE_SAMPLE] = "sample", + [HLSL_RESOURCE_GATHER_RED] = "gather4r", + [HLSL_RESOURCE_GATHER_GREEN] = "gather4g", + [HLSL_RESOURCE_GATHER_BLUE] = "gather4b", + [HLSL_RESOURCE_GATHER_ALPHA] = "gather4a", }; vkd3d_string_buffer_printf(buffer, "%s(resource = ", type_names[load->load_type]); diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 2396adb4..49fa8d9d 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -378,6 +378,10 @@ enum hlsl_resource_load_type { HLSL_RESOURCE_LOAD, HLSL_RESOURCE_SAMPLE, + HLSL_RESOURCE_GATHER_RED, + HLSL_RESOURCE_GATHER_GREEN, + HLSL_RESOURCE_GATHER_BLUE, + HLSL_RESOURCE_GATHER_ALPHA, }; struct hlsl_ir_resource_load diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 33bfee5b..9aa0138d 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1930,6 +1930,115 @@ static bool add_method_call(struct hlsl_ctx *ctx, struct list *instrs, struct hl list_add_tail(instrs, &load->node.entry); return true; } + else if (!strcmp(name, "Gather") || !strcmp(name, "GatherRed") || !strcmp(name, "GatherBlue") + || !strcmp(name, "GatherGreen") || !strcmp(name, "GatherAlpha")) + { + const unsigned int sampler_dim = sampler_dim_count(object_type->sampler_dim); + enum hlsl_resource_load_type load_type; + const struct hlsl_type *sampler_type; + struct hlsl_ir_resource_load *load; + struct hlsl_ir_node *offset = NULL; + struct hlsl_ir_load *sampler_load; + struct hlsl_type *result_type; + struct hlsl_ir_node *coords; + int status_out_arg; + int read_channel; + + if (!strcmp(name, "Gather") || !strcmp(name, "GatherRed")) + { + load_type = HLSL_RESOURCE_GATHER_RED; + read_channel = 0; + } + else if (!strcmp(name, "GatherGreen")) + { + load_type = HLSL_RESOURCE_GATHER_GREEN; + read_channel = 1; + } + else if (!strcmp(name, "GatherBlue")) + { + load_type = HLSL_RESOURCE_GATHER_BLUE; + read_channel = 2; + } + else if (!strcmp(name, "GatherAlpha")) + { + load_type = HLSL_RESOURCE_GATHER_ALPHA; + read_channel = 3; + } + else { + assert(!"Unexpected Gather method."); + } + + + if (!strcmp(name, "Gather")) + { + if (params->args_count != 2 && params->args_count != 3) + { + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT, + "Wrong number of arguments to method 'Gather': expected 2 or 3, but got %u.", params->args_count); + return false; + } + } + else if (params->args_count < 2 || params->args_count == 5 || params->args_count > 7) + { + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_WRONG_PARAMETER_COUNT, + "Wrong number of arguments to method '%s': expected 2,3,4,6 or 7, but got %u.", name, params->args_count); + return false; + } + + status_out_arg = -1; + if (params->args_count == 4) + status_out_arg = 3; + if (params->args_count == 7) + status_out_arg = 6; + if (status_out_arg != -1) + FIXME("Ignoring 'status' output parameter.\n"); + + if (params->args_count == 6 || params->args_count == 7) + FIXME("Ignoring multiple offset parameters.\n"); + + if (params->args_count == 3 || params->args_count == 4) + { + if (!(offset = add_implicit_conversion(ctx, instrs, params->args[2], + hlsl_get_vector_type(ctx, HLSL_TYPE_INT, sampler_dim), loc))) + offset = params->args[2]; + } + + sampler_type = params->args[0]->data_type; + if (sampler_type->type != HLSL_CLASS_OBJECT || sampler_type->base_type != HLSL_TYPE_SAMPLER + || sampler_type->sampler_dim != HLSL_SAMPLER_DIM_GENERIC) + { + struct vkd3d_string_buffer *string; + + if ((string = hlsl_type_to_string(ctx, sampler_type))) + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, + "Wrong type for argument 0 of %s(): expected 'sampler', but got '%s'.", name, string->buffer); + hlsl_release_string_buffer(ctx, string); + return false; + } + + if (read_channel >= object_type->e.resource_format->dimx) + { + hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, + "Method %s() requires at least %d channels.", name, read_channel+1); + return false; + } + + result_type = hlsl_get_vector_type(ctx, object_type->e.resource_format->base_type, 4); + + /* Only HLSL_IR_LOAD can return an object. */ + sampler_load = hlsl_ir_load(params->args[0]); + + if (!(coords = add_implicit_conversion(ctx, instrs, params->args[1], + hlsl_get_vector_type(ctx, HLSL_TYPE_FLOAT, sampler_dim), loc))) + coords = params->args[1]; + + if (!(load = hlsl_new_resource_load(ctx, result_type, + load_type, object_load->src.var, object_load->src.offset.node, + sampler_load->src.var, sampler_load->src.offset.node, coords, offset, loc))) + return false; + list_add_tail(instrs, &load->node.entry); + return true; + } else { struct vkd3d_string_buffer *string; diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index 11e1f59a..be35d125 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -1654,6 +1654,56 @@ static void write_sm4_loop(struct hlsl_ctx *ctx, write_sm4_instruction(buffer, &instr); } + +static void write_sm4_gather(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, + const struct hlsl_type *resource_type, const struct hlsl_ir_node *dst, + const struct hlsl_deref *resource, const struct hlsl_deref *sampler, const struct hlsl_ir_node *coords, + unsigned int swizzle, const struct hlsl_ir_node *texel_offset) +{ + struct sm4_instruction instr; + unsigned int writemask; + int n_srcs = 0; + + memset(&instr, 0, sizeof(instr)); + + /* TODO: possible optimization, if the offset ranges from -8 to 7, an VKD3D_SM4_OP_GATHER4 with + an aoffimmi modifier can be used. */ + instr.opcode = texel_offset? VKD3D_SM5_OP_GATHER4_PO : VKD3D_SM4_OP_GATHER4; + + sm4_register_from_node(&instr.dsts[0].reg, &instr.dsts[0].writemask, NULL, dst); + instr.dst_count = 1; + + sm4_register_from_node(&instr.srcs[n_srcs].reg, &writemask, &instr.srcs[n_srcs].swizzle_type, coords); + instr.srcs[n_srcs].swizzle = hlsl_swizzle_from_writemask(writemask); + n_srcs++; + + if (texel_offset) + { + sm4_register_from_node(&instr.srcs[n_srcs].reg, &writemask, &instr.srcs[n_srcs].swizzle_type, texel_offset); + instr.srcs[n_srcs].swizzle = hlsl_swizzle_from_writemask(writemask); + + n_srcs++; + } + + sm4_register_from_deref(ctx, &instr.srcs[n_srcs].reg, &writemask, &instr.srcs[n_srcs].swizzle_type, + resource, resource_type); + instr.srcs[n_srcs].swizzle = hlsl_map_swizzle(hlsl_swizzle_from_writemask(writemask), instr.dsts[0].writemask); + n_srcs++; + + sm4_register_from_deref(ctx, &instr.srcs[n_srcs].reg, &writemask, NULL, + sampler, sampler->var->data_type); + instr.srcs[n_srcs].reg.type = VKD3D_SM4_RT_SAMPLER; + instr.srcs[n_srcs].reg.dim = VKD3D_SM4_DIMENSION_VEC4; + instr.srcs[n_srcs].swizzle_type = VKD3D_SM4_SWIZZLE_SCALAR; + instr.srcs[n_srcs].swizzle = swizzle; + n_srcs++; + + instr.src_count = n_srcs; + + write_sm4_instruction(buffer, &instr); +} + + static void write_sm4_resource_load(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buffer, const struct hlsl_ir_resource_load *load) { @@ -1694,6 +1744,23 @@ static void write_sm4_resource_load(struct hlsl_ctx *ctx, write_sm4_sample(ctx, buffer, resource_type, &load->node, &load->resource, &load->sampler, coords, texel_offset); break; + + case HLSL_RESOURCE_GATHER_RED: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(X, X, X, X), texel_offset); + break; + case HLSL_RESOURCE_GATHER_GREEN: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(Y, Y, Y, Y), texel_offset); + break; + case HLSL_RESOURCE_GATHER_BLUE: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(Z, Z, Z, Z), texel_offset); + break; + case HLSL_RESOURCE_GATHER_ALPHA: + write_sm4_gather(ctx, buffer, resource_type, &load->node, &load->resource, + &load->sampler, coords, HLSL_SWIZZLE(W, W, W, W), texel_offset); + break; } } diff --git a/tests/hlsl-gather-offset.shader_test b/tests/hlsl-gather-offset.shader_test new file mode 100644 index 00000000..d7e1a233 --- /dev/null +++ b/tests/hlsl-gather-offset.shader_test @@ -0,0 +1,93 @@ +[sampler 0] +filter linear linear linear +address clamp clamp clamp + +[texture 0] +size (3, 3) +0.0 0.0 0.0 0.4 0.1 0.0 0.5 0.0 0.2 0.0 0.0 0.4 +0.0 0.1 0.5 0.0 0.1 0.1 0.0 0.4 0.2 0.1 0.5 0.0 +0.0 0.2 0.0 0.4 0.1 0.2 0.5 0.0 0.2 0.2 0.0 0.4 + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.Gather(s, float2(0.2, 0.2), int2(1, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.2, 0.2, 0.1) + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherRed(s, float2(0.6, 0.6), int2(-1, 0)); +} + +[test] +draw quad +probe all rgba (0.0, 0.1, 0.1, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.2, 0.2), int2(0, 1)); +} + +[test] +draw quad +probe all rgba (0.2, 0.2, 0.1, 0.1) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.8, 0.8), int2(-1, -1)); +} + +[test] +draw quad +probe all rgba (0.1, 0.1, 0.0, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherBlue(s, float2(0.2, 0.8), int2(1, 0)); +} + +[test] +draw quad +probe all rgba (0.5, 0.0, 0.5, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherAlpha(s, float2(0.2, 0.8), int2(0, -1)); +} + +[test] +draw quad +probe all rgba (0.0, 0.4, 0.0, 0.4) diff --git a/tests/hlsl-gather.shader_test b/tests/hlsl-gather.shader_test new file mode 100644 index 00000000..2682c6ef --- /dev/null +++ b/tests/hlsl-gather.shader_test @@ -0,0 +1,107 @@ +[sampler 0] +filter linear linear linear +address clamp clamp clamp + +[texture 0] +size (3, 3) +0.0 0.0 0.0 0.4 0.1 0.0 0.5 0.0 0.2 0.0 0.0 0.4 +0.0 0.1 0.5 0.0 0.1 0.1 0.0 0.4 0.2 0.1 0.5 0.0 +0.0 0.2 0.0 0.4 0.1 0.2 0.5 0.0 0.2 0.2 0.0 0.4 + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.Gather(s, float2(0.2, 0.2)); +} + +[test] +draw quad +probe all rgba (0.0, 0.1, 0.1, 0.0) + + +[pixel shader] +sampler s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherRed(s, float2(0.6, 0.6), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.2, 0.2, 0.1) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.2, 0.2), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.1, 0.0, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.8, 0.8)); +} + +[test] +draw quad +probe all rgba (0.2, 0.2, 0.1, 0.1) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherGreen(s, float2(0.2, 0.2), int2(0, 0), int2(0, 0), int2(0, 0), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.1, 0.1, 0.0, 0.0) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherBlue(s, float2(0.2, 0.8), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.0, 0.5, 0.0, 0.5) + + +[pixel shader] +SamplerState s; +Texture2D t; + +float4 main() : sv_target +{ + return t.GatherAlpha(s, float2(0.2, 0.8), int2(0, 0)); +} + +[test] +draw quad +probe all rgba (0.4, 0.0, 0.4, 0.0) -- 2.25.1

3 4

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel December 2021