February 2022 - Wine-Devel - list.winehq.org

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

Oct. 4, 2022

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/2] shell32: Only call HCR_GetFolderAttributes with simple pidls
by Fabian Maurer April 28, 2022

April 28, 2022

The function returns false with not-simple pidls anyways. This fixes an "ERR" message when opening a control panel applet from explorer Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/shell32/shlfolder.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/shell32/shlfolder.c b/dlls/shell32/shlfolder.c index 10aafc160c0..8e3b561cfd1 100644 --- a/dlls/shell32/shlfolder.c +++ b/dlls/shell32/shlfolder.c @@ -412,7 +412,7 @@ HRESULT SHELL32_GetItemAttributes (IShellFolder2 *psf, LPCITEMIDLIST pidl, LPDWO if (_ILIsDrive (pidl)) { *pdwAttributes &= SFGAO_HASSUBFOLDER|SFGAO_FILESYSTEM|SFGAO_FOLDER|SFGAO_FILESYSANCESTOR| SFGAO_DROPTARGET|SFGAO_HASPROPSHEET|SFGAO_CANLINK; - } else if (has_guid && HCR_GetFolderAttributes(pidl, &dwAttributes)) { + } else if (has_guid && _ILIsPidlSimple(pidl) && HCR_GetFolderAttributes(pidl, &dwAttributes)) { *pdwAttributes = dwAttributes; } else if (_ILGetDataPointer (pidl)) { DWORD file_attr = _ILGetFileAttributes (pidl, NULL, 0); -- 2.34.1

2 5

[PATCH] dxgi: Fake success in dxgi_adapter_RegisterVideoMemoryBudgetChangeNotificationEvent
by Fabian Maurer April 25, 2022

April 25, 2022

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51665 Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/dxgi/adapter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/dxgi/adapter.c b/dlls/dxgi/adapter.c index e38fef5fa4f..987b89c4a88 100644 --- a/dlls/dxgi/adapter.c +++ b/dlls/dxgi/adapter.c @@ -350,7 +350,7 @@ static HRESULT STDMETHODCALLTYPE dxgi_adapter_RegisterVideoMemoryBudgetChangeNot { FIXME("iface %p, event %p, cookie %p stub!\n", iface, event, cookie); - return E_NOTIMPL; + return S_OK; } static void STDMETHODCALLTYPE dxgi_adapter_UnregisterVideoMemoryBudgetChangeNotification( -- 2.35.1

3 3

[PATCH 1/4] riched20: draw OLE object in richedit with OleDraw
by Dongwan Kim March 30, 2022

March 30, 2022

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 March 30, 2022

March 30, 2022

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 v4 0/5] Series short description
by Eric Pouech March 16, 2022

March 16, 2022

As described in bugzilla ticket, when calling CreateProcess: - with "default" console inheritance (no CREATE_NEW_CONSOLE nor DETACHED_PROCESS flags), - when parent is not attached to a console - and when the child's subsystem is CUI , native behaves as if CREATE_NEW_CONSOLE was passed. builtin doesn't... this serie: - adds a test case for showing the CUI/GUI discrepancies - fixes kernelbase accordingly - but also requires to fix all usage of CreateProcess in Wine Code that would now generate the creation of a console + a couple of programs moved into the GUI subsystem (to avoid console creation on invocation) + when looking to the other usage of CreateProcess, I only convinced myself to adapt one of them V1 => V2: - don't mess up with the number of patches in the serie - no longer modify makedep for creating cui vs gui test executable, but copy current *_test.exe executable and adapt its subsystem to the need V2 => V3: - removed the hacks in wow64 redirect, and let programs/uninstaller and programs/wusa belong to the GUI subsystem instead - force console creation for wine initial process when a) none of the unix fd are attached to a TTY, b) the initial process is in CUI subsystem V3 => V4: - included Jacek's comments: + removed unneeded casts + move CreateProcess change in programs/services into a separate patch + I didn't change programs/start as you suggested. Testing on W10 shows that 'start /b cui.exe' from a cmd prompt just reuses the current console. And Marvin will generate errors for Chinese and Japanese VM in console testing that are independant of this serie. Signed-off-by: Eric Pouech <eric.pouech(a)gmail.com> --- Eric Pouech (5): dlls/kernel32/tests: add some console tests about creating cui vs gui processes programs/wusa: set subsystem to GUI programs/uninstaller: set subsystem to GUI programs/services: start services detached from console dlls/kernelbase: handle corner case in CreateProcess dlls/kernel32/tests/console.c | 85 ++++++++++++++++++++++++++++++++ dlls/kernelbase/process.c | 6 ++- programs/services/services.c | 2 +- programs/uninstaller/Makefile.in | 2 +- programs/wusa/Makefile.in | 2 +- 5 files changed, 93 insertions(+), 4 deletions(-)

3 8

[PATCH vkd3d v2 1/5] vkd3d: Use device descriptor limits when creating descriptor pools.
by Conor McCarthy March 15, 2022

March 15, 2022

Signed-off-by: Conor McCarthy <cmccarthy(a)codeweavers.com> --- libs/vkd3d/command.c | 13 ++----------- libs/vkd3d/device.c | 36 ++++++++++++++++++++++++++++++++++++ libs/vkd3d/vkd3d_private.h | 20 ++++++++++++++++++++ 3 files changed, 58 insertions(+), 11 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 61e18105..e7375fb8 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -1351,15 +1351,6 @@ static bool d3d12_command_allocator_add_transfer_buffer(struct d3d12_command_all static VkDescriptorPool d3d12_command_allocator_allocate_descriptor_pool( struct d3d12_command_allocator *allocator) { - static const VkDescriptorPoolSize pool_sizes[] = - { - {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1024}, - {VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1024}, - {VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1024}, - {VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1024}, - {VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1024}, - {VK_DESCRIPTOR_TYPE_SAMPLER, 1024}, - }; struct d3d12_device *device = allocator->device; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; struct VkDescriptorPoolCreateInfo pool_desc; @@ -1379,8 +1370,8 @@ static VkDescriptorPool d3d12_command_allocator_allocate_descriptor_pool( pool_desc.pNext = NULL; pool_desc.flags = 0; pool_desc.maxSets = 512; - pool_desc.poolSizeCount = ARRAY_SIZE(pool_sizes); - pool_desc.pPoolSizes = pool_sizes; + pool_desc.poolSizeCount = ARRAY_SIZE(device->vk_pool_sizes); + pool_desc.pPoolSizes = device->vk_pool_sizes; if ((vr = VK_CALL(vkCreateDescriptorPool(vk_device, &pool_desc, NULL, &vk_pool))) < 0) { ERR("Failed to create descriptor pool, vr %d.\n", vr); diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 3360fd6e..59fa9af9 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -1277,6 +1277,16 @@ static void vkd3d_init_feature_level(struct vkd3d_vulkan_info *vk_info, TRACE("Max feature level: %#x.\n", vk_info->max_feature_level); } +static void vkd3d_device_descriptor_limits_init(struct vkd3d_device_descriptor_limits *limits, + const VkPhysicalDeviceLimits *device_limits) +{ + limits->uniform_buffer_max_descriptors = device_limits->maxDescriptorSetUniformBuffers; + limits->sampled_image_max_descriptors = device_limits->maxDescriptorSetSampledImages; + limits->storage_buffer_max_descriptors = device_limits->maxDescriptorSetStorageBuffers; + limits->storage_image_max_descriptors = device_limits->maxDescriptorSetStorageImages; + limits->sampler_max_descriptors = min(device_limits->maxDescriptorSetSamplers, VKD3D_MAX_DESCRIPTOR_SET_SAMPLERS); +} + static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, const struct vkd3d_device_create_info *create_info, struct vkd3d_physical_device_info *physical_device_info, @@ -1504,6 +1514,9 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, features->robustBufferAccess = VK_FALSE; } + vkd3d_device_descriptor_limits_init(&vulkan_info->descriptor_limits, + &physical_device_info->properties2.properties.limits); + return S_OK; } @@ -2419,6 +2432,27 @@ static void vkd3d_time_domains_init(struct d3d12_device *device) WARN("Found no acceptable host time domain. Calibrated timestamps will not be available.\n"); } +static void vkd3d_init_descriptor_pool_sizes(VkDescriptorPoolSize *pool_sizes, + const struct vkd3d_device_descriptor_limits *limits) +{ + pool_sizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; + pool_sizes[0].descriptorCount = min(limits->uniform_buffer_max_descriptors, + VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE); + pool_sizes[1].type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; + pool_sizes[1].descriptorCount = min(limits->sampled_image_max_descriptors, + VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE); + pool_sizes[2].type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; + pool_sizes[2].descriptorCount = pool_sizes[1].descriptorCount; + pool_sizes[3].type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; + pool_sizes[3].descriptorCount = min(limits->storage_image_max_descriptors, + VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE); + pool_sizes[4].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + pool_sizes[4].descriptorCount = pool_sizes[3].descriptorCount; + pool_sizes[5].type = VK_DESCRIPTOR_TYPE_SAMPLER; + pool_sizes[5].descriptorCount = min(limits->sampler_max_descriptors, + VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE); +}; + /* ID3D12Device */ static inline struct d3d12_device *impl_from_ID3D12Device(ID3D12Device *iface) { @@ -3979,6 +4013,8 @@ static HRESULT d3d12_device_init(struct d3d12_device *device, for (i = 0; i < ARRAY_SIZE(device->desc_mutex); ++i) vkd3d_mutex_init(&device->desc_mutex[i]); + vkd3d_init_descriptor_pool_sizes(device->vk_pool_sizes, &device->vk_info.descriptor_limits); + if ((device->parent = create_info->parent)) IUnknown_AddRef(device->parent); diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 67989c11..ca7a3f22 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -62,6 +62,12 @@ #define VKD3D_MAX_SHADER_STAGES 5u #define VKD3D_MAX_VK_SYNC_OBJECTS 4u #define VKD3D_MAX_DESCRIPTOR_SETS 64u +/* D3D12 binding tier 3 has a limit of 2048 samplers. */ +#define VKD3D_MAX_DESCRIPTOR_SET_SAMPLERS 2048u +/* The main limitation here is the simple descriptor pool recycling scheme + * requiring each pool to contain all descriptor types used by vkd3d. Limit + * this number to prevent excessive pool memory use. */ +#define VKD3D_MAX_VIRTUAL_HEAP_DESCRIPTORS_PER_TYPE (16 * 1024u) struct d3d12_command_list; struct d3d12_device; @@ -95,6 +101,15 @@ HRESULT hresult_from_errno(int rc); HRESULT hresult_from_vk_result(VkResult vr); HRESULT hresult_from_vkd3d_result(int vkd3d_result); +struct vkd3d_device_descriptor_limits +{ + unsigned int uniform_buffer_max_descriptors; + unsigned int sampled_image_max_descriptors; + unsigned int storage_buffer_max_descriptors; + unsigned int storage_image_max_descriptors; + unsigned int sampler_max_descriptors; +}; + struct vkd3d_vulkan_info { /* KHR instance extensions */ @@ -130,6 +145,7 @@ struct vkd3d_vulkan_info VkPhysicalDeviceLimits device_limits; VkPhysicalDeviceSparseProperties sparse_properties; + struct vkd3d_device_descriptor_limits descriptor_limits; VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT texel_buffer_alignment_properties; @@ -1299,6 +1315,8 @@ struct vkd3d_uav_clear_state HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device); void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device); +#define VKD3D_DESCRIPTOR_POOL_COUNT 6 + /* ID3D12Device */ struct d3d12_device { @@ -1352,6 +1370,8 @@ struct d3d12_device const struct vkd3d_format_compatibility_list *format_compatibility_lists; struct vkd3d_null_resources null_resources; struct vkd3d_uav_clear_state uav_clear_state; + + VkDescriptorPoolSize vk_pool_sizes[VKD3D_DESCRIPTOR_POOL_COUNT]; }; HRESULT d3d12_device_create(struct vkd3d_instance *instance, -- 2.34.1

4 12

Questions about whether Wine will participate in GSoC in 2022.
by Hui Xiang March 15, 2022

March 15, 2022

Dear Sir / Madam, I hope this email finds you well. My name is Hui Xiang, and I am an Electrical and Electronic Engineering student at the University of Manchester. I would like to participate in Google Summer of Code this summer. After doing research on previous programs, I was impressed by The Wine Project. I am writing this email to ask if Wine will participate in GSoC in 2022. I love Wine’s idea of running Windows apps on other operating systems while keeping the applications running efficiently with the CPU and memory. On Windows, there are a plethora of fantastic apps, such as Solidworks and AutoCAD. This project enables users to take advantage of both the applications and the operating systems through running these apps on diverse operating systems. I would appreciate the opportunity to make contributions to this project if Wine will participate GSoC in 2022. Thank you for your time. It would give me great pleasure to hear back from you. Best Regards, Hui

4 4

[PATCH v3 1/3] tools: headers should be within a consistent includedir.
by Kevin Puetz March 14, 2022

March 14, 2022

A wine installation should not be divided across multiple prefixes, and one shouldn't mix components from multiple installations. winegcc should therefore select a single viable get_inc_dir (as was with get_lib_dir) and add (only) its ${includedir}/wine/msvcrt and ${includedir}/wine/windows, not offer gcc multiple (potentially nonexistent or unrelated) paths to search for wine headers Signed-off-by: Kevin Puetz <PuetzKevinA(a)JohnDeere.com> -- e.g. for a wine built with --prefix /opt/wine-6 it's potentially the case that /usr/include/wine/* may also exist (perhaps from a distro package), but we don't really want winegcc adding both -I/opt/wine-6/include/windows -I/usr/include/wine/windows get_inc_dir is identical in all winegcc/widl/wrc tools, and thus seems like a good candidate to move into tools.h. However, its interactions with init_argv0_dir (includedir global variable, INCLUDDIR macro, etc) made that not really work out. --- tools/widl/widl.c | 39 ++++++++++++++++++++++------------ tools/winegcc/winegcc.c | 47 ++++++++++++++++++++++++----------------- tools/wrc/wrc.c | 39 ++++++++++++++++++++++------------ 3 files changed, 80 insertions(+), 45 deletions(-) diff --git a/tools/widl/widl.c b/tools/widl/widl.c index 7b2276b0a41..9e3b4a026f3 100644 --- a/tools/widl/widl.c +++ b/tools/widl/widl.c @@ -256,6 +256,29 @@ static void add_widl_version_define(void) wpp_add_cmdline_define(version_str); } +static const char *get_inc_dir(const char *sysroot) +{ + const char *stdincpath[] = { includedir, INCLUDEDIR, "/usr/include", "/usr/local/include" }; + const char *root = sysroot ? sysroot : ""; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(stdincpath); i++) + { + const char *root = (sysroot && i) ? sysroot : ""; + char *path; + struct stat statbuf; + + if (!stdincpath[i]) continue; + path = strmake( "%s%s/%s",root, stdincpath[i], "wine"); + if (!stat(path,&statbuf) && S_ISDIR(statbuf.st_mode)) + { + return strmake( "%s%s",root,stdincpath[i]); + } + } + + return strmake( "%s%s", root, INCLUDEDIR ); +} + /* clean things up when aborting on a signal */ static void exit_on_signal( int sig ) { @@ -733,19 +756,9 @@ int main(int argc,char *argv[]) if (stdinc) { - static const char *incl_dirs[] = { INCLUDEDIR, "/usr/include", "/usr/local/include" }; - - if (includedir) - { - wpp_add_include_path( strmake( "%s/wine/msvcrt", includedir )); - wpp_add_include_path( strmake( "%s/wine/windows", includedir )); - } - for (i = 0; i < ARRAY_SIZE(incl_dirs); i++) - { - if (i && !strcmp( incl_dirs[i], incl_dirs[0] )) continue; - wpp_add_include_path( strmake( "%s%s/wine/msvcrt", sysroot, incl_dirs[i] )); - wpp_add_include_path( strmake( "%s%s/wine/windows", sysroot, incl_dirs[i] )); - } + const char *inc_dir = get_inc_dir(sysroot); + wpp_add_include_path( strmake( "%s/wine/msvcrt", inc_dir)); + wpp_add_include_path( strmake( "%s/wine/windows", inc_dir)); } if (pointer_size) diff --git a/tools/winegcc/winegcc.c b/tools/winegcc/winegcc.c index bcec3916843..a5303b2794e 100644 --- a/tools/winegcc/winegcc.c +++ b/tools/winegcc/winegcc.c @@ -648,6 +648,29 @@ static char *get_lib_dir( struct options *opts ) return strmake( "%s%s", root, LIBDIR ); } +static const char *get_inc_dir(const char *sysroot) +{ + const char *stdincpath[] = { includedir, INCLUDEDIR, "/usr/include", "/usr/local/include" }; + const char *root = sysroot ? sysroot : ""; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(stdincpath); i++) + { + const char *root = (sysroot && i) ? sysroot : ""; + char *path; + struct stat statbuf; + + if (!stdincpath[i]) continue; + path = strmake( "%s%s/%s",root, stdincpath[i], "wine"); + if (!stat(path,&statbuf) && S_ISDIR(statbuf.st_mode)) + { + return strmake( "%s%s",root,stdincpath[i]); + } + } + + return strmake( "%s%s", root, INCLUDEDIR ); +} + static void init_argv0_dir( const char *argv0 ) { #ifndef _WIN32 @@ -814,32 +837,18 @@ no_compat_defines: /* standard includes come last in the include search path */ if (!opts->wine_objdir && !opts->nostdinc) { - const char *incl_dirs[] = { INCLUDEDIR, "/usr/include", "/usr/local/include" }; - const char *root = opts->isysroot ? opts->isysroot : opts->sysroot ? opts->sysroot : ""; + const char *inc_sysroot = opts->isysroot ? opts->isysroot : opts->sysroot; + const char *inc_dir = get_inc_dir(inc_sysroot); const char *isystem = gcc_defs ? "-isystem" : "-I"; const char *idirafter = gcc_defs ? "-idirafter" : "-I"; if (opts->use_msvcrt) { - if (includedir) strarray_add( &comp_args, strmake( "%s%s/wine/msvcrt", isystem, includedir )); - for (j = 0; j < ARRAY_SIZE(incl_dirs); j++) - { - if (j && !strcmp( incl_dirs[0], incl_dirs[j] )) continue; - strarray_add(&comp_args, strmake( "%s%s%s/wine/msvcrt", isystem, root, incl_dirs[j] )); - } + strarray_add(&comp_args, strmake( "%s%s/wine/msvcrt", isystem, inc_dir )); strarray_add(&comp_args, "-D__MSVCRT__"); } - if (includedir) - { - strarray_add( &comp_args, strmake( "%s%s/wine/windows", isystem, includedir )); - strarray_add( &comp_args, strmake( "%s%s", idirafter, includedir )); - } - for (j = 0; j < ARRAY_SIZE(incl_dirs); j++) - { - if (j && !strcmp( incl_dirs[0], incl_dirs[j] )) continue; - strarray_add(&comp_args, strmake( "%s%s%s/wine/windows", isystem, root, incl_dirs[j] )); - strarray_add(&comp_args, strmake( "%s%s%s", idirafter, root, incl_dirs[j] )); - } + strarray_add(&comp_args, strmake( "%s%s/wine/windows", isystem, inc_dir )); + strarray_add(&comp_args, strmake( "%s%s", idirafter, inc_dir)); } else if (opts->wine_objdir) strarray_add(&comp_args, strmake("-I%s/include", opts->wine_objdir) ); diff --git a/tools/wrc/wrc.c b/tools/wrc/wrc.c index c80827127fe..1b7c771dcf3 100644 --- a/tools/wrc/wrc.c +++ b/tools/wrc/wrc.c @@ -225,6 +225,29 @@ static void set_version_defines(void) free( version ); } +static const char *get_inc_dir(const char *sysroot) +{ + const char *stdincpath[] = { includedir, INCLUDEDIR, "/usr/include", "/usr/local/include" }; + const char *root = sysroot ? sysroot : ""; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(stdincpath); i++) + { + const char *root = (sysroot && i) ? sysroot : ""; + char *path; + struct stat statbuf; + + if (!stdincpath[i]) continue; + path = strmake( "%s%s/%s",root, stdincpath[i], "wine"); + if (!stat(path,&statbuf) && S_ISDIR(statbuf.st_mode)) + { + return strmake( "%s%s",root,stdincpath[i]); + } + } + + return strmake( "%s%s", root, INCLUDEDIR ); +} + /* clean things up when aborting on a signal */ static void exit_on_signal( int sig ) { @@ -453,19 +476,9 @@ int main(int argc,char *argv[]) /* If we do need to search standard includes, add them to the path */ if (stdinc) { - static const char *incl_dirs[] = { INCLUDEDIR, "/usr/include", "/usr/local/include" }; - - if (includedir) - { - wpp_add_include_path( strmake( "%s/wine/msvcrt", includedir )); - wpp_add_include_path( strmake( "%s/wine/windows", includedir )); - } - for (i = 0; i < ARRAY_SIZE(incl_dirs); i++) - { - if (i && !strcmp( incl_dirs[i], incl_dirs[0] )) continue; - wpp_add_include_path( strmake( "%s%s/wine/msvcrt", sysroot, incl_dirs[i] )); - wpp_add_include_path( strmake( "%s%s/wine/windows", sysroot, incl_dirs[i] )); - } + const char *inc_dir = get_inc_dir(sysroot); + wpp_add_include_path( strmake( "%s/wine/msvcrt", inc_dir)); + wpp_add_include_path( strmake( "%s/wine/windows", inc_dir)); } /* Kill io buffering when some kind of debuglevel is enabled */ -- 2.34.1

2 3

[PATCH 3/7] comctl32/tests: add more static control tests
by Rafał Harabień March 13, 2022

March 13, 2022

Signed-off-by: Rafał Harabień <rafalh92(a)outlook.com> --- dlls/comctl32/tests/static.c | 33 +++++++++++++++++++++++++++++---- 1 file changed, 29 insertions(+), 4 deletions(-) diff --git a/dlls/comctl32/tests/static.c b/dlls/comctl32/tests/static.c index 0038cadd7d2..7a072fcbbec 100644 --- a/dlls/comctl32/tests/static.c +++ b/dlls/comctl32/tests/static.c @@ -82,10 +82,29 @@ static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lpara static void test_updates(int style, int flags) { HWND hStatic = create_static(style); - RECT r1 = {20, 20, 30, 30}; + RECT r1 = {20, 20, 30, 30}, rcClient; int exp; + LONG exstyle; flush_events(); + trace("Testing style 0x%x\n", style); + + exstyle = GetWindowLongW(hStatic, GWL_EXSTYLE); + if (style == SS_ETCHEDHORZ || style == SS_ETCHEDVERT || style == SS_SUNKEN) + todo_wine_if(style == SS_ETCHEDHORZ || style == SS_ETCHEDVERT) ok(exstyle == WS_EX_STATICEDGE, "expected WS_EX_STATICEDGE, got %d\n", exstyle); + else + ok(exstyle == 0, "expected 0, got %d\n", exstyle); + + GetClientRect(hStatic, &rcClient); + if (style == SS_ETCHEDVERT) + todo_wine ok(rcClient.right == 0, "expected zero width, got %d\n", rcClient.right); + else + ok(rcClient.right > 0, "expected non-zero width, got %d\n", rcClient.right); + if (style == SS_ETCHEDHORZ) + todo_wine ok(rcClient.bottom == 0, "expected zero height, got %d\n", rcClient.bottom); + else + ok(rcClient.bottom > 0, "expected non-zero height, got %d\n", rcClient.bottom); + g_nReceivedColorStatic = 0; /* during each update parent WndProc will test the WM_CTLCOLORSTATIC message */ InvalidateRect(hMainWnd, NULL, FALSE); @@ -406,14 +425,20 @@ START_TEST(static) ShowWindow(hMainWnd, SW_SHOW); test_updates(0, 0); - test_updates(SS_SIMPLE, 0); test_updates(SS_ICON, 0); - test_updates(SS_BITMAP, 0); - test_updates(SS_BITMAP | SS_CENTERIMAGE, 0); test_updates(SS_BLACKRECT, TODO_COUNT); test_updates(SS_WHITERECT, TODO_COUNT); + test_updates(SS_BLACKFRAME, TODO_COUNT); + test_updates(SS_WHITEFRAME, TODO_COUNT); + test_updates(SS_USERITEM, TODO_COUNT); + test_updates(SS_SIMPLE, 0); + test_updates(SS_OWNERDRAW, 0); + test_updates(SS_BITMAP, 0); + test_updates(SS_BITMAP | SS_CENTERIMAGE, 0); test_updates(SS_ETCHEDHORZ, TODO_COUNT); test_updates(SS_ETCHEDVERT, TODO_COUNT); + test_updates(SS_ETCHEDFRAME, TODO_COUNT); + test_updates(SS_SUNKEN, 0); test_set_text(); test_set_image(); test_STM_SETIMAGE(); -- 2.25.1

2 1

[PATCH v3 4/8] dllhost: Implement IClassFactory::CreateInstance().
by Dmitry Timoshkov March 8, 2022

March 8, 2022

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- programs/dllhost/dllhost.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/programs/dllhost/dllhost.c b/programs/dllhost/dllhost.c index 691f233906a..681a20a6bb5 100644 --- a/programs/dllhost/dllhost.c +++ b/programs/dllhost/dllhost.c @@ -98,8 +98,14 @@ static ULONG WINAPI factory_Release(IClassFactory *iface) static HRESULT WINAPI factory_CreateInstance(IClassFactory *iface, IUnknown *punkouter, REFIID iid, void **ppv) { - FIXME("(%p,%p,%s,%p): stub\n", iface, punkouter, wine_dbgstr_guid(iid), ppv); - return E_NOTIMPL; + struct factory *factory = impl_from_IClassFactory(iface); + + TRACE("(%p,%p,%s,%p)\n", iface, punkouter, wine_dbgstr_guid(iid), ppv); + + if (punkouter) + return CLASS_E_NOAGGREGATION; + + return CoGetClassObject(&factory->clsid, CLSCTX_INPROC_SERVER, NULL, iid, ppv); } static HRESULT WINAPI factory_LockServer(IClassFactory *iface, BOOL lock) -- 2.35.1

2 4

[PATCH v3 3/8] dllhost: Implement ISurrogate::LoadDllServer().
by Dmitry Timoshkov March 8, 2022

March 8, 2022

v3: Forward IMarshal::QueryInterface() to parent IClassFactory::QueryInterface(). Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- programs/dllhost/dllhost.c | 200 ++++++++++++++++++++++++++++++++++++- 1 file changed, 198 insertions(+), 2 deletions(-) diff --git a/programs/dllhost/dllhost.c b/programs/dllhost/dllhost.c index a0d3b9937f1..691f233906a 100644 --- a/programs/dllhost/dllhost.c +++ b/programs/dllhost/dllhost.c @@ -28,9 +28,182 @@ WINE_DEFAULT_DEBUG_CHANNEL(dllhost); +struct factory +{ + IClassFactory IClassFactory_iface; + IMarshal IMarshal_iface; + CLSID clsid; + LONG ref; +}; + +static inline struct factory *impl_from_IClassFactory(IClassFactory *iface) +{ + return CONTAINING_RECORD(iface, struct factory, IClassFactory_iface); +} + +static inline struct factory *impl_from_IMarshal(IMarshal *iface) +{ + return CONTAINING_RECORD(iface, struct factory, IMarshal_iface); +} + +static HRESULT WINAPI factory_QueryInterface(IClassFactory *iface, + REFIID iid, void **ppv) +{ + struct factory *factory = impl_from_IClassFactory(iface); + + TRACE("(%p,%s,%p)\n", iface, wine_dbgstr_guid(iid), ppv); + + if (!ppv) return E_INVALIDARG; + + if (IsEqualIID(iid, &IID_IUnknown) || + IsEqualIID(iid, &IID_IClassFactory)) + { + IClassFactory_AddRef(&factory->IClassFactory_iface); + *ppv = &factory->IClassFactory_iface; + return S_OK; + } + else if (IsEqualIID(iid, &IID_IMarshal)) + { + IClassFactory_AddRef(&factory->IClassFactory_iface); + *ppv = &factory->IMarshal_iface; + return S_OK; + } + + *ppv = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI factory_AddRef(IClassFactory *iface) +{ + struct factory *factory = impl_from_IClassFactory(iface); + ULONG ref = InterlockedIncrement(&factory->ref); + + TRACE("(%p)->%lu\n", iface, ref); + return ref; +} + +static ULONG WINAPI factory_Release(IClassFactory *iface) +{ + struct factory *factory = impl_from_IClassFactory(iface); + ULONG ref = InterlockedDecrement(&factory->ref); + + TRACE("(%p)->%lu\n", iface, ref); + + if (!ref) + HeapFree(GetProcessHeap(), 0, factory); + + return ref; +} + +static HRESULT WINAPI factory_CreateInstance(IClassFactory *iface, + IUnknown *punkouter, REFIID iid, void **ppv) +{ + FIXME("(%p,%p,%s,%p): stub\n", iface, punkouter, wine_dbgstr_guid(iid), ppv); + return E_NOTIMPL; +} + +static HRESULT WINAPI factory_LockServer(IClassFactory *iface, BOOL lock) +{ + TRACE("(%p,%d)\n", iface, lock); + return S_OK; +} + +static const IClassFactoryVtbl ClassFactory_Vtbl = +{ + factory_QueryInterface, + factory_AddRef, + factory_Release, + factory_CreateInstance, + factory_LockServer +}; + +static HRESULT WINAPI marshal_QueryInterface(IMarshal *iface, REFIID iid, LPVOID *ppv) +{ + struct factory *factory = impl_from_IMarshal(iface); + + TRACE("(%p,%s,%p)\n", iface, wine_dbgstr_guid(iid), ppv); + + return IClassFactory_QueryInterface(&factory->IClassFactory_iface, iid, ppv); +} + +static ULONG WINAPI marshal_AddRef(IMarshal *iface) +{ + struct factory *factory = impl_from_IMarshal(iface); + + TRACE("(%p)\n", iface); + + return IClassFactory_AddRef(&factory->IClassFactory_iface); +} + +static ULONG WINAPI marshal_Release(IMarshal *iface) +{ + struct factory *factory = impl_from_IMarshal(iface); + + TRACE("(%p)\n", iface); + + return IClassFactory_Release(&factory->IClassFactory_iface); +} + +static HRESULT WINAPI marshal_GetUnmarshalClass(IMarshal *iface, REFIID iid, void *pv, + DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, CLSID *clsid) +{ + FIXME("(%p,%s,%p,%08lx,%p,%08lx,%p): stub\n", iface, wine_dbgstr_guid(iid), pv, + dwDestContext, pvDestContext, mshlflags, clsid); + return E_NOTIMPL; +} + +static HRESULT WINAPI marshal_GetMarshalSizeMax(IMarshal *iface, REFIID iid, void *pv, + DWORD dwDestContext, void *pvDestContext, DWORD mshlflags, DWORD *size) +{ + FIXME("(%p,%s,%p,%08lx,%p,%08lx,%p): stub\n", iface, wine_dbgstr_guid(iid), pv, + dwDestContext, pvDestContext, mshlflags, size); + return E_NOTIMPL; +} + +static HRESULT WINAPI marshal_MarshalInterface(IMarshal *iface, IStream *stream, REFIID iid, + void *pv, DWORD dwDestContext, void *pvDestContext, DWORD mshlflags) +{ + FIXME("(%p,%s,%p,%08lx,%p,%08lx): stub\n", stream, wine_dbgstr_guid(iid), pv, dwDestContext, pvDestContext, mshlflags); + return E_NOTIMPL; +} + +static HRESULT WINAPI marshal_UnmarshalInterface(IMarshal *iface, IStream *stream, + REFIID iid, void **ppv) +{ + FIXME("(%p,%p,%s,%p): stub\n", iface, stream, wine_dbgstr_guid(iid), ppv); + return E_NOTIMPL; +} + +static HRESULT WINAPI marshal_ReleaseMarshalData(IMarshal *iface, IStream *stream) +{ + TRACE("(%p,%p)\n", iface, stream); + return S_OK; +} + +static HRESULT WINAPI marshal_DisconnectObject(IMarshal *iface, DWORD reserved) +{ + TRACE("(%p, %08lx)\n", iface, reserved); + return S_OK; +} + +static const IMarshalVtbl Marshal_Vtbl = +{ + marshal_QueryInterface, + marshal_AddRef, + marshal_Release, + marshal_GetUnmarshalClass, + marshal_GetMarshalSizeMax, + marshal_MarshalInterface, + marshal_UnmarshalInterface, + marshal_ReleaseMarshalData, + marshal_DisconnectObject +}; + struct surrogate { ISurrogate ISurrogate_iface; + IClassFactory *factory; + DWORD cookie; LONG ref; }; @@ -74,8 +247,29 @@ static ULONG WINAPI surrogate_Release(ISurrogate *iface) static HRESULT WINAPI surrogate_LoadDllServer(ISurrogate *iface, const CLSID *clsid) { - FIXME("(%p,%s): stub\n", iface, wine_dbgstr_guid(clsid)); - return E_NOTIMPL; + struct surrogate *surrogate = impl_from_ISurrogate(iface); + struct factory *factory; + HRESULT hr; + + TRACE("(%p,%s)\n", iface, wine_dbgstr_guid(clsid)); + + factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory)); + if (!factory) + return E_OUTOFMEMORY; + + factory->IClassFactory_iface.lpVtbl = &ClassFactory_Vtbl; + factory->IMarshal_iface.lpVtbl = &Marshal_Vtbl; + factory->clsid = *clsid; + factory->ref = 1; + + hr = CoRegisterClassObject(clsid, (IUnknown *)&factory->IClassFactory_iface, + CLSCTX_LOCAL_SERVER, REGCLS_SURROGATE, &surrogate->cookie); + if (hr != S_OK) + IClassFactory_Release(&factory->IClassFactory_iface); + else + surrogate->factory = &factory->IClassFactory_iface; + + return hr; } static HRESULT WINAPI surrogate_FreeSurrogate(ISurrogate *iface) @@ -105,6 +299,8 @@ int WINAPI wWinMain(HINSTANCE hinst, HINSTANCE previnst, LPWSTR cmdline, int sho cmdline += 11; surrogate.ISurrogate_iface.lpVtbl = &Surrogate_Vtbl; + surrogate.factory = NULL; + surrogate.cookie = 0; surrogate.ref = 1; CoInitializeEx(NULL, COINIT_MULTITHREADED); -- 2.35.1

2 1

[PATCH v3 2/8] dllhost: Add ISurrogate stub implementation.
by Dmitry Timoshkov March 8, 2022

March 8, 2022

Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- programs/dllhost/Makefile.in | 2 +- programs/dllhost/dllhost.c | 84 +++++++++++++++++++++++++++++++++++- 2 files changed, 84 insertions(+), 2 deletions(-) diff --git a/programs/dllhost/Makefile.in b/programs/dllhost/Makefile.in index a92add9c2f0..bca6c208cdc 100644 --- a/programs/dllhost/Makefile.in +++ b/programs/dllhost/Makefile.in @@ -1,5 +1,5 @@ MODULE = dllhost.exe -IMPORTS = ole32 +IMPORTS = ole32 uuid EXTRADLLFLAGS = -mwindows -municode diff --git a/programs/dllhost/dllhost.c b/programs/dllhost/dllhost.c index 39d2194db4b..a0d3b9937f1 100644 --- a/programs/dllhost/dllhost.c +++ b/programs/dllhost/dllhost.c @@ -18,6 +18,8 @@ #include <stdarg.h> +#define COBJMACROS + #include <windef.h> #include <winbase.h> #include <objbase.h> @@ -26,24 +28,104 @@ WINE_DEFAULT_DEBUG_CHANNEL(dllhost); +struct surrogate +{ + ISurrogate ISurrogate_iface; + LONG ref; +}; + +static inline struct surrogate *impl_from_ISurrogate(ISurrogate *iface) +{ + return CONTAINING_RECORD(iface, struct surrogate, ISurrogate_iface); +} + +static HRESULT WINAPI surrogate_QueryInterface(ISurrogate *iface, + REFIID iid, void **ppv) +{ + struct surrogate *surrogate = impl_from_ISurrogate(iface); + + TRACE("(%p,%s,%p)\n", iface, wine_dbgstr_guid(iid), ppv); + + if (!ppv) return E_INVALIDARG; + + if (IsEqualIID(iid, &IID_IUnknown) || + IsEqualIID(iid, &IID_ISurrogate)) + { + ISurrogate_AddRef(&surrogate->ISurrogate_iface); + *ppv = &surrogate->ISurrogate_iface; + return S_OK; + } + + *ppv = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI surrogate_AddRef(ISurrogate *iface) +{ + TRACE("(%p)\n", iface); + return 2; +} + +static ULONG WINAPI surrogate_Release(ISurrogate *iface) +{ + TRACE("(%p)\n", iface); + return 1; +} + +static HRESULT WINAPI surrogate_LoadDllServer(ISurrogate *iface, const CLSID *clsid) +{ + FIXME("(%p,%s): stub\n", iface, wine_dbgstr_guid(clsid)); + return E_NOTIMPL; +} + +static HRESULT WINAPI surrogate_FreeSurrogate(ISurrogate *iface) +{ + FIXME("(%p): stub\n", iface); + return E_NOTIMPL; +} + +static const ISurrogateVtbl Surrogate_Vtbl = +{ + surrogate_QueryInterface, + surrogate_AddRef, + surrogate_Release, + surrogate_LoadDllServer, + surrogate_FreeSurrogate +}; + int WINAPI wWinMain(HINSTANCE hinst, HINSTANCE previnst, LPWSTR cmdline, int showcmd) { HRESULT hr; CLSID clsid; + struct surrogate surrogate; if (wcsnicmp(cmdline, L"/PROCESSID:", 11)) return 0; cmdline += 11; + surrogate.ISurrogate_iface.lpVtbl = &Surrogate_Vtbl; + surrogate.ref = 1; + CoInitializeEx(NULL, COINIT_MULTITHREADED); hr = CLSIDFromString(cmdline, &clsid); if (hr == S_OK) { - FIXME("hosting object %s is not implemented\n", wine_dbgstr_guid(&clsid)); + CoRegisterSurrogate(&surrogate.ISurrogate_iface); + + hr = ISurrogate_LoadDllServer(&surrogate.ISurrogate_iface, &clsid); + if (hr != S_OK) + { + ERR("Can't create instance of %s\n", wine_dbgstr_guid(&clsid)); + goto cleanup; + } + + /* FIXME: wait for FreeSurrogate being called */ + Sleep(INFINITE); } +cleanup: CoUninitialize(); return 0; -- 2.35.1

2 1

[PATCH v3 1/8] dllhost: Add stub implementation.
by Dmitry Timoshkov March 8, 2022

March 8, 2022

v3: Switch to using /PROCESSID:{GUID} as a command line syntax. Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- configure | 2 ++ configure.ac | 1 + programs/dllhost/Makefile.in | 7 +++++ programs/dllhost/dllhost.c | 50 ++++++++++++++++++++++++++++++++++++ 4 files changed, 60 insertions(+) create mode 100644 programs/dllhost/Makefile.in create mode 100644 programs/dllhost/dllhost.c diff --git a/configure b/configure index 9ceef4c809b..511fc8b794a 100755 --- a/configure +++ b/configure @@ -1558,6 +1558,7 @@ enable_conhost enable_control enable_cscript enable_dism +enable_dllhost enable_dplaysvr enable_dpnsvr enable_dpvsetup @@ -22076,6 +22077,7 @@ wine_fn_config_makefile programs/conhost/tests enable_tests wine_fn_config_makefile programs/control enable_control wine_fn_config_makefile programs/cscript enable_cscript wine_fn_config_makefile programs/dism enable_dism +wine_fn_config_makefile programs/dllhost enable_dllhost wine_fn_config_makefile programs/dplaysvr enable_dplaysvr wine_fn_config_makefile programs/dpnsvr enable_dpnsvr wine_fn_config_makefile programs/dpvsetup enable_dpvsetup diff --git a/configure.ac b/configure.ac index d14cc396e51..f40d83eb18d 100644 --- a/configure.ac +++ b/configure.ac @@ -3258,6 +3258,7 @@ WINE_CONFIG_MAKEFILE(programs/conhost/tests) WINE_CONFIG_MAKEFILE(programs/control) WINE_CONFIG_MAKEFILE(programs/cscript) WINE_CONFIG_MAKEFILE(programs/dism) +WINE_CONFIG_MAKEFILE(programs/dllhost) WINE_CONFIG_MAKEFILE(programs/dplaysvr) WINE_CONFIG_MAKEFILE(programs/dpnsvr) WINE_CONFIG_MAKEFILE(programs/dpvsetup) diff --git a/programs/dllhost/Makefile.in b/programs/dllhost/Makefile.in new file mode 100644 index 00000000000..a92add9c2f0 --- /dev/null +++ b/programs/dllhost/Makefile.in @@ -0,0 +1,7 @@ +MODULE = dllhost.exe +IMPORTS = ole32 + +EXTRADLLFLAGS = -mwindows -municode + +C_SRCS = \ + dllhost.c diff --git a/programs/dllhost/dllhost.c b/programs/dllhost/dllhost.c new file mode 100644 index 00000000000..39d2194db4b --- /dev/null +++ b/programs/dllhost/dllhost.c @@ -0,0 +1,50 @@ +/* + * Copyright 2022 Dmitry Timoshkov + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> + +#include <windef.h> +#include <winbase.h> +#include <objbase.h> + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dllhost); + +int WINAPI wWinMain(HINSTANCE hinst, HINSTANCE previnst, LPWSTR cmdline, int showcmd) +{ + HRESULT hr; + CLSID clsid; + + if (wcsnicmp(cmdline, L"/PROCESSID:", 11)) + return 0; + + cmdline += 11; + + CoInitializeEx(NULL, COINIT_MULTITHREADED); + + hr = CLSIDFromString(cmdline, &clsid); + if (hr == S_OK) + { + FIXME("hosting object %s is not implemented\n", wine_dbgstr_guid(&clsid)); + } + + CoUninitialize(); + + return 0; +} -- 2.35.1

2 1

[PATCH v8 1/5] api-ms-win-core-privateprofile-l1-1-0: Add dll.
by Mohamad Al-Jaf March 7, 2022

March 7, 2022

Needed for native mfc42u.dll. Signed-off-by: Mohamad Al-Jaf <mohamadaljaf(a)gmail.com> --- v7: Rebase. v8: Add entry to tools/make_specfiles. --- configure.ac | 1 + .../Makefile.in | 1 + .../api-ms-win-core-privateprofile-l1-1-0.spec | 14 ++++++++++++++ tools/make_specfiles | 1 + 4 files changed, 17 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 a51d5d44ee7..aa08b282688 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 diff --git a/tools/make_specfiles b/tools/make_specfiles index 8f83034f160..946705fa1de 100755 --- a/tools/make_specfiles +++ b/tools/make_specfiles @@ -272,6 +272,7 @@ my @dll_groups = "api-ms-win-core-namespace-l1-1-0", "api-ms-win-core-normalization-l1-1-0", "api-ms-win-core-path-l1-1-0", + "api-ms-win-core-privateprofile-l1-1-0", "api-ms-win-core-privateprofile-l1-1-1", "api-ms-win-core-processenvironment-l1-1-0", "api-ms-win-core-processenvironment-l1-2-0", -- 2.35.1

3 12

[PATCH] api-ms-win-core-versionansi-l1-1-1
by David Warner March 7, 2022

March 7, 2022

Required for Adobe DNG Converter 14+ Signed-off-by: David Warner <david.p.warner(a)gmail.com> --- dlls/apisetschema/apisetschema.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/apisetschema/apisetschema.spec b/dlls/apisetschema/apisetschema.spec index dce332e51fb..a47a6fc4016 100644 --- a/dlls/apisetschema/apisetschema.spec +++ b/dlls/apisetschema/apisetschema.spec @@ -140,7 +140,7 @@ apiset api-ms-win-core-url-l1-1-0 = kernelbase.dll apiset api-ms-win-core-util-l1-1-0 = kernel32.dll apiset api-ms-win-core-version-l1-1-1 = kernelbase.dll apiset api-ms-win-core-version-private-l1-1-0 = kernelbase.dll -apiset api-ms-win-core-versionansi-l1-1-0 = kernelbase.dll +apiset api-ms-win-core-versionansi-l1-1-1 = kernelbase.dll apiset api-ms-win-core-windowsceip-l1-1-0 = kernelbase.dll apiset api-ms-win-core-windowserrorreporting-l1-1-1 = kernelbase.dll apiset api-ms-win-core-winrt-error-l1-1-1 = combase.dll -- 2.35.1

2 2

Re: [PATCH v2 1/3] vcomp: Implement _vcomp_for_dynamic_init_i8()
by David Koller March 4, 2022

March 4, 2022

Thanks a lot, Zebediah, for your comments on my vcomp patches; I really appreciate you taking time to review them! > Does it even make sense to make these unions? Can we just make the > relevant members 64-bit? > > Alternatively, should these be stored separately from the 32-bit > versions? Tests showing what happens if you mix and match 32-bit and > 64-bit calls might be helpful. Right, I considered three alternatives: 1. Create new separate vcomp_thread and vcomp_task structures for the 64-bit data, 2. Increase the 32-bit data members to 64-bit, or 3. Use unions Creating new separate 64-bit data structures for the 64-bit calls would necessitate adding a bunch of new and redundant code (to initialize the new structs, etc.), but would be the most performant. Increasing the 32-bit members to 64-bit would waste the most memory and be the least performant for 32-bit calls, but would eliminate redundant code. My choice of unions is a compromise; new data structures are unnecessary and the separate 32-bit and 64-bit calls each access their native data types, which is good for performance. Using unions in this way is a traditional approach in OpenMP runtime implementations. For example, if you look at the code for libgomp, the most widely used OpenMP implementation, you will see that it uses unions to handle 32/64-bit variants in a similar manner: https://github.com/gcc-mirror/gcc/blob/1931cbad498e625b1e24452dcfffe02539b1… > > Could we share any (or all) of this code with the 32-bit version? > Yes, if the top priority was to minimize redundant code, then refactoring these functions to handle both the 32-bit and 64-bit cases is possible. However, performance would suffer. If you look at the other previously-implemented vcomp functions, you'll see that earlier Wine contributors implemented separate 32-bit and 64-bit versions of functions for other scheduling modes: _vcomp_for_static_init() and _vcomp_for_static_init_i8(), _vcomp_for_static_simple_init() and _vcomp_for_static_simple_init_i8(), etc. My patches follow this same pre-established pattern. I believe that my patches strike a good balance between performance, memory usage, and code concision. clarity, and consistency. If you insist on me changing something, I'm happy to do so. Otherwise, I hope we can get these patches committed swiftly, so that I can move my attention to making further improvements to Wine's vcomp/OpenMP support.

3 3

[PATCH 1/3] winegstreamer: Implement WMA decoder Process(Input|Output) error checks.
by Rémi Bernon March 3, 2022

March 3, 2022

Checking that WMA decoder ignores any incorrectly sized input sample. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51931 Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52391 Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- I believe this approach works best and doesn't suffer from any of the potential troubles the queue would introduce. It should also be fully synchronous in the general case, although I kept the mutex to be safe. For now, one input buffer can be queued at a time, which is how the WMA decoder transform works, and the output buffers are appended to each other, although they are normally also produced one at a time. Later, and to satisfy the requirements of the H264 transform and the expectations of CoD: BO3, I will change the input to a GstBufferList with a length limit. Even for the zero-copy optimization, I was able to validate that it's still possible, and even simpler to implement as we now do all the processing in ProcessOutput. We can then later consider adding some asynchronicity using queues, but I'm not sure it is going to be useful, and may even cause more problems than it's worth. dlls/mf/tests/mf.c | 23 +++++++++++++--------- dlls/winegstreamer/wma_decoder.c | 33 ++++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+), 9 deletions(-) diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index e61442bb512..0ab46445d9a 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -6031,6 +6031,7 @@ static void test_wma_decoder(void) MFT_REGISTER_TYPE_INFO input_type = {MFMediaType_Audio, MFAudioFormat_WMAudioV8}; MFT_REGISTER_TYPE_INFO output_type = {MFMediaType_Audio, MFAudioFormat_Float}; MFT_OUTPUT_STREAM_INFO output_info; + MFT_OUTPUT_DATA_BUFFER outputs[2]; MFT_INPUT_STREAM_INFO input_info; MFT_OUTPUT_DATA_BUFFER output; const BYTE *wma_encoded_data; @@ -6208,7 +6209,7 @@ static void test_wma_decoder(void) ok(hr == S_OK, "ProcessInput returned %#x\n", hr); ret = IMFSample_Release(sample); ok(ret == 0, "Release returned %u\n", ret); - sample = create_sample(wma_encoded_data + wma_block_size, wma_block_size - wma_block_size / 2); + sample = create_sample(wma_encoded_data, wma_block_size + 1); hr = IMFTransform_ProcessInput(transform, 0, sample, 0); todo_wine ok(hr == S_OK, "ProcessInput returned %#x\n", hr); @@ -6231,16 +6232,13 @@ static void test_wma_decoder(void) status = 0xdeadbeef; memset(&output, 0, sizeof(output)); hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status); - todo_wine ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#x\n", hr); ok(output.dwStreamID == 0, "got dwStreamID %u\n", output.dwStreamID); ok(!output.pSample, "got pSample %p\n", output.pSample); - todo_wine ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE || broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */, "got dwStatus %#x\n", output.dwStatus); ok(!output.pEvents, "got pEvents %p\n", output.pEvents); - todo_wine ok(status == 0, "got status %#x\n", status); sample = create_sample(wma_encoded_data, wma_block_size); @@ -6253,16 +6251,25 @@ static void test_wma_decoder(void) status = 0xdeadbeef; memset(&output, 0, sizeof(output)); hr = IMFTransform_ProcessOutput(transform, 0, 1, &output, &status); - todo_wine ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#x\n", hr); ok(!output.pSample, "got pSample %p\n", output.pSample); - todo_wine ok(output.dwStatus == MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE || broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE)) /* Win7 */, "got dwStatus %#x\n", output.dwStatus); - todo_wine ok(status == 0, "got status %#x\n", status); + status = 0xdeadbeef; + memset(&output, 0, sizeof(output)); + output_info.cbSize = sizeof(wma_decoded_data); + sample = create_sample(NULL, output_info.cbSize); + outputs[0].pSample = sample; + sample = create_sample(NULL, output_info.cbSize); + outputs[1].pSample = sample; + hr = IMFTransform_ProcessOutput(transform, 0, 2, outputs, &status); + ok(hr == E_INVALIDARG, "ProcessOutput returned %#x\n", hr); + IMFSample_Release(outputs[0].pSample); + IMFSample_Release(outputs[1].pSample); + i = 1; status = 0xdeadbeef; output_info.cbSize = sizeof(wma_decoded_data); @@ -6333,7 +6340,6 @@ static void test_wma_decoder(void) ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "ProcessOutput returned %#x\n", hr); ok(output.pSample == sample, "got pSample %p\n", output.pSample); ok(output.dwStatus == 0, "got dwStatus %#x\n", output.dwStatus); - todo_wine ok(status == 0, "got status %#x\n", status); ret = IMFSample_Release(sample); ok(ret == 0, "Release returned %u\n", ret); @@ -6349,7 +6355,6 @@ static void test_wma_decoder(void) ok(output.dwStatus == 0 || broken(output.dwStatus == (MFT_OUTPUT_DATA_BUFFER_INCOMPLETE|7)) /* Win7 */, "got dwStatus %#x\n", output.dwStatus); - todo_wine ok(status == 0, "got status %#x\n", status); check_sample(sample, NULL, 0, NULL); ret = IMFSample_Release(sample); diff --git a/dlls/winegstreamer/wma_decoder.c b/dlls/winegstreamer/wma_decoder.c index 6c198706944..a35da1cdc70 100644 --- a/dlls/winegstreamer/wma_decoder.c +++ b/dlls/winegstreamer/wma_decoder.c @@ -520,14 +520,47 @@ static HRESULT WINAPI transform_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_ static HRESULT WINAPI transform_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags) { + struct wma_decoder *decoder = impl_from_IMFTransform(iface); + MFT_INPUT_STREAM_INFO info; + HRESULT hr; + FIXME("iface %p, id %lu, sample %p, flags %#lx stub!\n", iface, id, sample, flags); + + if (!decoder->wg_transform) + return MF_E_TRANSFORM_TYPE_NOT_SET; + + if (FAILED(hr = IMFTransform_GetInputStreamInfo(iface, 0, &info))) + return hr; + return E_NOTIMPL; } static HRESULT WINAPI transform_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count, MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status) { + struct wma_decoder *decoder = impl_from_IMFTransform(iface); + MFT_OUTPUT_STREAM_INFO info; + HRESULT hr; + FIXME("iface %p, flags %#lx, count %lu, samples %p, status %p stub!\n", iface, flags, count, samples, status); + + if (count > 1) + return E_INVALIDARG; + + if (!decoder->wg_transform) + return MF_E_TRANSFORM_TYPE_NOT_SET; + + if (FAILED(hr = IMFTransform_GetOutputStreamInfo(iface, 0, &info))) + return hr; + + *status = 0; + samples[0].dwStatus = 0; + if (!samples[0].pSample) + { + samples[0].dwStatus = MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE; + return MF_E_TRANSFORM_NEED_MORE_INPUT; + } + return E_NOTIMPL; } -- 2.34.1

3 5

[PATCH vkd3d] vkd3d-shader/hlsl: Fix order of matrix dimensions in hlsl_type_to_string().
by Francisco Casas March 2, 2022

March 2, 2022

Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index a9a42770..02a7ff42 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -902,7 +902,7 @@ struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const stru case HLSL_CLASS_MATRIX: assert(type->base_type < ARRAY_SIZE(base_types)); - vkd3d_string_buffer_printf(string, "%s%ux%u", base_types[type->base_type], type->dimx, type->dimy); + vkd3d_string_buffer_printf(string, "%s%ux%u", base_types[type->base_type], type->dimy, type->dimx); return string; case HLSL_CLASS_ARRAY: -- 2.25.1

5 4

[PATCH vkd3d v2 1/7] vkd3d-shader/hlsl: Introduce a helper to validate that an instruction has integer type.
by Zebediah Figura March 2, 2022

March 2, 2022

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl.y | 46 ++++++++++++++++++++-------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y index 459ad03bf..01e6b3dfb 100644 --- a/libs/vkd3d-shader/hlsl.y +++ b/libs/vkd3d-shader/hlsl.y @@ -1014,6 +1014,27 @@ static struct hlsl_ir_expr *add_expr(struct hlsl_ctx *ctx, struct list *instrs, return expr; } +static void check_integer_type(struct hlsl_ctx *ctx, const struct hlsl_ir_node *instr) +{ + const struct hlsl_type *type = instr->data_type; + struct vkd3d_string_buffer *string; + + switch (type->base_type) + { + case HLSL_TYPE_BOOL: + case HLSL_TYPE_INT: + case HLSL_TYPE_UINT: + break; + + default: + if ((string = hlsl_type_to_string(ctx, type))) + hlsl_error(ctx, &instr->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, + "Expression type '%s' is not integer.", string->buffer); + hlsl_release_string_buffer(ctx, string); + break; + } +} + static struct hlsl_ir_expr *add_unary_arithmetic_expr(struct hlsl_ctx *ctx, struct list *instrs, enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg, const struct vkd3d_shader_location *loc) { @@ -1061,29 +1082,8 @@ static struct hlsl_ir_expr *add_binary_bitwise_expr(struct hlsl_ctx *ctx, struct enum hlsl_ir_expr_op op, struct hlsl_ir_node *arg1, struct hlsl_ir_node *arg2, const struct vkd3d_shader_location *loc) { - if (arg1->data_type->base_type != HLSL_TYPE_INT && arg1->data_type->base_type != HLSL_TYPE_UINT - && arg1->data_type->base_type != HLSL_TYPE_BOOL) - { - struct vkd3d_string_buffer *type_str = hlsl_type_to_string(ctx, arg1->data_type); - - if (type_str) - hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, - "The first argument has type '%s', which is not integer.", type_str->buffer); - hlsl_release_string_buffer(ctx, type_str); - return NULL; - } - - if (arg2->data_type->base_type != HLSL_TYPE_INT && arg2->data_type->base_type != HLSL_TYPE_UINT - && arg2->data_type->base_type != HLSL_TYPE_BOOL) - { - struct vkd3d_string_buffer *type_str = hlsl_type_to_string(ctx, arg2->data_type); - - if (type_str) - hlsl_error(ctx, loc, VKD3D_SHADER_ERROR_HLSL_INVALID_TYPE, - "The second argument has type '%s', which is not integer.", type_str->buffer); - hlsl_release_string_buffer(ctx, type_str); - return NULL; - } + check_integer_type(ctx, arg1); + check_integer_type(ctx, arg2); return add_binary_arithmetic_expr(ctx, instrs, op, arg1, arg2, loc); } -- 2.35.1

5 29

[PATCH vkd3d v2 1/5] tests: Add some simple tests for HLSL function calls.
by Matteo Bruni March 2, 2022

March 2, 2022

From: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> Signed-off-by: Francisco Casas <fcasas(a)codeweavers.com> Signed-off-by: Matteo Bruni <mbruni(a)codeweavers.com> --- v2: Get rid of the second comment entirely. I'm not sure that the C standard really allows a void return, but regardless it's probably not that important to bring that up here. Makefile.am | 2 + tests/hlsl-function.shader_test | 164 ++++++++++++++++++++++++++++++++ 2 files changed, 166 insertions(+) create mode 100644 tests/hlsl-function.shader_test diff --git a/Makefile.am b/Makefile.am index 24257062..57cf5780 100644 --- a/Makefile.am +++ b/Makefile.am @@ -65,6 +65,7 @@ vkd3d_shader_tests = \ tests/hlsl-cross.shader_test \ tests/hlsl-duplicate-modifiers.shader_test \ tests/hlsl-for.shader_test \ + tests/hlsl-function.shader_test \ tests/hlsl-function-overload.shader_test \ tests/hlsl-gather-offset.shader_test \ tests/hlsl-gather.shader_test \ @@ -316,6 +317,7 @@ XFAIL_TESTS = \ tests/hlsl-bool-cast.shader_test \ tests/hlsl-duplicate-modifiers.shader_test \ tests/hlsl-for.shader_test \ + tests/hlsl-function.shader_test \ tests/hlsl-function-overload.shader_test \ tests/hlsl-gather.shader_test \ tests/hlsl-intrinsic-override.shader_test \ diff --git a/tests/hlsl-function.shader_test b/tests/hlsl-function.shader_test new file mode 100644 index 00000000..8d17605b --- /dev/null +++ b/tests/hlsl-function.shader_test @@ -0,0 +1,164 @@ +[pixel shader fail] + +float4 func(); + +float4 main() : sv_target +{ + return func(); +} + +% It's legal to call an undefined function in unused code, though. + +[pixel shader] + +float4 func(); + +float4 unused() +{ + return func(); +} + +float4 main() : sv_target +{ + return 0; +} + +[pixel shader fail] + +void func(inout float o) +{ + o += 0.1; +} + +float4 main() : sv_target +{ + float x = 0; + func(x + 1); + return 0; +} + +[pixel shader fail] + +void func(inout float2 o) +{ + o += 0.1; +} + +float4 main() : sv_target +{ + float2 x = 0; + func(x.yy); + return 0; +} + +[pixel shader fail] + +void func(out float o) +{ + o = 0.1; +} + +float4 main() : sv_target +{ + const float x = 0; + func(x); + return x; +} + +[pixel shader fail] + +void func(inout float o) +{ +} + +float4 main() : sv_target +{ + const float x = 0; + func(x); + return x; +} + +[pixel shader fail] + +void func() +{ +} + +float4 main() : sv_target +{ + return func(); +} + +[pixel shader fail] + +void foo() +{ +} + +void bar() +{ + return foo(); +} + +float4 main() : sv_target +{ + bar(); + return 0; +} + +[pixel shader fail] + +float4 main() : sv_target +{ + func(); + return 0; +} + +void func() +{ +} + +[pixel shader] + +float func(in float a, out float b, inout float c) +{ + c -= 0.2; + b = a * 2; + return a + 0.2; +} + +float4 main() : sv_target +{ + float x[2], ret; + + x[0] = 0.1; + x[1] = 0.9; + ret = func(0.3, x[0], x[1]); + + return float4(ret, x[0], x[1], 0); +} + +[test] +draw quad +probe all rgba (0.5, 0.6, 0.7, 0) + +[pixel shader] + +void func(in float a, inout float2 b) +{ + b.y += 0.1; + b *= a; +} + +float4 main() : sv_target +{ + float3 q = float3(0.1, 0.2, 0.3); + + func(3.0, q.zx); + func(0.5, q.yz); + return float4(q, 0); +} + +[test] +draw quad +probe all rgba (0.6, 0.1, 0.5, 0) -- 2.34.1

5 10

[PATCH 2/6] winealsa: Move timer_loop to the unixlib.
by Huw Davies March 2, 2022

March 2, 2022

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winealsa.drv/alsa.c | 230 +++++++++++++++++++++++++++++++++++ dlls/winealsa.drv/mmdevdrv.c | 229 +++------------------------------- dlls/winealsa.drv/unixlib.h | 9 +- 3 files changed, 258 insertions(+), 210 deletions(-) diff --git a/dlls/winealsa.drv/alsa.c b/dlls/winealsa.drv/alsa.c index 73971c0f8bb..91ead000497 100644 --- a/dlls/winealsa.drv/alsa.c +++ b/dlls/winealsa.drv/alsa.c @@ -960,6 +960,12 @@ static NTSTATUS release_stream(void *args) struct alsa_stream *stream = params->stream; SIZE_T size; + if(params->timer_thread){ + stream->please_quit = TRUE; + NtWaitForSingleObject(params->timer_thread, FALSE, NULL); + NtClose(params->timer_thread); + } + snd_pcm_drop(stream->pcm_handle); snd_pcm_close(stream->pcm_handle); if(stream->local_buffer){ @@ -1215,6 +1221,229 @@ static NTSTATUS write_best_effort(void *args) return STATUS_SUCCESS; } +static snd_pcm_sframes_t alsa_write_buffer_wrap(struct alsa_stream *stream, BYTE *buf, + snd_pcm_uframes_t buflen, snd_pcm_uframes_t offs, + snd_pcm_uframes_t to_write) +{ + snd_pcm_sframes_t ret = 0; + + while(to_write){ + snd_pcm_uframes_t chunk; + snd_pcm_sframes_t tmp; + + if(offs + to_write > buflen) + chunk = buflen - offs; + else + chunk = to_write; + + tmp = alsa_write_best_effort(stream, buf + offs * stream->fmt->nBlockAlign, chunk); + if(tmp < 0) + return ret; + if(!tmp) + break; + + ret += tmp; + to_write -= tmp; + offs += tmp; + offs %= buflen; + } + + return ret; +} + +static UINT buf_ptr_diff(UINT left, UINT right, UINT bufsize) +{ + if(left <= right) + return right - left; + return bufsize - (left - right); +} + +static UINT data_not_in_alsa(struct alsa_stream *stream) +{ + UINT32 diff; + + diff = buf_ptr_diff(stream->lcl_offs_frames, stream->wri_offs_frames, stream->bufsize_frames); + if(diff) + return diff; + + return stream->held_frames - stream->data_in_alsa_frames; +} + +/* Here's the buffer setup: + * + * vvvvvvvv sent to HW already + * vvvvvvvv in ALSA buffer but rewindable + * [dddddddddddddddd] ALSA buffer + * [dddddddddddddddd--------] mmdevapi buffer + * ^^^^^^^^ data_in_alsa_frames + * ^^^^^^^^^^^^^^^^ held_frames + * ^ lcl_offs_frames + * ^ wri_offs_frames + * + * GetCurrentPadding is held_frames + * + * During period callback, we decrement held_frames, fill ALSA buffer, and move + * lcl_offs forward + * + * During Stop, we rewind the ALSA buffer + */ +static void alsa_write_data(struct alsa_stream *stream) +{ + snd_pcm_sframes_t written; + snd_pcm_uframes_t avail, max_copy_frames, data_frames_played; + int err; + + /* this call seems to be required to get an accurate snd_pcm_state() */ + avail = snd_pcm_avail_update(stream->pcm_handle); + + if(snd_pcm_state(stream->pcm_handle) == SND_PCM_STATE_XRUN){ + TRACE("XRun state, recovering\n"); + + avail = stream->alsa_bufsize_frames; + + if((err = snd_pcm_recover(stream->pcm_handle, -EPIPE, 1)) < 0) + WARN("snd_pcm_recover failed: %d (%s)\n", err, snd_strerror(err)); + + if((err = snd_pcm_reset(stream->pcm_handle)) < 0) + WARN("snd_pcm_reset failed: %d (%s)\n", err, snd_strerror(err)); + + if((err = snd_pcm_prepare(stream->pcm_handle)) < 0) + WARN("snd_pcm_prepare failed: %d (%s)\n", err, snd_strerror(err)); + } + + TRACE("avail: %ld\n", avail); + + /* Add a lead-in when starting with too few frames to ensure + * continuous rendering. Additional benefit: Force ALSA to start. */ + if(stream->data_in_alsa_frames == 0 && stream->held_frames < stream->alsa_period_frames) + { + alsa_write_best_effort(stream, stream->silence_buf, + stream->alsa_period_frames - stream->held_frames); + stream->vol_adjusted_frames = 0; + } + + if(stream->started) + max_copy_frames = data_not_in_alsa(stream); + else + max_copy_frames = 0; + + data_frames_played = min(stream->data_in_alsa_frames, avail); + stream->data_in_alsa_frames -= data_frames_played; + + if(stream->held_frames > data_frames_played){ + if(stream->started) + stream->held_frames -= data_frames_played; + }else + stream->held_frames = 0; + + while(avail && max_copy_frames){ + snd_pcm_uframes_t to_write; + + to_write = min(avail, max_copy_frames); + + written = alsa_write_buffer_wrap(stream, stream->local_buffer, + stream->bufsize_frames, stream->lcl_offs_frames, to_write); + if(written <= 0) + break; + + avail -= written; + stream->lcl_offs_frames += written; + stream->lcl_offs_frames %= stream->bufsize_frames; + stream->data_in_alsa_frames += written; + max_copy_frames -= written; + } + + if(stream->event) + NtSetEvent(stream->event, NULL); +} + +static void alsa_read_data(struct alsa_stream *stream) +{ + snd_pcm_sframes_t nread; + UINT32 pos = stream->wri_offs_frames, limit = stream->held_frames; + unsigned int i; + + if(!stream->started) + goto exit; + + /* FIXME: Detect overrun and signal DATA_DISCONTINUITY + * How to count overrun frames and report them as position increase? */ + limit = stream->bufsize_frames - max(limit, pos); + + nread = snd_pcm_readi(stream->pcm_handle, + stream->local_buffer + pos * stream->fmt->nBlockAlign, limit); + TRACE("read %ld from %u limit %u\n", nread, pos, limit); + if(nread < 0){ + int ret; + + if(nread == -EAGAIN) /* no data yet */ + return; + + WARN("read failed, recovering: %ld (%s)\n", nread, snd_strerror(nread)); + + ret = snd_pcm_recover(stream->pcm_handle, nread, 0); + if(ret < 0){ + WARN("Recover failed: %d (%s)\n", ret, snd_strerror(ret)); + return; + } + + nread = snd_pcm_readi(stream->pcm_handle, + stream->local_buffer + pos * stream->fmt->nBlockAlign, limit); + if(nread < 0){ + WARN("read failed: %ld (%s)\n", nread, snd_strerror(nread)); + return; + } + } + + for(i = 0; i < stream->fmt->nChannels; i++) + if(stream->vols[i] != 0.0f) + break; + if(i == stream->fmt->nChannels){ /* mute */ + int err; + if((err = snd_pcm_format_set_silence(stream->alsa_format, + stream->local_buffer + pos * stream->fmt->nBlockAlign, + nread)) < 0) + WARN("Setting buffer to silence failed: %d (%s)\n", err, + snd_strerror(err)); + } + + stream->wri_offs_frames += nread; + stream->wri_offs_frames %= stream->bufsize_frames; + stream->held_frames += nread; + +exit: + if(stream->event) + NtSetEvent(stream->event, NULL); +} + +static NTSTATUS timer_loop(void *args) +{ + struct timer_loop_params *params = args; + struct alsa_stream *stream = params->stream; + LARGE_INTEGER delay; + + alsa_lock(stream); + + delay.QuadPart = -stream->mmdev_period_rt; + + while(!stream->please_quit){ + NtQueryPerformanceCounter(&stream->last_period_time, NULL); + + if(stream->flow == eRender) + alsa_write_data(stream); + else if(stream->flow == eCapture) + alsa_read_data(stream); + + alsa_unlock(stream); + NtDelayExecution(FALSE, &delay); + alsa_lock(stream); + } + + alsa_unlock(stream); + + return STATUS_SUCCESS; +} + static NTSTATUS is_format_supported(void *args) { struct is_format_supported_params *params = args; @@ -1522,6 +1751,7 @@ unixlib_entry_t __wine_unix_call_funcs[] = get_endpoint_ids, create_stream, release_stream, + timer_loop, is_format_supported, get_mix_format, get_buffer_size, diff --git a/dlls/winealsa.drv/mmdevdrv.c b/dlls/winealsa.drv/mmdevdrv.c index c06b08709f2..2748cc552a6 100644 --- a/dlls/winealsa.drv/mmdevdrv.c +++ b/dlls/winealsa.drv/mmdevdrv.c @@ -109,7 +109,7 @@ struct ACImpl { UINT32 channel_count; struct alsa_stream *stream; - HANDLE timer; + HANDLE timer_thread; AudioSession *session; AudioSessionWrapper *session_wrapper; @@ -128,8 +128,6 @@ typedef struct _SessionMgr { IMMDevice *device; } SessionMgr; -static HANDLE g_timer_q; - static CRITICAL_SECTION g_sessions_lock; static CRITICAL_SECTION_DEBUG g_sessions_lock_debug = { @@ -216,9 +214,6 @@ BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved) if(NtQueryVirtualMemory(GetCurrentProcess(), dll, MemoryWineUnixFuncs, &alsa_handle, sizeof(alsa_handle), NULL)) return FALSE; - g_timer_q = CreateTimerQueue(); - if(!g_timer_q) - return FALSE; break; case DLL_PROCESS_DETACH: @@ -252,17 +247,30 @@ static void alsa_unlock(struct alsa_stream *stream) pthread_mutex_unlock(&stream->lock); } -static HRESULT alsa_stream_release(struct alsa_stream *stream) +static HRESULT alsa_stream_release(struct alsa_stream *stream, HANDLE timer_thread) { struct release_stream_params params; params.stream = stream; + params.timer_thread = timer_thread; ALSA_CALL(release_stream, &params); return params.result; } +static DWORD WINAPI alsa_timer_thread(void *user) +{ + struct alsa_stream *stream = user; + struct timer_loop_params params; + + params.stream = stream; + + ALSA_CALL(timer_loop, &params); + + return 0; +} + static void set_device_guid(EDataFlow flow, HKEY drv_key, const WCHAR *key_name, GUID *guid) { @@ -552,17 +560,6 @@ static ULONG WINAPI AudioClient_Release(IAudioClient3 *iface) ref = InterlockedDecrement(&This->ref); TRACE("(%p) Refcount now %u\n", This, ref); if(!ref){ - if(This->timer){ - HANDLE event; - DWORD wait; - event = CreateEventW(NULL, TRUE, FALSE, NULL); - wait = !DeleteTimerQueueTimer(g_timer_q, This->timer, event); - wait = wait && GetLastError() == ERROR_IO_PENDING; - if(event && wait) - WaitForSingleObject(event, INFINITE); - CloseHandle(event); - } - IAudioClient3_Stop(iface); IMMDevice_Release(This->parent); IUnknown_Release(This->pUnkFTMarshal); @@ -573,7 +570,7 @@ static ULONG WINAPI AudioClient_Release(IAudioClient3 *iface) } HeapFree(GetProcessHeap(), 0, This->vols); if (This->stream) - alsa_stream_release(This->stream); + alsa_stream_release(This->stream, This->timer_thread); HeapFree(GetProcessHeap(), 0, This); } return ref; @@ -807,7 +804,7 @@ static HRESULT WINAPI AudioClient_Initialize(IAudioClient3 *iface, exit: if(FAILED(params.result)){ - alsa_stream_release(stream); + alsa_stream_release(stream, NULL); HeapFree(GetProcessHeap(), 0, This->vols); This->vols = NULL; }else{ @@ -1011,187 +1008,6 @@ static snd_pcm_sframes_t alsa_write_buffer_wrap(struct alsa_stream *stream, BYTE return ret; } -static UINT buf_ptr_diff(UINT left, UINT right, UINT bufsize) -{ - if(left <= right) - return right - left; - return bufsize - (left - right); -} - -static UINT data_not_in_alsa(struct alsa_stream *stream) -{ - UINT32 diff; - - diff = buf_ptr_diff(stream->lcl_offs_frames, stream->wri_offs_frames, stream->bufsize_frames); - if(diff) - return diff; - - return stream->held_frames - stream->data_in_alsa_frames; -} -/* Here's the buffer setup: - * - * vvvvvvvv sent to HW already - * vvvvvvvv in ALSA buffer but rewindable - * [dddddddddddddddd] ALSA buffer - * [dddddddddddddddd--------] mmdevapi buffer - * ^^^^^^^^ data_in_alsa_frames - * ^^^^^^^^^^^^^^^^ held_frames - * ^ lcl_offs_frames - * ^ wri_offs_frames - * - * GetCurrentPadding is held_frames - * - * During period callback, we decrement held_frames, fill ALSA buffer, and move - * lcl_offs forward - * - * During Stop, we rewind the ALSA buffer - */ -static void alsa_write_data(struct alsa_stream *stream) -{ - snd_pcm_sframes_t written; - snd_pcm_uframes_t avail, max_copy_frames, data_frames_played; - int err; - - /* this call seems to be required to get an accurate snd_pcm_state() */ - avail = snd_pcm_avail_update(stream->pcm_handle); - - if(snd_pcm_state(stream->pcm_handle) == SND_PCM_STATE_XRUN){ - TRACE("XRun state, recovering\n"); - - avail = stream->alsa_bufsize_frames; - - if((err = snd_pcm_recover(stream->pcm_handle, -EPIPE, 1)) < 0) - WARN("snd_pcm_recover failed: %d (%s)\n", err, snd_strerror(err)); - - if((err = snd_pcm_reset(stream->pcm_handle)) < 0) - WARN("snd_pcm_reset failed: %d (%s)\n", err, snd_strerror(err)); - - if((err = snd_pcm_prepare(stream->pcm_handle)) < 0) - WARN("snd_pcm_prepare failed: %d (%s)\n", err, snd_strerror(err)); - } - - TRACE("avail: %ld\n", avail); - - /* Add a lead-in when starting with too few frames to ensure - * continuous rendering. Additional benefit: Force ALSA to start. */ - if(stream->data_in_alsa_frames == 0 && stream->held_frames < stream->alsa_period_frames) - { - alsa_write_best_effort(stream, stream->silence_buf, - stream->alsa_period_frames - stream->held_frames); - stream->vol_adjusted_frames = 0; - } - - if(stream->started) - max_copy_frames = data_not_in_alsa(stream); - else - max_copy_frames = 0; - - data_frames_played = min(stream->data_in_alsa_frames, avail); - stream->data_in_alsa_frames -= data_frames_played; - - if(stream->held_frames > data_frames_played){ - if(stream->started) - stream->held_frames -= data_frames_played; - }else - stream->held_frames = 0; - - while(avail && max_copy_frames){ - snd_pcm_uframes_t to_write; - - to_write = min(avail, max_copy_frames); - - written = alsa_write_buffer_wrap(stream, stream->local_buffer, - stream->bufsize_frames, stream->lcl_offs_frames, to_write); - if(written <= 0) - break; - - avail -= written; - stream->lcl_offs_frames += written; - stream->lcl_offs_frames %= stream->bufsize_frames; - stream->data_in_alsa_frames += written; - max_copy_frames -= written; - } - - if(stream->event) - SetEvent(stream->event); -} - -static void alsa_read_data(struct alsa_stream *stream) -{ - snd_pcm_sframes_t nread; - UINT32 pos = stream->wri_offs_frames, limit = stream->held_frames; - unsigned int i; - - if(!stream->started) - goto exit; - - /* FIXME: Detect overrun and signal DATA_DISCONTINUITY - * How to count overrun frames and report them as position increase? */ - limit = stream->bufsize_frames - max(limit, pos); - - nread = snd_pcm_readi(stream->pcm_handle, - stream->local_buffer + pos * stream->fmt->nBlockAlign, limit); - TRACE("read %ld from %u limit %u\n", nread, pos, limit); - if(nread < 0){ - int ret; - - if(nread == -EAGAIN) /* no data yet */ - return; - - WARN("read failed, recovering: %ld (%s)\n", nread, snd_strerror(nread)); - - ret = snd_pcm_recover(stream->pcm_handle, nread, 0); - if(ret < 0){ - WARN("Recover failed: %d (%s)\n", ret, snd_strerror(ret)); - return; - } - - nread = snd_pcm_readi(stream->pcm_handle, - stream->local_buffer + pos * stream->fmt->nBlockAlign, limit); - if(nread < 0){ - WARN("read failed: %ld (%s)\n", nread, snd_strerror(nread)); - return; - } - } - - for(i = 0; i < stream->fmt->nChannels; i++) - if(stream->vols[i] != 0.0f) - break; - if(i == stream->fmt->nChannels){ /* mute */ - int err; - if((err = snd_pcm_format_set_silence(stream->alsa_format, - stream->local_buffer + pos * stream->fmt->nBlockAlign, - nread)) < 0) - WARN("Setting buffer to silence failed: %d (%s)\n", err, - snd_strerror(err)); - } - - stream->wri_offs_frames += nread; - stream->wri_offs_frames %= stream->bufsize_frames; - stream->held_frames += nread; - -exit: - if(stream->event) - SetEvent(stream->event); -} - -static void CALLBACK alsa_push_buffer_data(void *user, BOOLEAN timer) -{ - ACImpl *This = user; - struct alsa_stream *stream = This->stream; - - alsa_lock(stream); - - QueryPerformanceCounter(&stream->last_period_time); - - if(stream->flow == eRender) - alsa_write_data(stream); - else if(stream->flow == eCapture) - alsa_read_data(stream); - - alsa_unlock(stream); -} - static snd_pcm_uframes_t interp_elapsed_frames(struct alsa_stream *stream) { LARGE_INTEGER time_freq, current_time, time_diff; @@ -1291,14 +1107,9 @@ static HRESULT WINAPI AudioClient_Start(IAudioClient3 *iface) } } - if(!This->timer){ - if(!CreateTimerQueueTimer(&This->timer, g_timer_q, alsa_push_buffer_data, - This, 0, stream->mmdev_period_rt / 10000, WT_EXECUTEINTIMERTHREAD)){ - alsa_unlock(stream); - LeaveCriticalSection(&g_sessions_lock); - WARN("Unable to create timer: %u\n", GetLastError()); - return E_OUTOFMEMORY; - } + if(!This->timer_thread){ + This->timer_thread = CreateThread(NULL, 0, alsa_timer_thread, This->stream, 0, NULL); + SetThreadPriority(This->timer_thread, THREAD_PRIORITY_TIME_CRITICAL); } stream->started = TRUE; diff --git a/dlls/winealsa.drv/unixlib.h b/dlls/winealsa.drv/unixlib.h index 3fd6d2a73ee..4acbbcbcf11 100644 --- a/dlls/winealsa.drv/unixlib.h +++ b/dlls/winealsa.drv/unixlib.h @@ -37,7 +37,7 @@ struct alsa_stream int alsa_channels; int alsa_channel_map[32]; - BOOL started; + BOOL started, please_quit; REFERENCE_TIME mmdev_period_rt; UINT64 written_frames, last_pos_frames; UINT32 bufsize_frames, held_frames, tmp_buffer_frames, mmdev_period_frames; @@ -87,9 +87,15 @@ struct create_stream_params struct release_stream_params { struct alsa_stream *stream; + HANDLE timer_thread; HRESULT result; }; +struct timer_loop_params +{ + struct alsa_stream *stream; +}; + struct is_format_supported_params { const char *alsa_name; @@ -142,6 +148,7 @@ enum alsa_funcs alsa_get_endpoint_ids, alsa_create_stream, alsa_release_stream, + alsa_timer_loop, alsa_is_format_supported, alsa_get_mix_format, alsa_get_buffer_size, -- 2.25.1

2 2

[PATCH v3 0/8] Fix sock_send reordering issue (#52401)
by Jinoh Kang March 2, 2022

March 2, 2022

This fixes the send part of the issue #52401 [1]: "Improper synchronization in sock_recv/sock_send leads to arbitrary reordering of completion of I/O requests", which was initially reported (outside Bugzilla) by Dongwan Kim [2]. Changelog: v1 -> v2: - drop patch "server: Compact struct set_async_direct_result_reply." - add async and fd arguments to async_initial_status_callback - recv_socket_initial_callback: pass OOB flag via private instead of implementing two separate functions for OOB and non-OOB - detect short write in send_socket_initial_callback - preserve the behaviour of returning success if we had a short write and the socket is nonblocking and force_async is unset v2 -> v3: - fix typo in comment [1] https://bugs.winehq.org/show_bug.cgi?id=52401 [2] https://www.winehq.org/pipermail/wine-devel/2021-May/186454.html Jinoh Kang (8): server: Actually set initial status in set_async_direct_result handler. server: Add async_initial_status_callback. server: Defer postprocessing until after setting initial status in recv_socket handler. server: Defer postprocessing until after setting initial status in send_socket handler. server: Add mark_pending field to set_async_direct_result request. server: Attempt to complete I/O request immediately in send_socket. ntdll: Don't call try_send before server call in sock_send. server: Replace redundant send_socket status fields with force_async boolean field. dlls/ntdll/unix/socket.c | 102 ++++++++++++++++++++++-------- dlls/ntdll/unix/sync.c | 9 +-- dlls/ntdll/unix/unix_private.h | 2 +- dlls/ws2_32/tests/sock.c | 14 ++--- server/async.c | 52 +++++++++++++--- server/file.h | 2 + server/protocol.def | 6 +- server/sock.c | 110 +++++++++++++++++++-------------- 8 files changed, 204 insertions(+), 93 deletions(-) Interdiff: diff --git a/server/sock.c b/server/sock.c index 2706c2d20ed..1112708369d 100644 --- a/server/sock.c +++ b/server/sock.c @@ -3513,7 +3513,7 @@ DECL_HANDLER(send_socket) else if (!async_queued( &sock->write_q )) { /* If write_q is not empty, we cannot really tell if the already queued - * asyncs will not consume all available data; if there's no data + * asyncs will not consume all available space; if there's no space * available, the current request won't be immediately satiable. */ struct pollfd pollfd; -- 2.34.1

3 15

[PATCH v2] win32u: Don't use get_dc_ptr() in __wine_get_wgl_driver().
by Paul Gofman March 1, 2022

March 1, 2022

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- v2: - use "user_driver->" instead of load_driver(); - store is_display DC parameter and base dibdrv choice on that; - move __wine_get_wgl_driver to dc.c. dlls/user32/driver.c | 4 +++- dlls/win32u/dc.c | 32 ++++++++++++++++++++++++++++++++ dlls/win32u/dibdrv/dc.c | 18 ++---------------- dlls/win32u/driver.c | 31 ++++++++----------------------- dlls/win32u/emfdrv.c | 1 - dlls/win32u/font.c | 1 - dlls/win32u/ntgdi_private.h | 2 ++ dlls/win32u/path.c | 1 - dlls/wineandroid.drv/init.c | 13 +++---------- dlls/winemac.drv/gdi.c | 2 +- dlls/winemac.drv/macdrv.h | 2 +- dlls/winemac.drv/opengl.c | 2 +- dlls/wineps.drv/init.c | 1 - dlls/winex11.drv/init.c | 13 +++---------- dlls/winex11.drv/xrender.c | 1 - include/wine/gdi_driver.h | 5 +++-- 16 files changed, 59 insertions(+), 70 deletions(-) diff --git a/dlls/user32/driver.c b/dlls/user32/driver.c index 5381e0c52d7..c8df3f31e2e 100644 --- a/dlls/user32/driver.c +++ b/dlls/user32/driver.c @@ -380,8 +380,10 @@ static struct user_driver_funcs lazy_load_driver = NULL, /* vulkan support */ NULL, + /* opengl support */ + NULL, /* thread management */ - NULL + NULL, }; void CDECL __wine_set_user_driver( const struct user_driver_funcs *funcs, UINT version ) diff --git a/dlls/win32u/dc.c b/dlls/win32u/dc.c index 4ee138b2906..ab5f6fe6d28 100644 --- a/dlls/win32u/dc.c +++ b/dlls/win32u/dc.c @@ -36,6 +36,8 @@ #include "winternl.h" #include "winerror.h" #include "ntgdi_private.h" +#include "wine/wgl.h" +#include "wine/wgl_driver.h" #include "wine/debug.h" @@ -763,6 +765,7 @@ HDC WINAPI NtGdiOpenDCW( UNICODE_STRING *device, const DEVMODEW *devmode, UNICOD dc->attr->vis_rect.top = 0; dc->attr->vis_rect.right = NtGdiGetDeviceCaps( hdc, DESKTOPHORZRES ); dc->attr->vis_rect.bottom = NtGdiGetDeviceCaps( hdc, DESKTOPVERTRES ); + dc->is_display = !!is_display; DC_InitDC( dc ); release_dc_ptr( dc ); @@ -1364,3 +1367,32 @@ BOOL CDECL __wine_get_icm_profile( HDC hdc, BOOL allow_default, DWORD *size, WCH release_dc_ptr(dc); return ret; } + +/*********************************************************************** + * __wine_get_wgl_driver (win32u.@) + */ +struct opengl_funcs * CDECL __wine_get_wgl_driver( HDC hdc, UINT version ) +{ + BOOL dibdrv; + DC * dc; + + if (!(dc = get_dc_obj( hdc ))) return NULL; + if (dc->attr->disabled) + { + GDI_ReleaseObj( hdc ); + return NULL; + } + dibdrv = !dc->is_display; + GDI_ReleaseObj( hdc ); + + if (dibdrv) + { + if (version != WINE_WGL_DRIVER_VERSION) + { + ERR( "version mismatch, opengl32 wants %u but dibdrv has %u\n", version, WINE_WGL_DRIVER_VERSION ); + return NULL; + } + return dibdrv_get_wgl_driver(); + } + return user_driver->pwine_get_wgl_driver( version ); +} diff --git a/dlls/win32u/dibdrv/dc.c b/dlls/win32u/dibdrv/dc.c index a96b613d0a3..f29651773c0 100644 --- a/dlls/win32u/dibdrv/dc.c +++ b/dlls/win32u/dibdrv/dc.c @@ -603,15 +603,10 @@ static struct opengl_funcs opengl_funcs = }; /********************************************************************** - * dibdrv_wine_get_wgl_driver + * dibdrv_get_wgl_driver */ -static struct opengl_funcs * CDECL dibdrv_wine_get_wgl_driver( PHYSDEV dev, UINT version ) +struct opengl_funcs *dibdrv_get_wgl_driver(void) { - if (version != WINE_WGL_DRIVER_VERSION) - { - ERR( "version mismatch, opengl32 wants %u but dibdrv has %u\n", version, WINE_WGL_DRIVER_VERSION ); - return NULL; - } if (!osmesa_funcs && !(osmesa_funcs = init_opengl_lib())) { static int warned; @@ -715,7 +710,6 @@ const struct gdi_dc_funcs dib_driver = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - dibdrv_wine_get_wgl_driver, /* wine_get_wgl_driver */ GDI_PRIORITY_DIB_DRV /* priority */ }; @@ -1177,13 +1171,6 @@ static INT CDECL windrv_StretchDIBits( PHYSDEV dev, INT x_dst, INT y_dst, INT wi return ret; } -static struct opengl_funcs * CDECL windrv_wine_get_wgl_driver( PHYSDEV dev, UINT version ) -{ - dev = GET_NEXT_PHYSDEV( dev, wine_get_wgl_driver ); - if (dev->funcs == &dib_driver) dev = GET_NEXT_PHYSDEV( dev, wine_get_wgl_driver ); - return dev->funcs->wine_get_wgl_driver( dev, version ); -} - static const struct gdi_dc_funcs window_driver = { NULL, /* pAbortDoc */ @@ -1277,6 +1264,5 @@ static const struct gdi_dc_funcs window_driver = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - windrv_wine_get_wgl_driver, /* wine_get_wgl_driver */ GDI_PRIORITY_DIB_DRV + 10 /* priority */ }; diff --git a/dlls/win32u/driver.c b/dlls/win32u/driver.c index dc858cdc0ce..9e530305cca 100644 --- a/dlls/win32u/driver.c +++ b/dlls/win32u/driver.c @@ -571,11 +571,6 @@ static NTSTATUS CDECL nulldrv_D3DKMTSetVidPnSourceOwner( const D3DKMT_SETVIDPNSO return STATUS_PROCEDURE_NOT_FOUND; } -static struct opengl_funcs * CDECL nulldrv_wine_get_wgl_driver( PHYSDEV dev, UINT version ) -{ - return (void *)-1; -} - const struct gdi_dc_funcs null_driver = { nulldrv_AbortDoc, /* pAbortDoc */ @@ -669,7 +664,6 @@ const struct gdi_dc_funcs null_driver = nulldrv_UnrealizePalette, /* pUnrealizePalette */ nulldrv_D3DKMTCheckVidPnExclusiveOwnership, /* pD3DKMTCheckVidPnExclusiveOwnership */ nulldrv_D3DKMTSetVidPnSourceOwner, /* pD3DKMTSetVidPnSourceOwner */ - nulldrv_wine_get_wgl_driver, /* wine_get_wgl_driver */ GDI_PRIORITY_NULL_DRV /* priority */ }; @@ -928,6 +922,11 @@ static const struct vulkan_funcs * CDECL nulldrv_wine_get_vulkan_driver( UINT ve return NULL; } +static struct opengl_funcs * CDECL nulldrv_wine_get_wgl_driver( UINT version ) +{ + return (void *)-1; +} + static void CDECL nulldrv_ThreadDetach( void ) { } @@ -1063,6 +1062,8 @@ static const struct user_driver_funcs lazy_load_driver = .pSystemParametersInfo = nulldrv_SystemParametersInfo, /* vulkan support */ .pwine_get_vulkan_driver = loaderdrv_wine_get_vulkan_driver, + /* opengl support */ + .pwine_get_wgl_driver = nulldrv_wine_get_wgl_driver, /* thread management */ .pThreadDetach = nulldrv_ThreadDetach, }; @@ -1126,6 +1127,7 @@ void CDECL __wine_set_display_driver( struct user_driver_funcs *driver, UINT ver SET_USER_FUNC(WindowPosChanged); SET_USER_FUNC(SystemParametersInfo); SET_USER_FUNC(wine_get_vulkan_driver); + SET_USER_FUNC(wine_get_wgl_driver); SET_USER_FUNC(ThreadDetach); #undef SET_USER_FUNC @@ -1368,20 +1370,3 @@ NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNE return get_display_driver()->pD3DKMTCheckVidPnExclusiveOwnership( desc ); } - -/*********************************************************************** - * __wine_get_wgl_driver (win32u.@) - */ -struct opengl_funcs * CDECL __wine_get_wgl_driver( HDC hdc, UINT version ) -{ - struct opengl_funcs *ret = NULL; - DC * dc = get_dc_ptr( hdc ); - - if (dc) - { - PHYSDEV physdev = GET_DC_PHYSDEV( dc, wine_get_wgl_driver ); - ret = physdev->funcs->wine_get_wgl_driver( physdev, version ); - release_dc_ptr( dc ); - } - return ret; -} diff --git a/dlls/win32u/emfdrv.c b/dlls/win32u/emfdrv.c index f261a86e392..81481953288 100644 --- a/dlls/win32u/emfdrv.c +++ b/dlls/win32u/emfdrv.c @@ -524,7 +524,6 @@ static const struct gdi_dc_funcs emfdrv_driver = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - NULL, /* wine_get_wgl_driver */ GDI_PRIORITY_GRAPHICS_DRV /* priority */ }; diff --git a/dlls/win32u/font.c b/dlls/win32u/font.c index b8213ac9e6a..87ef75f04af 100644 --- a/dlls/win32u/font.c +++ b/dlls/win32u/font.c @@ -4351,7 +4351,6 @@ const struct gdi_dc_funcs font_driver = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - NULL, /* wine_get_wgl_driver */ GDI_PRIORITY_FONT_DRV /* priority */ }; diff --git a/dlls/win32u/ntgdi_private.h b/dlls/win32u/ntgdi_private.h index 2ed6182e151..e906b029bce 100644 --- a/dlls/win32u/ntgdi_private.h +++ b/dlls/win32u/ntgdi_private.h @@ -59,6 +59,7 @@ typedef struct tagDC DCHOOKPROC hookProc; /* DC hook */ BOOL bounds_enabled:1; /* bounds tracking is enabled */ BOOL path_open:1; /* path is currently open (only for saved DCs) */ + BOOL is_display:1; /* DC is for display device */ RECT device_rect; /* rectangle for the whole device */ int pixel_format; /* pixel format (for memory DCs) */ @@ -207,6 +208,7 @@ extern UINT get_dib_dc_color_table( HDC hdc, UINT startpos, UINT entries, extern UINT set_dib_dc_color_table( HDC hdc, UINT startpos, UINT entries, const RGBQUAD *colors ) DECLSPEC_HIDDEN; extern void dibdrv_set_window_surface( DC *dc, struct window_surface *surface ) DECLSPEC_HIDDEN; +extern struct opengl_funcs *dibdrv_get_wgl_driver(void) DECLSPEC_HIDDEN; /* driver.c */ extern const struct gdi_dc_funcs null_driver DECLSPEC_HIDDEN; diff --git a/dlls/win32u/path.c b/dlls/win32u/path.c index a87a7ab06c2..93a124953af 100644 --- a/dlls/win32u/path.c +++ b/dlls/win32u/path.c @@ -2121,6 +2121,5 @@ const struct gdi_dc_funcs path_driver = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - NULL, /* wine_get_wgl_driver */ GDI_PRIORITY_PATH_DRV /* priority */ }; diff --git a/dlls/wineandroid.drv/init.c b/dlls/wineandroid.drv/init.c index ed9116eb47e..7c103475e6b 100644 --- a/dlls/wineandroid.drv/init.c +++ b/dlls/wineandroid.drv/init.c @@ -261,16 +261,9 @@ BOOL CDECL ANDROID_EnumDisplaySettingsEx( LPCWSTR name, DWORD n, LPDEVMODEW devm /********************************************************************** * ANDROID_wine_get_wgl_driver */ -static struct opengl_funcs * CDECL ANDROID_wine_get_wgl_driver( PHYSDEV dev, UINT version ) +static struct opengl_funcs * CDECL ANDROID_wine_get_wgl_driver( UINT version ) { - struct opengl_funcs *ret; - - if (!(ret = get_wgl_driver( version ))) - { - dev = GET_NEXT_PHYSDEV( dev, wine_get_wgl_driver ); - ret = dev->funcs->wine_get_wgl_driver( dev, version ); - } - return ret; + return get_wgl_driver( version ); } @@ -279,7 +272,6 @@ static const struct user_driver_funcs android_drv_funcs = .dc_funcs.pCreateCompatibleDC = ANDROID_CreateCompatibleDC, .dc_funcs.pCreateDC = ANDROID_CreateDC, .dc_funcs.pDeleteDC = ANDROID_DeleteDC, - .dc_funcs.wine_get_wgl_driver = ANDROID_wine_get_wgl_driver, .dc_funcs.priority = GDI_PRIORITY_GRAPHICS_DRV, .pGetKeyNameText = ANDROID_GetKeyNameText, @@ -302,6 +294,7 @@ static const struct user_driver_funcs android_drv_funcs = .pWindowMessage = ANDROID_WindowMessage, .pWindowPosChanging = ANDROID_WindowPosChanging, .pWindowPosChanged = ANDROID_WindowPosChanged, + .pwine_get_wgl_driver = ANDROID_wine_get_wgl_driver, }; diff --git a/dlls/winemac.drv/gdi.c b/dlls/winemac.drv/gdi.c index 40ba4c570c5..264781c6ac1 100644 --- a/dlls/winemac.drv/gdi.c +++ b/dlls/winemac.drv/gdi.c @@ -268,7 +268,6 @@ static const struct user_driver_funcs macdrv_funcs = .dc_funcs.pGetDeviceCaps = macdrv_GetDeviceCaps, .dc_funcs.pGetDeviceGammaRamp = macdrv_GetDeviceGammaRamp, .dc_funcs.pSetDeviceGammaRamp = macdrv_SetDeviceGammaRamp, - .dc_funcs.wine_get_wgl_driver = macdrv_wine_get_wgl_driver, .dc_funcs.priority = GDI_PRIORITY_GRAPHICS_DRV, .pActivateKeyboardLayout = macdrv_ActivateKeyboardLayout, @@ -309,6 +308,7 @@ static const struct user_driver_funcs macdrv_funcs = .pWindowPosChanged = macdrv_WindowPosChanged, .pWindowPosChanging = macdrv_WindowPosChanging, .pwine_get_vulkan_driver = macdrv_wine_get_vulkan_driver, + .pwine_get_wgl_driver = macdrv_wine_get_wgl_driver, }; diff --git a/dlls/winemac.drv/macdrv.h b/dlls/winemac.drv/macdrv.h index 0bd0a18f111..4e4524722af 100644 --- a/dlls/winemac.drv/macdrv.h +++ b/dlls/winemac.drv/macdrv.h @@ -263,7 +263,7 @@ extern DWORD CDECL macdrv_MsgWaitForMultipleObjectsEx(DWORD count, const HANDLE extern BOOL query_drag_exited(macdrv_query* query) DECLSPEC_HIDDEN; extern BOOL query_drag_drop(macdrv_query* query) DECLSPEC_HIDDEN; -extern struct opengl_funcs * CDECL macdrv_wine_get_wgl_driver(PHYSDEV dev, UINT version) DECLSPEC_HIDDEN; +extern struct opengl_funcs * CDECL macdrv_wine_get_wgl_driver(UINT version) DECLSPEC_HIDDEN; extern const struct vulkan_funcs * CDECL macdrv_wine_get_vulkan_driver(UINT version) DECLSPEC_HIDDEN; extern void sync_gl_view(struct macdrv_win_data* data, const RECT* old_whole_rect, const RECT* old_client_rect) DECLSPEC_HIDDEN; diff --git a/dlls/winemac.drv/opengl.c b/dlls/winemac.drv/opengl.c index daf194c2aec..02ac613ddc9 100644 --- a/dlls/winemac.drv/opengl.c +++ b/dlls/winemac.drv/opengl.c @@ -4632,7 +4632,7 @@ static struct opengl_funcs opengl_funcs = /********************************************************************** * macdrv_wine_get_wgl_driver */ -struct opengl_funcs * CDECL macdrv_wine_get_wgl_driver(PHYSDEV dev, UINT version) +struct opengl_funcs * CDECL macdrv_wine_get_wgl_driver(UINT version) { static INIT_ONCE opengl_init = INIT_ONCE_STATIC_INIT; diff --git a/dlls/wineps.drv/init.c b/dlls/wineps.drv/init.c index 27260e95507..04b00e82709 100644 --- a/dlls/wineps.drv/init.c +++ b/dlls/wineps.drv/init.c @@ -858,7 +858,6 @@ static const struct gdi_dc_funcs psdrv_funcs = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - NULL, /* wine_get_wgl_driver */ GDI_PRIORITY_GRAPHICS_DRV /* priority */ }; diff --git a/dlls/winex11.drv/init.c b/dlls/winex11.drv/init.c index 5b31c352a23..fe2c50bffa7 100644 --- a/dlls/winex11.drv/init.c +++ b/dlls/winex11.drv/init.c @@ -312,16 +312,9 @@ static INT CDECL X11DRV_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOI /********************************************************************** * X11DRV_wine_get_wgl_driver */ -static struct opengl_funcs * CDECL X11DRV_wine_get_wgl_driver( PHYSDEV dev, UINT version ) +static struct opengl_funcs * CDECL X11DRV_wine_get_wgl_driver( UINT version ) { - struct opengl_funcs *ret; - - if (!(ret = get_glx_driver( version ))) - { - dev = GET_NEXT_PHYSDEV( dev, wine_get_wgl_driver ); - ret = dev->funcs->wine_get_wgl_driver( dev, version ); - } - return ret; + return get_glx_driver( version ); } /********************************************************************** @@ -377,7 +370,6 @@ static const struct user_driver_funcs x11drv_funcs = .dc_funcs.pUnrealizePalette = X11DRV_UnrealizePalette, .dc_funcs.pD3DKMTCheckVidPnExclusiveOwnership = X11DRV_D3DKMTCheckVidPnExclusiveOwnership, .dc_funcs.pD3DKMTSetVidPnSourceOwner = X11DRV_D3DKMTSetVidPnSourceOwner, - .dc_funcs.wine_get_wgl_driver = X11DRV_wine_get_wgl_driver, .dc_funcs.priority = GDI_PRIORITY_GRAPHICS_DRV, .pActivateKeyboardLayout = X11DRV_ActivateKeyboardLayout, @@ -419,6 +411,7 @@ static const struct user_driver_funcs x11drv_funcs = .pWindowPosChanged = X11DRV_WindowPosChanged, .pSystemParametersInfo = X11DRV_SystemParametersInfo, .pwine_get_vulkan_driver = X11DRV_wine_get_vulkan_driver, + .pwine_get_wgl_driver = X11DRV_wine_get_wgl_driver, .pThreadDetach = X11DRV_ThreadDetach, }; diff --git a/dlls/winex11.drv/xrender.c b/dlls/winex11.drv/xrender.c index 92dc35fa9e1..5ede97fb026 100644 --- a/dlls/winex11.drv/xrender.c +++ b/dlls/winex11.drv/xrender.c @@ -2246,7 +2246,6 @@ static const struct gdi_dc_funcs xrender_funcs = NULL, /* pUnrealizePalette */ NULL, /* pD3DKMTCheckVidPnExclusiveOwnership */ NULL, /* pD3DKMTSetVidPnSourceOwner */ - NULL, /* wine_get_wgl_driver */ GDI_PRIORITY_GRAPHICS_DRV + 10 /* priority */ }; diff --git a/include/wine/gdi_driver.h b/include/wine/gdi_driver.h index 567a6c21608..e6f8239e27d 100644 --- a/include/wine/gdi_driver.h +++ b/include/wine/gdi_driver.h @@ -159,14 +159,13 @@ struct gdi_dc_funcs BOOL (CDECL *pUnrealizePalette)(HPALETTE); NTSTATUS (CDECL *pD3DKMTCheckVidPnExclusiveOwnership)(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *); NTSTATUS (CDECL *pD3DKMTSetVidPnSourceOwner)(const D3DKMT_SETVIDPNSOURCEOWNER *); - struct opengl_funcs * (CDECL *wine_get_wgl_driver)(PHYSDEV,UINT); /* priority order for the driver on the stack */ UINT priority; }; /* increment this when you change the DC function table */ -#define WINE_GDI_DRIVER_VERSION 74 +#define WINE_GDI_DRIVER_VERSION 75 #define GDI_PRIORITY_NULL_DRV 0 /* null driver */ #define GDI_PRIORITY_FONT_DRV 100 /* any font driver */ @@ -321,6 +320,8 @@ struct user_driver_funcs BOOL (CDECL *pSystemParametersInfo)(UINT,UINT,void*,UINT); /* vulkan support */ const struct vulkan_funcs * (CDECL *pwine_get_vulkan_driver)(UINT); + /* opengl support */ + struct opengl_funcs * (CDECL *pwine_get_wgl_driver)(UINT); /* thread management */ void (CDECL *pThreadDetach)(void); }; -- 2.35.1

3 3

[PATCH 01/27] include/commctrl.h: fix definition of CLR_* macros
by Eric Pouech March 1, 2022

March 1, 2022

Signed-off-by: Eric Pouech <eric.pouech(a)gmail.com> --- include/commctrl.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/include/commctrl.h b/include/commctrl.h index 944a9158371..b829e4498ea 100644 --- a/include/commctrl.h +++ b/include/commctrl.h @@ -476,8 +476,8 @@ typedef struct struct _IMAGELIST; typedef struct _IMAGELIST *HIMAGELIST; -#define CLR_NONE 0xFFFFFFFF -#define CLR_DEFAULT 0xFF000000 +#define CLR_NONE __MSABI_LONG(0xFFFFFFFF) +#define CLR_DEFAULT __MSABI_LONG(0xFF000000) #define CLR_HILIGHT CLR_DEFAULT #define ILC_MASK 0x00000001

5 38