wine-devel December 2021

85 participants
585 discussions

[PATCH 1/2] qedit/tests: Check the Sample Grabber's buffer during and after flushing.

by Gabriel Ivăncescu

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

1 year, 6 months

[PATCH 1/4] riched20: draw OLE object in richedit with OleDraw

by Dongwan Kim

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

2 years

[PATCH 1/2] api-ms-win-core-privateprofile-l1-1-0: Add dll.

by Mohamad Al-Jaf

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

2 years

[PATCH vkd3d 01/13] vkd3d-shader/hlsl: Handle objects in copy propagation.

by Zebediah Figura

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

2 years, 2 months

[v2 PATCH vkd3d 1/4] tests: Fix shader tests crashes on WARP driver.

by Nikolay Sivov

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

2 years, 2 months

[PATCH] tools: Add gdbinit helper with LoadSymbolFiles command.

by Rémi Bernon

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

2 years, 2 months

[PATCH v9 1/3] ntdll: sock_recv keeps message ordered

by Dongwan Kim

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 years, 2 months

[PATCH vkd3d v3 01/12] vkd3d-shader/hlsl: Add support for sm4 instruction modifiers.

by Francisco Casas

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

2 years, 3 months

[PATCH vkd3d v2 1/5] vkd3d-shader/hlsl: Write SM4 equality instructions.

by Giovanni Mascellani

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

2 years, 3 months

[PATCH vkd3d v4 05/10] vkd3d-shader/hlsl: Add Gather methods with offset and tests.

by Francisco Casas

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 years, 3 months

Jump to page:

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