November 2021 - 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/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] tools: Add gdbinit helper with LoadSymbolFiles command.
by Rémi Bernon Jan. 24, 2022

Jan. 24, 2022

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

3 7

[PATCH v2] ntdll: resolve drive symlink for mapped filename
by Matias Zuniga Dec. 27, 2021

Dec. 27, 2021

Applications expect a path starting with a drive like '\Device\Harddisk1\' instead of a drive letter. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51687 Signed-off-by: Matias Zuniga <matias.nicolas.zc(a)gmail.com> --- v2: Fix info.c test breakage --- dlls/ntdll/unix/virtual.c | 97 ++++++++++++++++++++++++++++++++--- dlls/psapi/tests/psapi_main.c | 5 +- 2 files changed, 90 insertions(+), 12 deletions(-) diff --git a/dlls/ntdll/unix/virtual.c b/dlls/ntdll/unix/virtual.c index 984af2d4a21..48bfaf3cf99 100644 --- a/dlls/ntdll/unix/virtual.c +++ b/dlls/ntdll/unix/virtual.c @@ -133,6 +133,8 @@ struct file_view } \ } while (0); +#define SYMBOLIC_LINK_QUERY 0x0001 + /* per-page protection flags */ #define VPROT_READ 0x01 #define VPROT_WRITE 0x02 @@ -4273,34 +4275,113 @@ static NTSTATUS get_working_set_ex( HANDLE process, LPCVOID addr, return STATUS_SUCCESS; } +static NTSTATUS read_nt_symlink( UNICODE_STRING *name, WCHAR *target, DWORD size ) +{ + NTSTATUS status; + OBJECT_ATTRIBUTES attr; + HANDLE handle; + + attr.Length = sizeof(attr); + attr.RootDirectory = 0; + attr.Attributes = OBJ_CASE_INSENSITIVE; + attr.ObjectName = name; + attr.SecurityDescriptor = NULL; + attr.SecurityQualityOfService = NULL; + + if (!(status = NtOpenSymbolicLinkObject( &handle, SYMBOLIC_LINK_QUERY, &attr ))) + { + UNICODE_STRING targetW; + targetW.Buffer = target; + targetW.MaximumLength = (size - 1) * sizeof(WCHAR); + status = NtQuerySymbolicLinkObject( handle, &targetW, NULL ); + if (!status) target[targetW.Length / sizeof(WCHAR)] = 0; + NtClose( handle ); + } + return status; +} + +static NTSTATUS follow_device_symlink( WCHAR *name, SIZE_T max_path_len, WCHAR *buffer, + SIZE_T buffer_len, SIZE_T *current_path_len ) +{ + WCHAR *p; + NTSTATUS status = STATUS_SUCCESS; + SIZE_T devname_len = 6 * sizeof(WCHAR); // e.g. \??\C: + UNICODE_STRING devname; + SIZE_T target_len; + + if (*current_path_len > buffer_len) return STATUS_INVALID_PARAMETER; + + if (*current_path_len >= devname_len && buffer[devname_len / sizeof(WCHAR) - 1] == ':') { + devname.Buffer = buffer; + devname.Length = devname_len; + + p = buffer + (*current_path_len / sizeof(WCHAR)); + if (!(status = read_nt_symlink( &devname, p, (buffer_len - *current_path_len) / sizeof(WCHAR) ))) + { + *current_path_len -= devname_len; // skip the device name + target_len = lstrlenW(p) * sizeof(WCHAR); + *current_path_len += target_len; + + if (*current_path_len <= max_path_len) + { + memcpy( name, p, target_len ); + p = buffer + devname_len / sizeof(WCHAR); + memcpy( name + target_len / sizeof(WCHAR), p, *current_path_len - target_len); + } + else status = STATUS_BUFFER_OVERFLOW; + } + } + else if (*current_path_len <= max_path_len) { + memcpy( name, buffer, *current_path_len ); + } + else status = STATUS_BUFFER_OVERFLOW; + + return status; +} + static NTSTATUS get_memory_section_name( HANDLE process, LPCVOID addr, MEMORY_SECTION_NAME *info, SIZE_T len, SIZE_T *ret_len ) { + SIZE_T current_path_len, max_path_len = 0; + // buffer to hold the path + 6 chars devname (e.g. \??\C:) + SIZE_T buffer_len = (MAX_PATH + 6) * sizeof(WCHAR); + WCHAR *buffer = NULL; NTSTATUS status; if (!info) return STATUS_ACCESS_VIOLATION; + if (!(buffer = malloc( buffer_len ))) return STATUS_NO_MEMORY; + if (len > sizeof(*info) + sizeof(WCHAR)) + { + max_path_len = len - sizeof(*info) - sizeof(WCHAR); // dont count null char + } SERVER_START_REQ( get_mapping_filename ) { req->process = wine_server_obj_handle( process ); req->addr = wine_server_client_ptr( addr ); - if (len > sizeof(*info) + sizeof(WCHAR)) - wine_server_set_reply( req, info + 1, len - sizeof(*info) - sizeof(WCHAR) ); + wine_server_set_reply( req, buffer, MAX_PATH ); status = wine_server_call( req ); - if (!status || status == STATUS_BUFFER_OVERFLOW) + if (!status) { - if (ret_len) *ret_len = sizeof(*info) + reply->len + sizeof(WCHAR); - if (len < sizeof(*info)) status = STATUS_INFO_LENGTH_MISMATCH; + current_path_len = reply->len; + status = follow_device_symlink( (WCHAR *)(info + 1), max_path_len, buffer, buffer_len, &current_path_len); + if (len < sizeof(*info)) + { + status = STATUS_INFO_LENGTH_MISMATCH; + } + + if (ret_len) *ret_len = sizeof(*info) + current_path_len + sizeof(WCHAR); if (!status) { info->SectionFileName.Buffer = (WCHAR *)(info + 1); - info->SectionFileName.Length = reply->len; - info->SectionFileName.MaximumLength = reply->len + sizeof(WCHAR); - info->SectionFileName.Buffer[reply->len / sizeof(WCHAR)] = 0; + info->SectionFileName.Length = current_path_len; + info->SectionFileName.MaximumLength = current_path_len + sizeof(WCHAR); + info->SectionFileName.Buffer[current_path_len / sizeof(WCHAR)] = 0; } } } SERVER_END_REQ; + free(buffer); return status; } diff --git a/dlls/psapi/tests/psapi_main.c b/dlls/psapi/tests/psapi_main.c index c4a740310a4..d6fb8e69384 100644 --- a/dlls/psapi/tests/psapi_main.c +++ b/dlls/psapi/tests/psapi_main.c @@ -471,7 +471,6 @@ static void test_GetMappedFileName(void) ret = GetMappedFileNameA(GetCurrentProcess(), base, map_name, sizeof(map_name)); ok(ret, "GetMappedFileName error %d\n", GetLastError()); ok(ret > strlen(device_name), "map_name should be longer than device_name\n"); - todo_wine ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name); SetLastError(0xdeadbeef); @@ -482,7 +481,6 @@ static void test_GetMappedFileName(void) { ok(memcmp(map_nameW, nt_map_name, lstrlenW(map_nameW)) == 0, "map name does not start with a device name: %s\n", map_name); WideCharToMultiByte(CP_ACP, 0, map_nameW, -1, map_name, MAX_PATH, NULL, NULL); - todo_wine ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name); } @@ -490,7 +488,6 @@ static void test_GetMappedFileName(void) ret = GetMappedFileNameA(GetCurrentProcess(), base + 0x2000, map_name, sizeof(map_name)); ok(ret, "GetMappedFileName error %d\n", GetLastError()); ok(ret > strlen(device_name), "map_name should be longer than device_name\n"); - todo_wine ok(memcmp(map_name, device_name, strlen(device_name)) == 0, "map name does not start with a device name: %s\n", map_name); SetLastError(0xdeadbeef); @@ -566,7 +563,7 @@ static void test_GetProcessImageFileName(void) { /* Windows returns 2*strlen-1 */ ok(ret >= strlen(szImgPath), "szImgPath=\"%s\" ret=%d\n", szImgPath, ret); - todo_wine ok(!strcmp(szImgPath, szMapPath), "szImgPath=\"%s\" szMapPath=\"%s\"\n", szImgPath, szMapPath); + ok(!strcmp(szImgPath, szMapPath), "szImgPath=\"%s\" szMapPath=\"%s\"\n", szImgPath, szMapPath); } SetLastError(0xdeadbeef); -- 2.31.1

3 2

[PATCH] msvcrt: support I width modifier in *scanf* family
by Eric Pouech Dec. 20, 2021

Dec. 20, 2021

Despite what msdn states, I and I32 are supported width modifiers. V2: - better code structure - added support and tests for I32 Signed-off-by: Eric Pouech <eric.pouech(a)gmail.com> --- dlls/msvcrt/scanf.h | 10 ++++++++-- dlls/msvcrt/tests/scanf.c | 46 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 2 deletions(-) diff --git a/dlls/msvcrt/scanf.h b/dlls/msvcrt/scanf.h index 3ab2efef13d..02284379854 100644 --- a/dlls/msvcrt/scanf.h +++ b/dlls/msvcrt/scanf.h @@ -279,13 +279,19 @@ _FUNCTION_ { *(format + 2) == '4') { I64_prefix = 1; format += 2; + break; } - break; + else if (*(format + 1) == '3' && + *(format + 2) == '2') { + format += 2; + break; + } + /* fall through */ #if _MSVCR_VER == 0 || _MSVCR_VER >= 140 case 'z': +#endif if (sizeof(void *) == sizeof(LONGLONG)) I64_prefix = 1; break; -#endif default: prefix_finished = 1; } diff --git a/dlls/msvcrt/tests/scanf.c b/dlls/msvcrt/tests/scanf.c index e175342796b..6541f5fd5cb 100644 --- a/dlls/msvcrt/tests/scanf.c +++ b/dlls/msvcrt/tests/scanf.c @@ -74,6 +74,7 @@ static void test_sscanf( void ) int hour=21,min=59,sec=20; int number,number_so_far; HMODULE hmod = GetModuleHandleA("msvcrt.dll"); + DWORD_PTR result_ptr; p_sprintf = (void *)GetProcAddress( hmod, "sprintf" ); p_sscanf = (void *)GetProcAddress( hmod, "sscanf" ); @@ -264,6 +265,51 @@ static void test_sscanf( void ) if(ret == 14) ok(!strcmp(buffer, buffer1), "got %s, expected %s\n", buffer1, buffer); + strcpy(buffer,"12345678901234"); + ret = p_sscanf(buffer, "%I64d", &result64); + ok(ret == 1, "Wrong number of arguments read: %d\n", ret); + ret = p_sprintf(buffer1, "%I64d", result64); + ok(ret==14 || broken(ret==10), "sprintf returned %d\n", ret); + if(ret == 14) + ok(!strcmp(buffer, buffer1), "got %s, expected %s\n", buffer1, buffer); + + result = 0; + strcpy(buffer,"0x123456789"); + ret = p_sscanf(buffer, "%I32x", &result); + ok(ret == 1, "Wrong number of arguments read: %d\n", ret); + ok(result == 0x23456789, "got %x, expected 0x23456789\n", result); + + result_ptr = 0; + strcpy(buffer,"0x87654321"); + ret = p_sscanf(buffer, "%Ix", &result_ptr); + ok(ret == 1, "Wrong number of arguments read: %d\n", ret); + if (sizeof(void*) == sizeof(LONGLONG)) + { + ret = p_sprintf(buffer1, "%#Ix", result_ptr); + ok(ret==9, "sprintf returned %d\n", ret); + if(ret == 9) + ok(!strcmp(buffer, buffer1), "got %s, expected %s\n", buffer1, buffer); + } + else + { + ok(result_ptr == 0x87654321, "got %x, expected 0x23456789\n", result); + } + result_ptr = 0; + strcpy(buffer,"0x123456789"); + ret = p_sscanf(buffer, "%Ix", &result_ptr); + ok(ret == 1, "Wrong number of arguments read: %d\n", ret); + if (sizeof(void*) == sizeof(LONGLONG)) + { + ret = p_sprintf(buffer1, "%#Ix", result_ptr); + ok(ret==11, "sprintf returned %d\n", ret); + if(ret == 11) + ok(!strcmp(buffer, buffer1), "got %s, expected %s\n", buffer1, buffer); + } + else + { + ok(result_ptr == 0x23456789, "got %x, expected 0x23456789\n", result); + } + /* Check %i according to bug 1878 */ strcpy(buffer,"123"); ret = p_sscanf(buffer, "%i", &result);

4 6

[PATCH 0/6] A couple of workarounds for warnings emitted by GCC11
by Eric Pouech Dec. 20, 2021

Dec. 20, 2021

GCC11 implements new warnings. This serie of patches: - works around a couple of false positive - fixes a couple of bad handling of corner cases in error handling - last patch should be reviewed by D3D folks. The fix is consistent with function definition, and no regression appear in make test... A+ --- Eric Pouech (6): dlls/msvcrt*: ensure variable sse2_cw is set for all code paths in _control87 (GCC11) In tests, ensure buffers passed as const pointers are always initialized (GCC11) kernelbase: always return NULL in case of error in GetModuleHandleA (GCC11) kernel32/tests: mark pointer as volatile when reading after allocated size Workaround GCC11 complaining about sizeof(a)/sizeof(b) constructs when it's d3dx9_36/tests: fixed order of parameters dlls/d3dx9_36/mesh.c | 2 +- dlls/d3dx9_36/tests/effect.c | 4 ++-- dlls/d3dx9_36/tests/mesh.c | 4 ++-- dlls/kernel32/tests/heap.c | 3 ++- dlls/kernelbase/loader.c | 2 +- dlls/kernelbase/tests/path.c | 1 + dlls/msvcirt/tests/msvcirt.c | 5 +++-- dlls/msvcrt/math.c | 2 +- dlls/shlwapi/tests/clist.c | 1 + 9 files changed, 14 insertions(+), 10 deletions(-)

8 23

[PATCH 1/2] comctl32/tests: Fix a test failure on Win10 21H1 with Hebrew locale.
by Zhiyi Zhang Dec. 10, 2021

Dec. 10, 2021

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/tests/propsheet.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/comctl32/tests/propsheet.c b/dlls/comctl32/tests/propsheet.c index 9acdea85c66..04a540b07e6 100644 --- a/dlls/comctl32/tests/propsheet.c +++ b/dlls/comctl32/tests/propsheet.c @@ -78,8 +78,8 @@ static int CALLBACK sheet_callback(HWND hwnd, UINT msg, LPARAM lparam) size = SizeofResource(module, hrsrc); ok(size != 0, "Failed to get size of propsheet dialog resource\n"); buffer_size = HeapSize(GetProcessHeap(), 0, (void *)lparam); - ok(buffer_size == 2 * size, "Unexpected template buffer size %u, resource size %u\n", - buffer_size, size); + ok(buffer_size == 2 * size || buffer_size == 2 * size + 8 /* Win10 21H1 Hebrew (Israel) */, + "Unexpected template buffer size %u, resource size %u\n", buffer_size, size); break; } case PSCB_INITIALIZED: -- 2.32.0

3 4

[PATCH v4] ws2_32: Fix setsockopt(TCP_NODELAY) when optlen is less than 4.
by Bastien Orivel Dec. 9, 2021

Dec. 9, 2021

According to MSDN [1], the `TCP_NODELAY` parameter should be of type `BOOL` which is 4 bytes. Due to a bug [2] in rustc passing a byte instead of an int, any program written in rust that tries to set that option on a socket will fail with a "Invalid parameter supplied" error. Turns out that setsockopt on linux does not want optlen to be less than 4 bytes [3]. Windows' behavior is the following: - For optlen <= 0, return SOCKET_ERROR and set last error to WSAEFAULT - For optlen > 0, ignore the optlen value and set the TCP_NODELAY value to one if the first byte of the given optvalue is not 0. This will fix any rust program using the hyper library to do HTTP requests. [1]: https://docs.microsoft.com/en-us/windows/win32/winsock/ipproto-tcp-socket-o… [2]: https://github.com/rust-lang/rust/blob/44593aeb1387b1be355aeaf0040d5927bd80… [3]: https://github.com/torvalds/linux/blob/d58071a8a76d779eedab38033ae4c821c302… Signed-off-by: Bastien Orivel <eijebong(a)bananium.fr> --- dlls/ws2_32/socket.c | 10 ++++++-- dlls/ws2_32/tests/sock.c | 53 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 2 deletions(-) diff --git a/dlls/ws2_32/socket.c b/dlls/ws2_32/socket.c index 2db441bee3c..5ac88c47b2e 100644 --- a/dlls/ws2_32/socket.c +++ b/dlls/ws2_32/socket.c @@ -2868,8 +2868,14 @@ int WINAPI setsockopt( SOCKET s, int level, int optname, const char *optval, int switch(optname) { case TCP_NODELAY: - return server_setsockopt( s, IOCTL_AFD_WINE_SET_TCP_NODELAY, optval, optlen ); - + { + INT nodelay = *optval; + if (optlen <= 0) { + SetLastError(WSAEFAULT); + return SOCKET_ERROR; + } + return server_setsockopt( s, IOCTL_AFD_WINE_SET_TCP_NODELAY, (char*)&nodelay, sizeof(nodelay) ); + } default: FIXME("Unknown IPPROTO_TCP optname 0x%08x\n", optname); SetLastError(WSAENOPROTOOPT); diff --git a/dlls/ws2_32/tests/sock.c b/dlls/ws2_32/tests/sock.c index 02713a7c625..464a6e5c8ea 100644 --- a/dlls/ws2_32/tests/sock.c +++ b/dlls/ws2_32/tests/sock.c @@ -1259,6 +1259,59 @@ static void test_set_getsockopt(void) ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT, "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError()); + /* TCP_NODELAY: optlen doesn't matter on windows, it should work with any positive value */ + size = sizeof(value); + + value = 1; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 1); + ok (!err, "setsockopt TCP_NODELAY failed with optlen == 1\n"); + value = 0xff; + err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size); + ok(!err, "getsockopt TCP_NODELAY failed\n"); + ok(value == 1, "TCP_NODELAY should be 1\n"); + value = 0; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value)); + ok(!err, "Failed to reset TCP_NODELAY to 0\n"); + + value = 1; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4); + ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4\n"); + value = 0xff; + err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size); + ok(!err, "getsockopt TCP_NODELAY failed\n"); + ok(value == 1, "TCP_NODELAY should be 1\n"); + value = 0; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value)); + ok(!err, "Failed to reset TCP_NODELAY to 0\n"); + + value = 1; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 42); + ok (!err, "setsockopt TCP_NODELAY failed with optlen == 42\n"); + value = 0xff; + err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size); + ok(!err, "getsockopt TCP_NODELAY failed\n"); + ok(value == 1, "TCP_NODELAY should be 1\n"); + value = 0; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, sizeof(value)); + ok(!err, "Failed to reset TCP_NODELAY to 0\n"); + + value = 1; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 0); + ok(err == SOCKET_ERROR && WSAGetLastError() == WSAEFAULT, + "got %d with %d (expected SOCKET_ERROR with WSAEFAULT)\n", err, WSAGetLastError()); + value = 0xff; + err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size); + ok(!err, "getsockopt TCP_NODELAY failed\n"); + ok(!value, "TCP_NODELAY should be 0\n"); + + value = 0x100; + err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, 4); + ok (!err, "setsockopt TCP_NODELAY failed with optlen == 4 and optvalue = 0x100\n"); + value = 0xff; + err = getsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&value, &size); + ok(!err, "getsockopt TCP_NODELAY failed\n"); + ok(!value, "TCP_NODELAY should be 0\n"); + /* Test for erroneously passing a value instead of a pointer as optval */ size = sizeof(char); err = setsockopt(s, SOL_SOCKET, SO_DONTROUTE, (char *)1, size); -- 2.34.0

3 2

[PATCH vkd3d v7 1/6] vkd3d-shader/hlsl: Remove trivial swizzles.
by Giovanni Mascellani Dec. 3, 2021

Dec. 3, 2021

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_codegen.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 24b8205c..f8b977b0 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -475,6 +475,27 @@ static bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, voi return true; } +static bool remove_trivial_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) +{ + struct hlsl_ir_swizzle *swizzle; + unsigned int i; + + if (instr->type != HLSL_IR_SWIZZLE) + return false; + swizzle = hlsl_ir_swizzle(instr); + + if (instr->data_type->dimx != swizzle->val.node->data_type->dimx) + return false; + + for (i = 0; i < instr->data_type->dimx; ++i) + if (((swizzle->swizzle >> (2 * i)) & 3) != i) + return false; + + replace_node(instr, swizzle->val.node); + + return true; +} + /* Lower DIV to RCP + MUL. */ static bool lower_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) { @@ -1355,6 +1376,7 @@ int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun } while (progress); while (transform_ir(ctx, fold_constants, body, NULL)); + transform_ir(ctx, remove_trivial_swizzles, body, NULL); if (ctx->profile->major_version < 4) transform_ir(ctx, lower_division, body, NULL); -- 2.33.1

6 33

[PATCH] d3d10/effect: Use first element when index expression evaluates to out of bounds value.
by Nikolay Sivov Dec. 2, 2021

Dec. 2, 2021

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/d3d10/effect.c | 2 +- dlls/d3d10/tests/effect.c | 194 +++++++++++++++++++++++++++++--------- 2 files changed, 149 insertions(+), 47 deletions(-) diff --git a/dlls/d3d10/effect.c b/dlls/d3d10/effect.c index cd6a3cfb238..190ad19a5f1 100644 --- a/dlls/d3d10/effect.c +++ b/dlls/d3d10/effect.c @@ -774,7 +774,7 @@ static void d3d10_effect_update_dependent_props(struct d3d10_effect_prop_depende { WARN("Expression evaluated to invalid index value %u, array %s of size %u.\n", variable_idx, debugstr_a(v->name), v->type->element_count); - return; + variable_idx = 0; } /* Ignoring destination index here, there are no object typed array properties. */ diff --git a/dlls/d3d10/tests/effect.c b/dlls/d3d10/tests/effect.c index eae0036c0b6..ddc24d66e20 100644 --- a/dlls/d3d10/tests/effect.c +++ b/dlls/d3d10/tests/effect.c @@ -7807,10 +7807,16 @@ float4 g_var2; PixelShader ps_array[2]; VertexShader vs_array[2]; GeometryShader gs_array[2]; +BlendState bs_array[2] +{ + { BlendEnable[0] = true; SrcBlend = inv_src_color; }, + { BlendEnable[0] = true; SrcBlend = src_color; } +}; technique10 tech { pass p0 { + SetBlendState( bs_array[g_var.w], float4(0.0f, 0.0f, 0.0f, 0.0f), 0xffff ); SetPixelShader( ps_array[g_var.z] ); SetVertexShader( vs_array[g_var.x + 0.1f] ); SetGeometryShader( gs_array[g_var2.y] ); @@ -7819,9 +7825,9 @@ technique10 tech #endif static DWORD fx_test_index_expression[] = { - 0x43425844, 0xef7cea81, 0x5103f059, 0x9011e9d4, 0xa8ed3607, 0x00000001, 0x00000564, 0x00000001, - 0x00000024, 0x30315846, 0x00000538, 0xfeff1001, 0x00000001, 0x00000002, 0x00000003, 0x00000000, - 0x00000000, 0x00000000, 0x00000001, 0x00000400, 0x00000000, 0x00000000, 0x00000000, 0x00000000, + 0x43425844, 0x85cafff9, 0xf7f791b5, 0xfc973931, 0x1de9cde1, 0x00000001, 0x00000778, 0x00000001, + 0x00000024, 0x30315846, 0x0000074c, 0xfeff1001, 0x00000001, 0x00000002, 0x00000004, 0x00000000, + 0x00000000, 0x00000000, 0x00000001, 0x00000588, 0x00000000, 0x00000000, 0x00000000, 0x00000002, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000006, 0x00000000, 0x00000000, 0x6f6c4724, 0x736c6162, 0x6f6c6600, 0x00347461, 0x0000000d, 0x00000001, 0x00000000, 0x00000010, 0x00000010, 0x00000010, 0x0000210a, 0x61765f67, 0x5f670072, 0x32726176, 0x78695000, 0x68536c65, 0x72656461, @@ -7829,49 +7835,75 @@ static DWORD fx_test_index_expression[] = 0x61727261, 0x65560079, 0x78657472, 0x64616853, 0x6e007265, 0x02000000, 0x02000000, 0x00000000, 0x00000000, 0x00000000, 0x06000000, 0x76000000, 0x72615f73, 0x00796172, 0x6d6f6547, 0x79727465, 0x64616853, 0xa0007265, 0x02000000, 0x02000000, 0x00000000, 0x00000000, 0x00000000, 0x07000000, - 0x67000000, 0x72615f73, 0x00796172, 0x68636574, 0x00307000, 0x000000ec, 0x43425844, 0xe6990a97, - 0x7ed17834, 0x9f40de47, 0x01f476a7, 0x00000001, 0x000000ec, 0x00000003, 0x0000002c, 0x000000a8, - 0x000000b4, 0x42415443, 0x00000074, 0x0000001c, 0x0000004b, 0x46580400, 0x00000001, 0x0000001c, + 0x67000000, 0x72615f73, 0x00796172, 0x6e656c42, 0x61745364, 0xd4006574, 0x02000000, 0x02000000, + 0x00000000, 0x00000000, 0x00000000, 0x02000000, 0x62000000, 0x72615f73, 0x00796172, 0x00000001, + 0x00000004, 0x00000001, 0x00000001, 0x00000002, 0x00000004, 0x00000001, 0x00000004, 0x00000001, + 0x00000001, 0x00000002, 0x00000003, 0x68636574, 0x00307000, 0x00000004, 0x00000001, 0x00000000, + 0x00000001, 0x00000000, 0x00000001, 0x00000000, 0x00000001, 0x00000000, 0x00000001, 0x00000003, + 0x0000ffff, 0x000000ec, 0x43425844, 0xc647666b, 0x92d327e5, 0x82d21ef6, 0xc31dc0cf, 0x00000001, + 0x000000ec, 0x00000003, 0x0000002c, 0x000000a8, 0x000000b4, 0x42415443, 0x00000074, 0x0000001c, + 0x0000004b, 0x46580400, 0x00000001, 0x0000001c, 0x00000100, 0x00000048, 0x00000030, 0x00000002, + 0x00000001, 0x00000038, 0x00000000, 0x61765f67, 0xabab0072, 0x00030001, 0x00040001, 0x00000001, + 0x00000000, 0x4d007874, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, + 0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, 0x34494c43, 0x00000004, 0x00000000, 0x434c5846, + 0x00000030, 0x00000001, 0x13300001, 0x00000001, 0x00000000, 0x00000002, 0x00000003, 0x00000000, + 0x00000004, 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, 0x000000fb, 0x0000016c, 0x000000ec, + 0x43425844, 0xe6990a97, 0x7ed17834, 0x9f40de47, 0x01f476a7, 0x00000001, 0x000000ec, 0x00000003, + 0x0000002c, 0x000000a8, 0x000000b4, 0x42415443, 0x00000074, 0x0000001c, 0x0000004b, 0x46580400, + 0x00000001, 0x0000001c, 0x00000100, 0x00000048, 0x00000030, 0x00000002, 0x00000001, 0x00000038, + 0x00000000, 0x61765f67, 0xabab0072, 0x00030001, 0x00040001, 0x00000001, 0x00000000, 0x4d007874, + 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, 0x6d6f4320, 0x656c6970, + 0x30312072, 0xab00312e, 0x34494c43, 0x00000004, 0x00000000, 0x434c5846, 0x00000030, 0x00000001, + 0x13300001, 0x00000001, 0x00000000, 0x00000002, 0x00000002, 0x00000000, 0x00000004, 0x00000000, + 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, 0x00000065, 0x00000264, 0x00000128, 0x43425844, 0x7a78de2e, + 0xcd31414e, 0xb6f69158, 0x92416c97, 0x00000001, 0x00000128, 0x00000003, 0x0000002c, 0x000000a8, + 0x000000c4, 0x42415443, 0x00000074, 0x0000001c, 0x0000004b, 0x46580400, 0x00000001, 0x0000001c, 0x00000100, 0x00000048, 0x00000030, 0x00000002, 0x00000001, 0x00000038, 0x00000000, 0x61765f67, 0xabab0072, 0x00030001, 0x00040001, 0x00000001, 0x00000000, 0x4d007874, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, 0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, - 0x34494c43, 0x00000004, 0x00000000, 0x434c5846, 0x00000030, 0x00000001, 0x13300001, 0x00000001, - 0x00000000, 0x00000002, 0x00000002, 0x00000000, 0x00000004, 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, - 0x0000ffff, 0x00000065, 0x000000dc, 0x00000128, 0x43425844, 0x7a78de2e, 0xcd31414e, 0xb6f69158, - 0x92416c97, 0x00000001, 0x00000128, 0x00000003, 0x0000002c, 0x000000a8, 0x000000c4, 0x42415443, - 0x00000074, 0x0000001c, 0x0000004b, 0x46580400, 0x00000001, 0x0000001c, 0x00000100, 0x00000048, - 0x00000030, 0x00000002, 0x00000001, 0x00000038, 0x00000000, 0x61765f67, 0xabab0072, 0x00030001, - 0x00040001, 0x00000001, 0x00000000, 0x4d007874, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, - 0x6853204c, 0x72656461, 0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, 0x34494c43, 0x00000014, - 0x00000004, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, 0x434c5846, 0x0000005c, 0x00000002, - 0x20400001, 0x00000002, 0x00000000, 0x00000002, 0x00000000, 0x00000000, 0x00000001, 0x00000000, - 0x00000000, 0x00000007, 0x00000000, 0x13300001, 0x00000001, 0x00000000, 0x00000007, 0x00000000, - 0x00000000, 0x00000004, 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, 0x00000097, 0x000001d4, - 0x000000ec, 0x43425844, 0x90e93368, 0x6c8d5166, 0x276e99ab, 0x25ccef44, 0x00000001, 0x000000ec, - 0x00000003, 0x0000002c, 0x000000a8, 0x000000b4, 0x42415443, 0x00000074, 0x0000001c, 0x0000004b, - 0x46580400, 0x00000001, 0x0000001c, 0x00000100, 0x00000048, 0x00000030, 0x00000002, 0x00000001, - 0x00000038, 0x00000000, 0x61765f67, 0xab003272, 0x00030001, 0x00040001, 0x00000001, 0x00000000, - 0x4d007874, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, 0x72656461, 0x6d6f4320, - 0x656c6970, 0x30312072, 0xab00312e, 0x34494c43, 0x00000004, 0x00000000, 0x434c5846, 0x00000030, - 0x00000001, 0x13300001, 0x00000001, 0x00000000, 0x00000002, 0x00000001, 0x00000000, 0x00000004, - 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, 0x000000cb, 0x00000308, 0x00000004, 0x00000020, - 0x00000000, 0x00000002, 0xffffffff, 0x00000000, 0x00000030, 0x00000014, 0x00000000, 0x00000000, - 0x00000000, 0x00000000, 0x00000000, 0x00000036, 0x00000014, 0x00000000, 0x00000010, 0x00000000, - 0x00000000, 0x00000000, 0x00000065, 0x00000049, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, - 0x00000000, 0x00000097, 0x0000007b, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, - 0x000000cb, 0x000000af, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x000000d4, - 0x00000001, 0x00000000, 0x000000d9, 0x00000003, 0x00000000, 0x00000007, 0x00000000, 0x00000005, - 0x000001cc, 0x00000006, 0x00000000, 0x00000005, 0x00000300, 0x00000008, 0x00000000, 0x00000005, - 0x000003f8, + 0x34494c43, 0x00000014, 0x00000004, 0x3dcccccd, 0x00000000, 0x00000000, 0x00000000, 0x434c5846, + 0x0000005c, 0x00000002, 0x20400001, 0x00000002, 0x00000000, 0x00000002, 0x00000000, 0x00000000, + 0x00000001, 0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x13300001, 0x00000001, 0x00000000, + 0x00000007, 0x00000000, 0x00000000, 0x00000004, 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, + 0x00000097, 0x0000035c, 0x000000ec, 0x43425844, 0x90e93368, 0x6c8d5166, 0x276e99ab, 0x25ccef44, + 0x00000001, 0x000000ec, 0x00000003, 0x0000002c, 0x000000a8, 0x000000b4, 0x42415443, 0x00000074, + 0x0000001c, 0x0000004b, 0x46580400, 0x00000001, 0x0000001c, 0x00000100, 0x00000048, 0x00000030, + 0x00000002, 0x00000001, 0x00000038, 0x00000000, 0x61765f67, 0xab003272, 0x00030001, 0x00040001, + 0x00000001, 0x00000000, 0x4d007874, 0x6f726369, 0x74666f73, 0x29522820, 0x534c4820, 0x6853204c, + 0x72656461, 0x6d6f4320, 0x656c6970, 0x30312072, 0xab00312e, 0x34494c43, 0x00000004, 0x00000000, + 0x434c5846, 0x00000030, 0x00000001, 0x13300001, 0x00000001, 0x00000000, 0x00000002, 0x00000001, + 0x00000000, 0x00000004, 0x00000000, 0xf0f0f0f0, 0x0f0f0f0f, 0x0000ffff, 0x000000cb, 0x00000490, + 0x00000004, 0x00000020, 0x00000000, 0x00000002, 0xffffffff, 0x00000000, 0x00000030, 0x00000014, + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000036, 0x00000014, 0x00000000, + 0x00000010, 0x00000000, 0x00000000, 0x00000000, 0x00000065, 0x00000049, 0x00000000, 0xffffffff, + 0x00000000, 0x00000000, 0x00000000, 0x00000097, 0x0000007b, 0x00000000, 0xffffffff, 0x00000000, + 0x00000000, 0x00000000, 0x000000cb, 0x000000af, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, + 0x00000000, 0x000000fb, 0x000000df, 0x00000000, 0xffffffff, 0x00000002, 0x00000025, 0x00000000, + 0x00000001, 0x00000104, 0x00000026, 0x00000000, 0x00000001, 0x00000110, 0x00000002, 0x00000025, + 0x00000000, 0x00000001, 0x0000011c, 0x00000026, 0x00000000, 0x00000001, 0x00000128, 0x00000000, + 0x00000134, 0x00000001, 0x00000000, 0x00000139, 0x00000006, 0x00000000, 0x0000000a, 0x00000000, + 0x00000001, 0x0000013c, 0x0000000b, 0x00000000, 0x00000001, 0x00000160, 0x00000002, 0x00000000, + 0x00000005, 0x0000025c, 0x00000007, 0x00000000, 0x00000005, 0x00000354, 0x00000006, 0x00000000, + 0x00000005, 0x00000488, 0x00000008, 0x00000000, 0x00000005, 0x00000580, }; +static void set_vec4(float *v, float x, float y, float z, float w) +{ + v[0] = x; + v[1] = y; + v[2] = z; + v[3] = w; +} + static void test_effect_index_expression(void) { D3D10_PASS_SHADER_DESC shader_desc; ID3D10EffectVectorVariable *vector; ID3D10EffectTechnique *tech; + D3D10_BLEND_DESC bs_desc; ID3D10EffectVariable *v; ID3D10EffectPass *pass; + ID3D10BlendState *bs; ID3D10Effect *effect; ID3D10Device *device; ULONG refcount; @@ -7897,10 +7929,7 @@ static void test_effect_index_expression(void) v = effect->lpVtbl->GetVariableByName(effect, "g_var"); vector = v->lpVtbl->AsVector(v); - val[0] = 0.0f; - val[1] = 0.0f; - val[2] = 1.0f; - val[3] = 0.0f; + set_vec4(val, 0.0f, 0.0f, 1.0f, 0.0f); hr = vector->lpVtbl->SetFloatVector(vector, val); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); @@ -7908,14 +7937,90 @@ static void test_effect_index_expression(void) ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(shader_desc.ShaderIndex == 1, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + hr = pass->lpVtbl->Apply(pass, 0); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ID3D10Device_OMGetBlendState(device, &bs, NULL, NULL); + ID3D10BlendState_GetDesc(bs, &bs_desc); + ok(bs_desc.SrcBlend == D3D10_BLEND_INV_SRC_COLOR, "Unexpected blend state parameter %u.\n", bs_desc.SrcBlend); + ID3D10BlendState_Release(bs); + + set_vec4(val, 0.0f, 0.0f, 1.0f, 1.0f); + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->Apply(pass, 0); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ID3D10Device_OMGetBlendState(device, &bs, NULL, NULL); + ID3D10BlendState_GetDesc(bs, &bs_desc); + ok(bs_desc.SrcBlend == D3D10_BLEND_SRC_COLOR, "Unexpected blend state parameter %u.\n", bs_desc.SrcBlend); + ID3D10BlendState_Release(bs); + + /* Out of bounds index */ + set_vec4(val, 0.0f, 0.0f, 2.0f, 2.0f); + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->GetPixelShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + hr = pass->lpVtbl->Apply(pass, 0); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ID3D10Device_OMGetBlendState(device, &bs, NULL, NULL); + ID3D10BlendState_GetDesc(bs, &bs_desc); + ok(bs_desc.SrcBlend == D3D10_BLEND_INV_SRC_COLOR, "Unexpected blend state parameter %u.\n", bs_desc.SrcBlend); + ID3D10BlendState_Release(bs); + + set_vec4(val, 0.0f, 0.0f, 3.0f, 3.0f); + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->GetPixelShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + hr = pass->lpVtbl->Apply(pass, 0); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ID3D10Device_OMGetBlendState(device, &bs, NULL, NULL); + ID3D10BlendState_GetDesc(bs, &bs_desc); + ok(bs_desc.SrcBlend == D3D10_BLEND_INV_SRC_COLOR, "Unexpected blend state parameter %u.\n", bs_desc.SrcBlend); + ID3D10BlendState_Release(bs); + + set_vec4(val, 0.0f, 0.0f, -1.0f, -1.0f); + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->GetPixelShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + hr = pass->lpVtbl->Apply(pass, 0); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ID3D10Device_OMGetBlendState(device, &bs, NULL, NULL); + ID3D10BlendState_GetDesc(bs, &bs_desc); + ok(bs_desc.SrcBlend == D3D10_BLEND_INV_SRC_COLOR, "Unexpected blend state parameter %u.\n", bs_desc.SrcBlend); + ID3D10BlendState_Release(bs); + + set_vec4(val, 0.0f, 0.0f, -11.0f, 0.0f); + hr = vector->lpVtbl->SetFloatVector(vector, val); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + + hr = pass->lpVtbl->GetPixelShaderDesc(pass, &shader_desc); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); + + hr = pass->lpVtbl->Apply(pass, 0); + ok(hr == S_OK, "Unexpected hr %#x.\n", hr); + ID3D10Device_OMGetBlendState(device, &bs, NULL, NULL); + ID3D10BlendState_GetDesc(bs, &bs_desc); + ok(bs_desc.SrcBlend == D3D10_BLEND_INV_SRC_COLOR, "Unexpected blend state parameter %u.\n", bs_desc.SrcBlend); + ID3D10BlendState_Release(bs); + hr = pass->lpVtbl->GetVertexShaderDesc(pass, &shader_desc); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); - val[0] = 0.9f; - val[1] = 0.0f; - val[2] = 1.0f; - val[3] = 0.0f; + set_vec4(val, 0.9f, 0.0f, 1.0f, 0.0f); hr = vector->lpVtbl->SetFloatVector(vector, val); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); @@ -7930,10 +8035,7 @@ static void test_effect_index_expression(void) ok(hr == S_OK, "Unexpected hr %#x.\n", hr); ok(!shader_desc.ShaderIndex, "Unexpected shader index %#x.\n", shader_desc.ShaderIndex); - val[0] = 0.0f; - val[1] = 1.0f; - val[2] = 0.0f; - val[3] = 0.0f; + set_vec4(val, 0.0f, 1.0f, 0.0f, 0.0f); hr = vector->lpVtbl->SetFloatVector(vector, val); ok(hr == S_OK, "Unexpected hr %#x.\n", hr); -- 2.33.0

2 1

[PATCH v2 1/2] ntdll: Add tests for \Device\NamedPipe\ root directory.
by Jinoh Kang Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Jinoh Kang <jinoh.kang.kr(a)gmail.com> --- dlls/ntdll/tests/om.c | 109 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) diff --git a/dlls/ntdll/tests/om.c b/dlls/ntdll/tests/om.c index 77eb58a23b5..681f3784974 100644 --- a/dlls/ntdll/tests/om.c +++ b/dlls/ntdll/tests/om.c @@ -22,6 +22,7 @@ #include "ntdll_test.h" #include "winternl.h" #include "winuser.h" +#include "winioctl.h" #include "ddk/wdm.h" #include "stdio.h" #include "winnt.h" @@ -197,6 +198,104 @@ static void test_namespace_pipe(void) pNtClose(pipe); } +static NTSTATUS fsctl(HANDLE handle, ULONG code, void *inbuf, ULONG insize, void *outbuf, ULONG outsize) +{ + HANDLE event; + NTSTATUS status; + OBJECT_ATTRIBUTES attr; + IO_STATUS_BLOCK iosb; + + InitializeObjectAttributes(&attr, NULL, 0, 0, NULL); + status = pNtCreateEvent(&event, GENERIC_ALL, &attr, NotificationEvent, FALSE); + ok(status == STATUS_SUCCESS, "NtCreateEvent failure: %08x\n", status); + + memset(&iosb, 0, sizeof(iosb)); + iosb.Status = STATUS_PENDING; + status = NtFsControlFile(handle, event, NULL, NULL, &iosb, FSCTL_PIPE_WAIT, + inbuf, insize, outbuf, outsize); + if (status == STATUS_PENDING) + { + while ((status = iosb.Status) == STATUS_PENDING) + { + WaitForSingleObject(event, INFINITE); + } + } + else if (status == STATUS_SUCCESS) + { + status = iosb.Status; + } + + pNtClose(event); + return status; +} + +static void test_pipe_device_file_as_root(void) +{ + OBJECT_ATTRIBUTES attr; + UNICODE_STRING str; + IO_STATUS_BLOCK iosb; + NTSTATUS status; + LARGE_INTEGER timeout; + HANDLE pipe, root, h; + union { + FILE_PIPE_WAIT_FOR_BUFFER d; + unsigned char buf[offsetof(FILE_PIPE_WAIT_FOR_BUFFER, Name[32])]; + } pipe_wait; + + timeout.QuadPart = -10000; + + pRtlInitUnicodeString(&str, L"\\Device\\NamedPipe"); + InitializeObjectAttributes(&attr, &str, 0, 0, NULL); + status = pNtOpenFile(&root, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0); + ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded, but got %08x\n", status); + + memset( &pipe_wait.d, 0, sizeof(pipe_wait.d) ); + pipe_wait.d.Timeout.QuadPart = 0; + pipe_wait.d.TimeoutSpecified = TRUE; + wcscpy( pipe_wait.d.Name, L"nonexistent" ); + pipe_wait.d.NameLength = wcslen(pipe_wait.d.Name); + + status = fsctl(root, FSCTL_PIPE_WAIT, &pipe_wait, sizeof(pipe_wait), NULL, 0); + todo_wine ok(status == STATUS_ILLEGAL_FUNCTION, "unexpected status for FSCTL_PIPE_WAIT on \\Device\\NamedPipe: %08x\n", status); + + pRtlInitUnicodeString(&str, L"test3\\pipe"); + InitializeObjectAttributes(&attr, &str, 0, root, NULL); + status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout); + ok(status == STATUS_OBJECT_NAME_INVALID, "unexpected status from NtCreateNamedPipeFile: %08x\n", status); + + if (SUCCEEDED(status)) pNtClose(pipe); + pNtClose(root); + + pRtlInitUnicodeString(&str, L"\\Device\\NamedPipe\\"); + InitializeObjectAttributes(&attr, &str, 0, 0, NULL); + status = pNtOpenFile(&root, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0); + ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded, but got %08x\n", status); + + memset( &pipe_wait.d, 0, sizeof(pipe_wait.d) ); + pipe_wait.d.Timeout.QuadPart = 0; + pipe_wait.d.TimeoutSpecified = TRUE; + wcscpy( pipe_wait.d.Name, L"nonexistent_pipe" ); + pipe_wait.d.NameLength = wcslen(pipe_wait.d.Name); + + status = fsctl(root, FSCTL_PIPE_WAIT, &pipe_wait, sizeof(pipe_wait), NULL, 0); + ok(status == STATUS_OBJECT_NAME_NOT_FOUND, "unexpected status for FSCTL_PIPE_WAIT on \\Device\\NamedPipe\\: %08x\n", status); + + pRtlInitUnicodeString(&str, L"test3\\pipe"); + InitializeObjectAttributes(&attr, &str, 0, root, NULL); + status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, + FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout); + todo_wine ok(status == STATUS_SUCCESS, "unexpected failure from NtCreateNamedPipeFile: %08x\n", status); + + h = CreateFileA("\\\\.\\pipe\\test3\\pipe", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, + OPEN_EXISTING, 0, 0 ); + todo_wine ok(h != INVALID_HANDLE_VALUE, "Failed to open NamedPipe (%u)\n", GetLastError()); + + pNtClose(h); + pNtClose(pipe); + pNtClose(root); +} + #define check_create_open_dir(parent, name, status) check_create_open_dir_(__LINE__, parent, name, status) static void check_create_open_dir_( int line, HANDLE parent, const WCHAR *name, NTSTATUS expect ) { @@ -1870,6 +1969,15 @@ static void test_query_object(void) pNtClose( handle ); + handle = CreateFileA( "\\\\.\\pipe\\", 0, 0, NULL, OPEN_EXISTING, 0, 0 ); + ok( handle != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError() ); + + test_object_name( handle, L"\\Device\\NamedPipe\\", TRUE ); + test_object_type( handle, L"File" ); + test_file_info( handle ); + + pNtClose( handle ); + RtlInitUnicodeString( &path, L"\\REGISTRY\\Machine" ); status = pNtCreateKey( &handle, KEY_READ, &attr, 0, 0, 0, 0 ); ok( status == STATUS_SUCCESS, "NtCreateKey failed status %x\n", status ); @@ -2434,6 +2542,7 @@ START_TEST(om) test_case_sensitive(); test_namespace_pipe(); + test_pipe_device_file_as_root(); test_name_collisions(); test_name_limits(); test_directory(); -- 2.31.1

2 2

[PATCH vkd3d 1/3] vkd3d-shader/hlsl: Write the else block only if it isn't empty.
by Giovanni Mascellani Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_sm4.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/libs/vkd3d-shader/hlsl_sm4.c b/libs/vkd3d-shader/hlsl_sm4.c index e597425a..c56a74d4 100644 --- a/libs/vkd3d-shader/hlsl_sm4.c +++ b/libs/vkd3d-shader/hlsl_sm4.c @@ -1446,11 +1446,14 @@ static void write_sm4_if(struct hlsl_ctx *ctx, struct vkd3d_bytecode_buffer *buf write_sm4_block(ctx, buffer, &iff->then_instrs); - instr.opcode = VKD3D_SM4_OP_ELSE; - instr.src_count = 0; - write_sm4_instruction(buffer, &instr); + if (!list_empty(&iff->else_instrs.instrs)) + { + instr.opcode = VKD3D_SM4_OP_ELSE; + instr.src_count = 0; + write_sm4_instruction(buffer, &instr); - write_sm4_block(ctx, buffer, &iff->else_instrs); + write_sm4_block(ctx, buffer, &iff->else_instrs); + } instr.opcode = VKD3D_SM4_OP_ENDIF; write_sm4_instruction(buffer, &instr); -- 2.33.1

4 17

[PATCH vkd3d v6 1/6] vkd3d-shader/hlsl: Remove trivial swizzles.
by Giovanni Mascellani Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- libs/vkd3d-shader/hlsl_codegen.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 24b8205c..f8b977b0 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -475,6 +475,27 @@ static bool fold_constants(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, voi return true; } +static bool remove_trivial_swizzles(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) +{ + struct hlsl_ir_swizzle *swizzle; + unsigned int i; + + if (instr->type != HLSL_IR_SWIZZLE) + return false; + swizzle = hlsl_ir_swizzle(instr); + + if (instr->data_type->dimx != swizzle->val.node->data_type->dimx) + return false; + + for (i = 0; i < instr->data_type->dimx; ++i) + if (((swizzle->swizzle >> (2 * i)) & 3) != i) + return false; + + replace_node(instr, swizzle->val.node); + + return true; +} + /* Lower DIV to RCP + MUL. */ static bool lower_division(struct hlsl_ctx *ctx, struct hlsl_ir_node *instr, void *context) { @@ -1355,6 +1376,7 @@ int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun } while (progress); while (transform_ir(ctx, fold_constants, body, NULL)); + transform_ir(ctx, remove_trivial_swizzles, body, NULL); if (ctx->profile->major_version < 4) transform_ir(ctx, lower_division, body, NULL); -- 2.33.1

3 10

[PATCH 6/6] winecoreaudio: Build with msvcrt.
by Huw Davies Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winecoreaudio.drv/Makefile.in | 2 -- dlls/winecoreaudio.drv/midi.c | 6 +----- dlls/winecoreaudio.drv/mmdevdrv.c | 25 ++++++++++--------------- 3 files changed, 11 insertions(+), 22 deletions(-) diff --git a/dlls/winecoreaudio.drv/Makefile.in b/dlls/winecoreaudio.drv/Makefile.in index 8162eae67d7..4be396c489c 100644 --- a/dlls/winecoreaudio.drv/Makefile.in +++ b/dlls/winecoreaudio.drv/Makefile.in @@ -4,8 +4,6 @@ IMPORTS = uuid ole32 user32 advapi32 DELAYIMPORTS = winmm EXTRALIBS = $(COREAUDIO_LIBS) -EXTRADLLFLAGS = -mcygwin - C_SRCS = \ coreaudio.c \ coremidi.c \ diff --git a/dlls/winecoreaudio.drv/midi.c b/dlls/winecoreaudio.drv/midi.c index 6191885553a..6c6752c0c76 100644 --- a/dlls/winecoreaudio.drv/midi.c +++ b/dlls/winecoreaudio.drv/midi.c @@ -21,23 +21,19 @@ * 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 "config.h" -#include "wine/port.h" - #include <string.h> #include <stdarg.h> #include <stdio.h> #include "windef.h" #include "winbase.h" +#include "winternl.h" #include "wingdi.h" #include "winuser.h" #include "winnls.h" #include "mmddk.h" #include "mmdeviceapi.h" #include "audioclient.h" -#include "wine/unicode.h" #include "wine/debug.h" #include "wine/unixlib.h" #include "coreaudio.h" diff --git a/dlls/winecoreaudio.drv/mmdevdrv.c b/dlls/winecoreaudio.drv/mmdevdrv.c index b4cf325c9d2..128396fbe29 100644 --- a/dlls/winecoreaudio.drv/mmdevdrv.c +++ b/dlls/winecoreaudio.drv/mmdevdrv.c @@ -21,11 +21,11 @@ #include "windef.h" #include "winbase.h" +#include "winternl.h" #include "winnls.h" #include "winreg.h" #include "wine/debug.h" #include "wine/heap.h" -#include "wine/unicode.h" #include "wine/list.h" #include "wine/unixlib.h" @@ -126,10 +126,7 @@ typedef struct _SessionMgr { IMMDevice *device; } SessionMgr; -static const WCHAR drv_key_devicesW[] = {'S','o','f','t','w','a','r','e','\\', - 'W','i','n','e','\\','D','r','i','v','e','r','s','\\', - 'w','i','n','e','c','o','r','e','a','u','d','i','o','.','d','r','v','\\','d','e','v','i','c','e','s',0}; -static const WCHAR guidW[] = {'g','u','i','d',0}; +static const WCHAR *drv_key_devicesW = L"Software\\Wine\\Drivers\\winecoreaudio.drv\\devices"; static HANDLE g_timer_q; @@ -253,7 +250,7 @@ static void set_device_guid(EDataFlow flow, HKEY drv_key, const WCHAR *key_name, goto exit; } - lr = RegSetValueExW(key, guidW, 0, REG_BINARY, (BYTE*)guid, + lr = RegSetValueExW(key, L"guid", 0, REG_BINARY, (BYTE*)guid, sizeof(GUID)); if(lr != ERROR_SUCCESS) ERR("RegSetValueEx(%s\\guid) failed: %u\n", wine_dbgstr_w(key_name), lr); @@ -270,19 +267,17 @@ static void get_device_guid(EDataFlow flow, DWORD device_id, GUID *guid) DWORD type, size = sizeof(*guid); WCHAR key_name[256]; - static const WCHAR key_fmt[] = {'%','u',0}; - if(flow == eCapture) key_name[0] = '1'; else key_name[0] = '0'; key_name[1] = ','; - sprintfW(key_name + 2, key_fmt, device_id); + swprintf(key_name + 2, ARRAY_SIZE(key_name), L"%u", device_id); if(RegOpenKeyExW(HKEY_CURRENT_USER, drv_key_devicesW, 0, KEY_WRITE|KEY_READ, &key) == ERROR_SUCCESS){ if(RegOpenKeyExW(key, key_name, 0, KEY_READ, &dev_key) == ERROR_SUCCESS){ - if(RegQueryValueExW(dev_key, guidW, 0, &type, + if(RegQueryValueExW(dev_key, L"guid", 0, &type, (BYTE*)guid, &size) == ERROR_SUCCESS){ if(type == REG_BINARY){ RegCloseKey(dev_key); @@ -322,8 +317,8 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, { struct get_endpoint_ids_params params; unsigned int i; - GUID *guids; - WCHAR **ids; + GUID *guids = NULL; + WCHAR **ids = NULL; TRACE("%d %p %p %p\n", flow, ids_out, num, def_index); @@ -346,7 +341,7 @@ HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids_out, } for(i = 0; i < params.num; i++){ - int size = (strlenW(params.endpoints[i].name) + 1) * sizeof(WCHAR); + int size = (wcslen(params.endpoints[i].name) + 1) * sizeof(WCHAR); ids[i] = heap_alloc(size); if(!ids[i]){ params.result = E_OUTOFMEMORY; @@ -402,7 +397,7 @@ static BOOL get_deviceid_by_guid(GUID *guid, DWORD *id, EDataFlow *flow) } size = sizeof(reg_guid); - if(RegQueryValueExW(key, guidW, 0, &type, + if(RegQueryValueExW(key, L"guid", 0, &type, (BYTE*)&reg_guid, &size) == ERROR_SUCCESS){ if(IsEqualGUID(&reg_guid, guid)){ RegCloseKey(key); @@ -419,7 +414,7 @@ static BOOL get_deviceid_by_guid(GUID *guid, DWORD *id, EDataFlow *flow) return FALSE; } - *id = strtoulW(key_name + 2, NULL, 10); + *id = wcstoul(key_name + 2, NULL, 10); return TRUE; } -- 2.23.0

2 1

[PATCH 5/6] winecoreaudio: Always start the notification thread.
by Huw Davies Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winecoreaudio.drv/coremidi.c | 9 ++------- dlls/winecoreaudio.drv/midi.c | 7 +------ dlls/winecoreaudio.drv/unixlib.h | 1 - 3 files changed, 3 insertions(+), 14 deletions(-) diff --git a/dlls/winecoreaudio.drv/coremidi.c b/dlls/winecoreaudio.drv/coremidi.c index 5777236bd26..8c09d4a2c1b 100644 --- a/dlls/winecoreaudio.drv/coremidi.c +++ b/dlls/winecoreaudio.drv/coremidi.c @@ -417,19 +417,14 @@ NTSTATUS midi_init(void *args) dests[i].caps.wNotes = 0; } - params->num_srcs = num_srcs; - *params->err = DRV_SUCCESS; return STATUS_SUCCESS; } NTSTATUS midi_release(void *args) { - if (num_srcs) - { - /* stop the notify_wait thread */ - notify_post(NULL); - } + /* stop the notify_wait thread */ + notify_post(NULL); if (midi_client) MIDIClientDispose(midi_client); /* MIDIClientDispose will close all ports */ diff --git a/dlls/winecoreaudio.drv/midi.c b/dlls/winecoreaudio.drv/midi.c index 262713dd003..6191885553a 100644 --- a/dlls/winecoreaudio.drv/midi.c +++ b/dlls/winecoreaudio.drv/midi.c @@ -45,8 +45,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(midi); -static DWORD MIDIIn_NumDevs = 0; - static void notify_client(struct notify_context *notify) { TRACE("dev_id=%d msg=%d param1=%04lX param2=%04lX\n", notify->dev_id, notify->msg, notify->param_1, notify->param_2); @@ -87,10 +85,7 @@ static LONG CoreAudio_MIDIInit(void) return err; } - MIDIIn_NumDevs = params.num_srcs; - - if (MIDIIn_NumDevs > 0) - CloseHandle(CreateThread(NULL, 0, notify_thread, NULL, 0, NULL)); + CloseHandle(CreateThread(NULL, 0, notify_thread, NULL, 0, NULL)); return err; } diff --git a/dlls/winecoreaudio.drv/unixlib.h b/dlls/winecoreaudio.drv/unixlib.h index d44a7a013e8..bd9a5ce03bd 100644 --- a/dlls/winecoreaudio.drv/unixlib.h +++ b/dlls/winecoreaudio.drv/unixlib.h @@ -186,7 +186,6 @@ struct set_volumes_params struct midi_init_params { DWORD *err; - UINT num_srcs; }; struct notify_context -- 2.23.0

2 1

[PATCH 4/6] winecoreaudio: Switch midi_in_lock() away from a syscall prototype.
by Huw Davies Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winecoreaudio.drv/coremidi.c | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/dlls/winecoreaudio.drv/coremidi.c b/dlls/winecoreaudio.drv/coremidi.c index ae8b71e002b..5777236bd26 100644 --- a/dlls/winecoreaudio.drv/coremidi.c +++ b/dlls/winecoreaudio.drv/coremidi.c @@ -136,13 +136,10 @@ static struct notify_context *notify_read, *notify_write; #define MAX_MIDI_SYNTHS 1 -NTSTATUS midi_in_lock(void *args) +static void midi_in_lock(BOOL lock) { - BOOL lock = !!args; - if (lock) pthread_mutex_lock(&midi_in_mutex); else pthread_mutex_unlock(&midi_in_mutex); - return STATUS_SUCCESS; } static void set_in_notify(struct notify_context *notify, struct midi_src *src, WORD dev_id, WORD msg, @@ -228,7 +225,7 @@ static void process_sysex_packet(struct midi_src *src, MIDIPacket *packet) src->state |= 2; - midi_in_lock((void *)TRUE); + midi_in_lock(TRUE); while (len) { @@ -253,7 +250,7 @@ static void process_sysex_packet(struct midi_src *src, MIDIPacket *packet) } } - midi_in_lock((void *)FALSE); + midi_in_lock(FALSE); } static void process_small_packet(struct midi_src *src, MIDIPacket *packet) @@ -981,13 +978,13 @@ static DWORD midi_in_add_buffer(WORD dev_id, MIDIHDR *hdr, DWORD hdr_size) hdr->dwBytesRecorded = 0; hdr->lpNext = NULL; - midi_in_lock((void *)TRUE); + midi_in_lock(TRUE); next = &srcs[dev_id].lpQueueHdr; while (*next) next = &(*next)->lpNext; *next = hdr; - midi_in_lock((void *)FALSE); + midi_in_lock(FALSE); return MMSYSERR_NOERROR; } @@ -1090,7 +1087,7 @@ static DWORD midi_in_reset(WORD dev_id, struct notify_context *notify) } src = srcs + dev_id; - midi_in_lock((void *)TRUE); + midi_in_lock(TRUE); if (src->lpQueueHdr) { @@ -1102,7 +1099,7 @@ static DWORD midi_in_reset(WORD dev_id, struct notify_context *notify) if (src->lpQueueHdr) err = ERROR_RETRY; /* ask the client to call again */ } - midi_in_lock((void *)FALSE); + midi_in_lock(FALSE); return err; } -- 2.23.0

2 1

[PATCH 3/6] winecoreaudio: Move the midi input event processing to the unixlib.
by Huw Davies Dec. 1, 2021

Dec. 1, 2021

Notifications of incoming data are now directly added to a notify ring-buffer by macOS's midi read callback. The ring-buffer is implemented with an unused sentinel directly before the read ptr to distinguish between the full vs empty state. Notifications are processed by the client's notify thread via the midi_notify_wait syscall. Note that the read callback thread is not a Win32 thread, so the Win32 api cannot be used in anything that it calls. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winecoreaudio.drv/coreaudio.c | 2 - dlls/winecoreaudio.drv/coremidi.c | 163 +++++++++++++++++++---- dlls/winecoreaudio.drv/coremidi.h | 86 ------------ dlls/winecoreaudio.drv/midi.c | 204 +---------------------------- dlls/winecoreaudio.drv/unixlib.h | 6 +- 5 files changed, 140 insertions(+), 321 deletions(-) delete mode 100644 dlls/winecoreaudio.drv/coremidi.h diff --git a/dlls/winecoreaudio.drv/coreaudio.c b/dlls/winecoreaudio.drv/coreaudio.c index 1efcfdba3f4..e6ce5c33e36 100644 --- a/dlls/winecoreaudio.drv/coreaudio.c +++ b/dlls/winecoreaudio.drv/coreaudio.c @@ -1634,6 +1634,4 @@ unixlib_entry_t __wine_unix_call_funcs[] = midi_out_message, midi_in_message, midi_notify_wait, - - midi_in_lock, /* temporary */ }; diff --git a/dlls/winecoreaudio.drv/coremidi.c b/dlls/winecoreaudio.drv/coremidi.c index bb8cb23f83b..ae8b71e002b 100644 --- a/dlls/winecoreaudio.drv/coremidi.c +++ b/dlls/winecoreaudio.drv/coremidi.c @@ -89,7 +89,6 @@ #include "wine/unixlib.h" #include "coreaudio.h" -#include "coremidi.h" #include "unixlib.h" WINE_DEFAULT_DEBUG_CHANNEL(midi); @@ -107,12 +106,24 @@ struct midi_dest WORD wFlags; }; +struct midi_src +{ + MIDIEndpointRef source; + + WORD wDevID; + int state; /* 0 is no recording started, 1 in recording, bit 2 set if in sys exclusive recording */ + MIDIINCAPSW caps; + MIDIOPENDESC midiDesc; + LPMIDIHDR lpQueueHdr; + WORD wFlags; + DWORD startTime; +}; + static MIDIClientRef midi_client; static MIDIPortRef midi_out_port, midi_in_port; static UINT num_dests, num_srcs; static struct midi_dest *dests; static struct midi_src *srcs; -static CFStringRef midi_in_thread_port_name; static pthread_mutex_t midi_in_mutex = PTHREAD_MUTEX_INITIALIZER; @@ -123,6 +134,8 @@ static BOOL notify_quit; static struct notify_context notify_buffer[NOTIFY_BUFFER_SIZE]; static struct notify_context *notify_read, *notify_write; +#define MAX_MIDI_SYNTHS 1 + NTSTATUS midi_in_lock(void *args) { BOOL lock = !!args; @@ -146,11 +159,49 @@ static void set_in_notify(struct notify_context *notify, struct midi_src *src, W notify->instance = src->midiDesc.dwInstance; } +/* + * notify buffer: The notification ring buffer is implemented so that + * there is always at least one unused sentinel before the current + * read position in order to allow detection of the full vs empty + * state. + */ +static struct notify_context *notify_buffer_next(struct notify_context *notify) +{ + if (++notify >= notify_buffer + ARRAY_SIZE(notify_buffer)) + notify = notify_buffer; + + return notify; +} + +static void notify_buffer_add(struct notify_context *notify) +{ + struct notify_context *next = notify_buffer_next(notify_write); + + if (next == notify_read) /* buffer is full - we can't issue a WARN() in a non-Win32 thread */ + notify_read = notify_buffer_next(notify_read); /* drop the oldest notification */ + *notify_write = *notify; + notify_write = next; +} + +static BOOL notify_buffer_empty(void) +{ + return notify_read == notify_write; +} + +static BOOL notify_buffer_remove(struct notify_context *notify) +{ + if (notify_buffer_empty()) return FALSE; + + *notify = *notify_read; + notify_read = notify_buffer_next(notify_read); + return TRUE; +} + static void notify_post(struct notify_context *notify) { pthread_mutex_lock(&notify_mutex); - if (notify) FIXME("Not yet handled\n"); + if (notify) notify_buffer_add(notify); else notify_quit = TRUE; pthread_cond_signal(&notify_cond); @@ -169,29 +220,94 @@ static uint64_t get_time_ms(void) return mach_absolute_time() / 1000000 * timebase.numer / timebase.denom; } +static void process_sysex_packet(struct midi_src *src, MIDIPacket *packet) +{ + unsigned int pos = 0, len = packet->length, copy_len; + DWORD current_time = get_time_ms() - src->startTime; + struct notify_context notify; + + src->state |= 2; + + midi_in_lock((void *)TRUE); + + while (len) + { + MIDIHDR *hdr = src->lpQueueHdr; + if (!hdr) break; + + copy_len = min(len, hdr->dwBufferLength - hdr->dwBytesRecorded); + memcpy(hdr->lpData + hdr->dwBytesRecorded, packet->data + pos, copy_len); + hdr->dwBytesRecorded += copy_len; + len -= copy_len; + pos += copy_len; + + if ((hdr->dwBytesRecorded == hdr->dwBufferLength) || + (*(BYTE*)(hdr->lpData + hdr->dwBytesRecorded - 1) == 0xf7)) + { /* buffer full or end of sysex message */ + src->lpQueueHdr = hdr->lpNext; + hdr->dwFlags &= ~MHDR_INQUEUE; + hdr->dwFlags |= MHDR_DONE; + set_in_notify(&notify, src, src->wDevID, MIM_LONGDATA, (DWORD_PTR)hdr, current_time); + notify_post(&notify); + src->state &= ~2; + } + } + + midi_in_lock((void *)FALSE); +} + +static void process_small_packet(struct midi_src *src, MIDIPacket *packet) +{ + DWORD current_time = get_time_ms() - src->startTime, data; + struct notify_context notify; + unsigned int pos = 0; + + while (pos < packet->length) + { + data = 0; + switch (packet->data[pos] & 0xf0) + { + case 0xf0: + data = packet->data[pos]; + pos++; + break; + case 0xc0: + case 0xd0: + data = (packet->data[pos + 1] << 8) | packet->data[pos]; + pos += 2; + break; + default: + data = (packet->data[pos + 2] << 16) | (packet->data[pos + 1] << 8) | + packet->data[pos]; + pos += 3; + break; + } + set_in_notify(&notify, src, src->wDevID, MIM_DATA, data, current_time); + notify_post(&notify); + } +} + static void midi_in_read_proc(const MIDIPacketList *pktlist, void *refCon, void *connRefCon) { - CFMessagePortRef msg_port = CFMessagePortCreateRemote(kCFAllocatorDefault, midi_in_thread_port_name); MIDIPacket *packet = (MIDIPacket *)pktlist->packet; - CFMutableDataRef data; - MIDIMessage msg; + WORD dev_id = *(WORD *)connRefCon; + struct midi_src *src; unsigned int i; + if (dev_id >= num_srcs) return; + src = srcs + dev_id; + if (src->state < 1) /* input not started */ + return; + for (i = 0; i < pktlist->numPackets; ++i) { - msg.devID = *(UInt16 *)connRefCon; - msg.length = packet->length; - data = CFDataCreateMutable(kCFAllocatorDefault, sizeof(msg) + packet->length); - if (data) - { - CFDataAppendBytes(data, (UInt8 *)&msg, sizeof(msg)); - CFDataAppendBytes(data, packet->data, packet->length); - CFMessagePortSendRequest(msg_port, 0, data, 0.0, 0.0, NULL, NULL); - CFRelease(data); - } + if (packet->data[0] == 0xf0 || src->state & 2) + process_sysex_packet(src, packet); + else + process_small_packet(src, packet); + packet = MIDIPacketNext(packet); } - CFRelease(msg_port); } NTSTATUS midi_init(void *args) @@ -225,7 +341,6 @@ NTSTATUS midi_init(void *args) if (num_srcs > 0) { - midi_in_thread_port_name = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("MIDIInThreadPortName.%u"), getpid()); name = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("WineInputPort.%u"), getpid()); MIDIInputPortCreate(midi_client, name, midi_in_read_proc, NULL, &midi_in_port); CFRelease(name); @@ -306,8 +421,6 @@ NTSTATUS midi_init(void *args) } params->num_srcs = num_srcs; - params->srcs = srcs; - params->midi_in_port = (void *)midi_in_port; *params->err = DRV_SUCCESS; return STATUS_SUCCESS; @@ -315,15 +428,8 @@ NTSTATUS midi_init(void *args) NTSTATUS midi_release(void *args) { - CFMessagePortRef msg_port; - if (num_srcs) { - /* Stop CFRunLoop in MIDIIn_MessageThread */ - msg_port = CFMessagePortCreateRemote(kCFAllocatorDefault, midi_in_thread_port_name); - CFMessagePortSendRequest(msg_port, 1, NULL, 0.0, 0.0, NULL, NULL); - CFRelease(msg_port); - /* stop the notify_wait thread */ notify_post(NULL); } @@ -1114,10 +1220,11 @@ NTSTATUS midi_notify_wait(void *args) pthread_mutex_lock(&notify_mutex); - while (!notify_quit) + while (!notify_quit && notify_buffer_empty()) pthread_cond_wait(&notify_cond, &notify_mutex); *params->quit = notify_quit; + if (!notify_quit) notify_buffer_remove(params->notify); pthread_mutex_unlock(&notify_mutex); diff --git a/dlls/winecoreaudio.drv/coremidi.h b/dlls/winecoreaudio.drv/coremidi.h deleted file mode 100644 index e6d5c8c18c8..00000000000 --- a/dlls/winecoreaudio.drv/coremidi.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Wine Midi driver for Mac OS X - * - * Copyright 2006 Emmanuel Maillard - * - * 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 - */ - -#ifndef WINE_COREMIDI_H -#define WINE_COREMIDI_H - -#include <CoreFoundation/CoreFoundation.h> - -#define MAX_MIDI_SYNTHS 1 - -#ifdef WINE_DEFINITIONS -/* - * Due to CoreMIDI headers conflict redefine some types for Wine - */ -typedef void *MIDIClientRef; -typedef void *MIDIEndpointRef; -typedef void *MIDIPortRef; -typedef void *MIDIObjectRef; - -typedef struct MIDIPacketList MIDIPacketList; - -/* - * functions - */ -extern OSStatus MIDIClientDispose(MIDIClientRef client); -extern unsigned MIDIGetNumberOfDestinations(void); -extern MIDIEndpointRef MIDIGetDestination(unsigned i); -extern unsigned MIDIGetNumberOfSources(void); -extern MIDIEndpointRef MIDIGetSource(unsigned i); -extern OSStatus MIDIOutputPortCreate(MIDIClientRef client, CFStringRef portName, MIDIPortRef *outPort); - -typedef void (*MIDIReadProc)(const MIDIPacketList *pktlist, void *readProcRefCon, void *srcConnRefCon); -extern OSStatus MIDIInputPortCreate(MIDIClientRef client, CFStringRef portName, MIDIReadProc readProc, void *refCon, MIDIPortRef *outPort); - -extern OSStatus MIDIObjectGetProperties(MIDIObjectRef obj, CFPropertyListRef *outProperties, Boolean deep); - -extern OSStatus MIDIPortConnectSource(MIDIPortRef port, MIDIEndpointRef source, void *connRefCon); - -/* - * Due to AudioUnit headers conflict redefine some types. - */ -typedef void *AudioUnit; -typedef void *AUGraph; - -extern OSStatus MusicDeviceMIDIEvent(AudioUnit au, UInt32 inStatus, UInt32 inData1, UInt32 inData2, UInt32 inOffsetSampleFrame); -extern OSStatus MusicDeviceSysEx(AudioUnit au, const UInt8 *inData, UInt32 inLength); -#endif - -/* midi.c */ -typedef struct midi_src -{ - MIDIEndpointRef source; - - WORD wDevID; - int state; /* 0 is no recording started, 1 in recording, bit 2 set if in sys exclusive recording */ - MIDIINCAPSW caps; - MIDIOPENDESC midiDesc; - LPMIDIHDR lpQueueHdr; - WORD wFlags; - DWORD startTime; -} MIDISource; - -typedef struct { - UInt16 devID; - UInt16 length; - Byte data[]; -} MIDIMessage; - -#endif diff --git a/dlls/winecoreaudio.drv/midi.c b/dlls/winecoreaudio.drv/midi.c index e9cdb2a8ec4..262713dd003 100644 --- a/dlls/winecoreaudio.drv/midi.c +++ b/dlls/winecoreaudio.drv/midi.c @@ -45,31 +45,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(midi); -#include <mach/mach_time.h> -#include <CoreAudio/CoreAudio.h> - -#define WINE_DEFINITIONS -#include "coremidi.h" - static DWORD MIDIIn_NumDevs = 0; - -static CFStringRef MIDIInThreadPortName; - -static DWORD WINAPI MIDIIn_MessageThread(LPVOID p); - -static MIDIPortRef MIDIInPort = NULL; - -MIDISource *sources; - -static uint64_t get_time_ms(void) -{ - static mach_timebase_info_data_t timebase; - - if (!timebase.denom) mach_timebase_info(&timebase); - return mach_absolute_time() / 1000000 * timebase.numer / timebase.denom; -} - static void notify_client(struct notify_context *notify) { TRACE("dev_id=%d msg=%d param1=%04lX param2=%04lX\n", notify->dev_id, notify->msg, notify->param_1, notify->param_2); @@ -81,14 +58,17 @@ static void notify_client(struct notify_context *notify) static DWORD WINAPI notify_thread(void *p) { struct midi_notify_wait_params params; + struct notify_context notify; BOOL quit; + params.notify = &notify; params.quit = &quit; while (1) { UNIX_CALL(midi_notify_wait, &params); if (quit) break; + if (notify.send_notify) notify_client(&notify); } return 0; } @@ -108,15 +88,10 @@ static LONG CoreAudio_MIDIInit(void) } MIDIIn_NumDevs = params.num_srcs; - sources = params.srcs; - MIDIInPort = params.midi_in_port; if (MIDIIn_NumDevs > 0) - { - MIDIInThreadPortName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("MIDIInThreadPortName.%u"), getpid()); - CloseHandle( CreateThread(NULL, 0, MIDIIn_MessageThread, NULL, 0, NULL)); CloseHandle(CreateThread(NULL, 0, notify_thread, NULL, 0, NULL)); - } + return err; } @@ -125,181 +100,10 @@ static LONG CoreAudio_MIDIRelease(void) TRACE("\n"); UNIX_CALL(midi_release, NULL); - sources = NULL; return DRV_SUCCESS; } - -/************************************************************************** - * MIDI_NotifyClient [internal] - */ -static void MIDI_NotifyClient(UINT wDevID, WORD wMsg, DWORD_PTR dwParam1, DWORD_PTR dwParam2) -{ - DWORD_PTR dwCallBack; - UINT uFlags; - HANDLE hDev; - DWORD_PTR dwInstance; - - TRACE("wDevID=%d wMsg=%d dwParm1=%04lX dwParam2=%04lX\n", wDevID, wMsg, dwParam1, dwParam2); - - switch (wMsg) { - case MIM_DATA: - case MIM_LONGDATA: - case MIM_ERROR: - case MIM_LONGERROR: - case MIM_MOREDATA: - dwCallBack = sources[wDevID].midiDesc.dwCallback; - uFlags = sources[wDevID].wFlags; - hDev = sources[wDevID].midiDesc.hMidi; - dwInstance = sources[wDevID].midiDesc.dwInstance; - break; - default: - ERR("Unsupported MSW-MIDI message %u\n", wMsg); - return; - } - - DriverCallback(dwCallBack, uFlags, hDev, wMsg, dwInstance, dwParam1, dwParam2); -} - -static void midi_lock( BOOL lock ) -{ - UNIX_CALL(midi_in_lock, (void *)lock); -} - -/* - * MIDI In Mach message handling - */ -static CFDataRef MIDIIn_MessageHandler(CFMessagePortRef local, SInt32 msgid, CFDataRef data, void *info) -{ - MIDIMessage *msg = NULL; - int i = 0; - MIDISource *src = NULL; - DWORD sendData = 0; - int pos = 0; - DWORD currentTime; - BOOL sysexStart; - - switch (msgid) - { - case 0: - msg = (MIDIMessage *) CFDataGetBytePtr(data); - TRACE("devID=%d\n", msg->devID); - for (i = 0; i < msg->length; ++i) { - TRACE("%02X ", msg->data[i]); - } - TRACE("\n"); - src = &sources[msg->devID]; - if (src->state < 1) - { - TRACE("input not started, thrown away\n"); - return NULL; - } - - sysexStart = (msg->data[0] == 0xF0); - - if (sysexStart || src->state & 2) { - int pos = 0; - int len = msg->length; - - if (sysexStart) { - TRACE("Receiving sysex message\n"); - src->state |= 2; - } - - midi_lock( TRUE ); - currentTime = get_time_ms() - src->startTime; - - while (len) { - LPMIDIHDR lpMidiHdr = src->lpQueueHdr; - - if (lpMidiHdr != NULL) { - int copylen = min(len, lpMidiHdr->dwBufferLength - lpMidiHdr->dwBytesRecorded); - memcpy(lpMidiHdr->lpData + lpMidiHdr->dwBytesRecorded, msg->data + pos, copylen); - lpMidiHdr->dwBytesRecorded += copylen; - len -= copylen; - pos += copylen; - - TRACE("Copied %d bytes of sysex message\n", copylen); - - if ((lpMidiHdr->dwBytesRecorded == lpMidiHdr->dwBufferLength) || - (*(BYTE*)(lpMidiHdr->lpData + lpMidiHdr->dwBytesRecorded - 1) == 0xF7)) { - TRACE("Sysex message complete (or buffer limit reached), dispatching %d bytes\n", lpMidiHdr->dwBytesRecorded); - src->lpQueueHdr = lpMidiHdr->lpNext; - lpMidiHdr->dwFlags &= ~MHDR_INQUEUE; - lpMidiHdr->dwFlags |= MHDR_DONE; - MIDI_NotifyClient(msg->devID, MIM_LONGDATA, (DWORD_PTR)lpMidiHdr, currentTime); - src->state &= ~2; - } - } - else { - FIXME("Sysex data received but no buffer to store it!\n"); - break; - } - } - - midi_lock( FALSE ); - return NULL; - } - - midi_lock( TRUE ); - currentTime = get_time_ms() - src->startTime; - - while (pos < msg->length) - { - sendData = 0; - switch (msg->data[pos] & 0xF0) - { - case 0xF0: - sendData = (msg->data[pos] << 0); - pos++; - break; - - case 0xC0: - case 0xD0: - sendData = (msg->data[pos + 1] << 8) | (msg->data[pos] << 0); - pos += 2; - break; - default: - sendData = (msg->data[pos + 2] << 16) | - (msg->data[pos + 1] << 8) | - (msg->data[pos] << 0); - pos += 3; - break; - } - MIDI_NotifyClient(msg->devID, MIM_DATA, sendData, currentTime); - } - midi_lock( FALSE ); - break; - default: - CFRunLoopStop(CFRunLoopGetCurrent()); - break; - } - return NULL; -} - -static DWORD WINAPI MIDIIn_MessageThread(LPVOID p) -{ - CFMessagePortRef local; - CFRunLoopSourceRef source; - Boolean info; - - local = CFMessagePortCreateLocal(kCFAllocatorDefault, MIDIInThreadPortName, &MIDIIn_MessageHandler, NULL, &info); - - source = CFMessagePortCreateRunLoopSource(kCFAllocatorDefault, local, 0); - CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopDefaultMode); - - CFRunLoopRun(); - - CFRunLoopSourceInvalidate(source); - CFRelease(source); - CFRelease(local); - CFRelease(MIDIInThreadPortName); - MIDIInThreadPortName = NULL; - - return 0; -} - /************************************************************************** * modMessage */ diff --git a/dlls/winecoreaudio.drv/unixlib.h b/dlls/winecoreaudio.drv/unixlib.h index 67fcc35ce4c..d44a7a013e8 100644 --- a/dlls/winecoreaudio.drv/unixlib.h +++ b/dlls/winecoreaudio.drv/unixlib.h @@ -187,8 +187,6 @@ struct midi_init_params { DWORD *err; UINT num_srcs; - void *srcs; - void *midi_in_port; }; struct notify_context @@ -228,6 +226,7 @@ struct midi_in_message_params struct midi_notify_wait_params { + struct notify_context *notify; BOOL *quit; }; @@ -258,8 +257,6 @@ enum unix_funcs unix_midi_out_message, unix_midi_in_message, unix_midi_notify_wait, - - unix_midi_in_lock, /* temporary */ }; NTSTATUS midi_init( void * ) DECLSPEC_HIDDEN; @@ -267,7 +264,6 @@ NTSTATUS midi_release( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_out_message( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_in_message( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_notify_wait( void * ) DECLSPEC_HIDDEN; -NTSTATUS midi_in_lock( void * ) DECLSPEC_HIDDEN; extern unixlib_handle_t coreaudio_handle; -- 2.23.0

2 1

[PATCH 2/6] winecoreaudio: Introduce a notification thread.
by Huw Davies Dec. 1, 2021

Dec. 1, 2021

Currently the thread just blocks until told to quit by midi_release. Eventually, this thread will dispatch the MIM_DATA and MIM_LONGDATA notifications and essentially replace the existing RunLoop-based mechanism. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winecoreaudio.drv/coreaudio.c | 1 + dlls/winecoreaudio.drv/coremidi.c | 42 ++++++++++++++++++++++++++++++ dlls/winecoreaudio.drv/midi.c | 16 ++++++++++++ dlls/winecoreaudio.drv/unixlib.h | 7 +++++ 4 files changed, 66 insertions(+) diff --git a/dlls/winecoreaudio.drv/coreaudio.c b/dlls/winecoreaudio.drv/coreaudio.c index 420021a53ea..1efcfdba3f4 100644 --- a/dlls/winecoreaudio.drv/coreaudio.c +++ b/dlls/winecoreaudio.drv/coreaudio.c @@ -1633,6 +1633,7 @@ unixlib_entry_t __wine_unix_call_funcs[] = midi_release, midi_out_message, midi_in_message, + midi_notify_wait, midi_in_lock, /* temporary */ }; diff --git a/dlls/winecoreaudio.drv/coremidi.c b/dlls/winecoreaudio.drv/coremidi.c index 2e92d9ac2cb..bb8cb23f83b 100644 --- a/dlls/winecoreaudio.drv/coremidi.c +++ b/dlls/winecoreaudio.drv/coremidi.c @@ -116,6 +116,13 @@ static CFStringRef midi_in_thread_port_name; static pthread_mutex_t midi_in_mutex = PTHREAD_MUTEX_INITIALIZER; +#define NOTIFY_BUFFER_SIZE 64 + 1 /* + 1 for the sentinel */ +static pthread_mutex_t notify_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t notify_cond = PTHREAD_COND_INITIALIZER; +static BOOL notify_quit; +static struct notify_context notify_buffer[NOTIFY_BUFFER_SIZE]; +static struct notify_context *notify_read, *notify_write; + NTSTATUS midi_in_lock(void *args) { BOOL lock = !!args; @@ -139,6 +146,17 @@ static void set_in_notify(struct notify_context *notify, struct midi_src *src, W notify->instance = src->midiDesc.dwInstance; } +static void notify_post(struct notify_context *notify) +{ + pthread_mutex_lock(&notify_mutex); + + if (notify) FIXME("Not yet handled\n"); + else notify_quit = TRUE; + pthread_cond_signal(&notify_cond); + + pthread_mutex_unlock(&notify_mutex); +} + /* * CoreMIDI IO threaded callback, * we can't call Wine debug channels, critical section or anything using NtCurrentTeb here. @@ -183,6 +201,11 @@ NTSTATUS midi_init(void *args) OSStatus sc; UINT i; + pthread_mutex_lock(&notify_mutex); + notify_quit = FALSE; + notify_read = notify_write = notify_buffer; + pthread_mutex_unlock(&notify_mutex); + sc = MIDIClientCreate(name, NULL /* FIXME use notify proc */, NULL, &midi_client); CFRelease(name); if (sc) @@ -300,6 +323,9 @@ NTSTATUS midi_release(void *args) msg_port = CFMessagePortCreateRemote(kCFAllocatorDefault, midi_in_thread_port_name); CFMessagePortSendRequest(msg_port, 1, NULL, 0.0, 0.0, NULL, NULL); CFRelease(msg_port); + + /* stop the notify_wait thread */ + notify_post(NULL); } if (midi_client) MIDIClientDispose(midi_client); /* MIDIClientDispose will close all ports */ @@ -1081,3 +1107,19 @@ NTSTATUS midi_in_message(void *args) return STATUS_SUCCESS; } + +NTSTATUS midi_notify_wait(void *args) +{ + struct midi_notify_wait_params *params = args; + + pthread_mutex_lock(&notify_mutex); + + while (!notify_quit) + pthread_cond_wait(&notify_cond, &notify_mutex); + + *params->quit = notify_quit; + + pthread_mutex_unlock(&notify_mutex); + + return STATUS_SUCCESS; +} diff --git a/dlls/winecoreaudio.drv/midi.c b/dlls/winecoreaudio.drv/midi.c index b3adb09886d..e9cdb2a8ec4 100644 --- a/dlls/winecoreaudio.drv/midi.c +++ b/dlls/winecoreaudio.drv/midi.c @@ -78,6 +78,21 @@ static void notify_client(struct notify_context *notify) notify->instance, notify->param_1, notify->param_2); } +static DWORD WINAPI notify_thread(void *p) +{ + struct midi_notify_wait_params params; + BOOL quit; + + params.quit = &quit; + + while (1) + { + UNIX_CALL(midi_notify_wait, &params); + if (quit) break; + } + return 0; +} + static LONG CoreAudio_MIDIInit(void) { struct midi_init_params params; @@ -100,6 +115,7 @@ static LONG CoreAudio_MIDIInit(void) { MIDIInThreadPortName = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("MIDIInThreadPortName.%u"), getpid()); CloseHandle( CreateThread(NULL, 0, MIDIIn_MessageThread, NULL, 0, NULL)); + CloseHandle(CreateThread(NULL, 0, notify_thread, NULL, 0, NULL)); } return err; } diff --git a/dlls/winecoreaudio.drv/unixlib.h b/dlls/winecoreaudio.drv/unixlib.h index 2f0464ad322..67fcc35ce4c 100644 --- a/dlls/winecoreaudio.drv/unixlib.h +++ b/dlls/winecoreaudio.drv/unixlib.h @@ -226,6 +226,11 @@ struct midi_in_message_params struct notify_context *notify; }; +struct midi_notify_wait_params +{ + BOOL *quit; +}; + enum unix_funcs { unix_get_endpoint_ids, @@ -252,6 +257,7 @@ enum unix_funcs unix_midi_release, unix_midi_out_message, unix_midi_in_message, + unix_midi_notify_wait, unix_midi_in_lock, /* temporary */ }; @@ -260,6 +266,7 @@ NTSTATUS midi_init( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_release( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_out_message( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_in_message( void * ) DECLSPEC_HIDDEN; +NTSTATUS midi_notify_wait( void * ) DECLSPEC_HIDDEN; NTSTATUS midi_in_lock( void * ) DECLSPEC_HIDDEN; extern unixlib_handle_t coreaudio_handle; -- 2.23.0

2 1

[PATCH 1/6] winecoreaudio: Introduce a helper to retrieve the time.
by Huw Davies Dec. 1, 2021

Dec. 1, 2021

The motivation is that this will need to be called from a non-Win32 thread and so shouldn't use the Win32 API. An added benefit is that it will eliminate the 16ms jitter associated with GetTickCount(). The instance of the helper on the user-side is temporary. Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/winecoreaudio.drv/coremidi.c | 12 ++++++++++-- dlls/winecoreaudio.drv/midi.c | 13 +++++++++++-- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/dlls/winecoreaudio.drv/coremidi.c b/dlls/winecoreaudio.drv/coremidi.c index 9dc9f452c29..2e92d9ac2cb 100644 --- a/dlls/winecoreaudio.drv/coremidi.c +++ b/dlls/winecoreaudio.drv/coremidi.c @@ -143,6 +143,14 @@ static void set_in_notify(struct notify_context *notify, struct midi_src *src, W * CoreMIDI IO threaded callback, * we can't call Wine debug channels, critical section or anything using NtCurrentTeb here. */ +static uint64_t get_time_ms(void) +{ + static mach_timebase_info_data_t timebase; + + if (!timebase.denom) mach_timebase_info(&timebase); + return mach_absolute_time() / 1000000 * timebase.numer / timebase.denom; +} + static void midi_in_read_proc(const MIDIPacketList *pktlist, void *refCon, void *connRefCon) { CFMessagePortRef msg_port = CFMessagePortCreateRemote(kCFAllocatorDefault, midi_in_thread_port_name); @@ -917,7 +925,7 @@ static DWORD midi_in_start(WORD dev_id) return MMSYSERR_BADDEVICEID; } srcs[dev_id].state = 1; - srcs[dev_id].startTime = NtGetTickCount(); + srcs[dev_id].startTime = get_time_ms(); return MMSYSERR_NOERROR; } @@ -936,7 +944,7 @@ static DWORD midi_in_stop(WORD dev_id) static DWORD midi_in_reset(WORD dev_id, struct notify_context *notify) { - DWORD cur_time = NtGetTickCount(); + DWORD cur_time = get_time_ms(); DWORD err = MMSYSERR_NOERROR; struct midi_src *src; MIDIHDR *hdr; diff --git a/dlls/winecoreaudio.drv/midi.c b/dlls/winecoreaudio.drv/midi.c index dcb9a7e1b69..b3adb09886d 100644 --- a/dlls/winecoreaudio.drv/midi.c +++ b/dlls/winecoreaudio.drv/midi.c @@ -45,6 +45,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(midi); +#include <mach/mach_time.h> #include <CoreAudio/CoreAudio.h> #define WINE_DEFINITIONS @@ -61,6 +62,14 @@ static MIDIPortRef MIDIInPort = NULL; MIDISource *sources; +static uint64_t get_time_ms(void) +{ + static mach_timebase_info_data_t timebase; + + if (!timebase.denom) mach_timebase_info(&timebase); + return mach_absolute_time() / 1000000 * timebase.numer / timebase.denom; +} + static void notify_client(struct notify_context *notify) { TRACE("dev_id=%d msg=%d param1=%04lX param2=%04lX\n", notify->dev_id, notify->msg, notify->param_1, notify->param_2); @@ -183,7 +192,7 @@ static CFDataRef MIDIIn_MessageHandler(CFMessagePortRef local, SInt32 msgid, CFD } midi_lock( TRUE ); - currentTime = GetTickCount() - src->startTime; + currentTime = get_time_ms() - src->startTime; while (len) { LPMIDIHDR lpMidiHdr = src->lpQueueHdr; @@ -218,7 +227,7 @@ static CFDataRef MIDIIn_MessageHandler(CFMessagePortRef local, SInt32 msgid, CFD } midi_lock( TRUE ); - currentTime = GetTickCount() - src->startTime; + currentTime = get_time_ms() - src->startTime; while (pos < msg->length) { -- 2.23.0

2 1

[PATCH v11 01/10] mshtml: Stringify attribute values in setAttribute using string hints in IE10+.
by Gabriel Ivăncescu Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/mshtml/dispex.c | 2 +- dlls/mshtml/htmlelem.c | 36 ++++++++++++++++++++++++++++++- dlls/mshtml/mshtml_private.h | 1 + dlls/mshtml/tests/documentmode.js | 1 - 4 files changed, 37 insertions(+), 3 deletions(-) diff --git a/dlls/mshtml/dispex.c b/dlls/mshtml/dispex.c index 4605fda..9f56a56 100644 --- a/dlls/mshtml/dispex.c +++ b/dlls/mshtml/dispex.c @@ -1043,7 +1043,7 @@ static HRESULT get_builtin_id(DispatchEx *This, BSTR name, DWORD grfdex, DISPID return DISP_E_UNKNOWNNAME; } -static HRESULT change_type(VARIANT *dst, VARIANT *src, VARTYPE vt, IServiceProvider *caller) +HRESULT change_type(VARIANT *dst, VARIANT *src, VARTYPE vt, IServiceProvider *caller) { V_VT(dst) = VT_EMPTY; diff --git a/dlls/mshtml/htmlelem.c b/dlls/mshtml/htmlelem.c index d54f729..3f7c60b 100644 --- a/dlls/mshtml/htmlelem.c +++ b/dlls/mshtml/htmlelem.c @@ -6585,8 +6585,42 @@ static IHTMLEventObj *HTMLElement_set_current_event(DispatchEx *dispex, IHTMLEve return default_set_current_event(This->node.doc->window, event); } +static HRESULT IHTMLElement6_setAttribute_hook(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *dp, + VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller) +{ + VARIANT args[2]; + HRESULT hres; + DISPPARAMS new_dp = { args, NULL, 2, 0 }; + + if(!(flags & DISPATCH_METHOD) || dp->cArgs < 2 || dp->cNamedArgs) + return S_FALSE; + + switch(V_VT(&dp->rgvarg[dp->cArgs - 2])) { + case VT_EMPTY: + case VT_BSTR: + case VT_NULL: + return S_FALSE; + default: + break; + } + + hres = change_type(&args[0], &dp->rgvarg[dp->cArgs - 2], VT_BSTR, caller); + if(FAILED(hres)) + return hres; + args[1] = dp->rgvarg[dp->cArgs - 1]; + + hres = IDispatchEx_InvokeEx(&dispex->IDispatchEx_iface, DISPID_IHTMLELEMENT6_IE9_SETATTRIBUTE, + lcid, flags, &new_dp, res, ei, caller); + VariantClear(&args[0]); + return hres; +} + void HTMLElement_init_dispex_info(dispex_data_t *info, compat_mode_t mode) { + static const dispex_hook_t elem6_ie10_hooks[] = { + {DISPID_IHTMLELEMENT6_IE9_SETATTRIBUTE, IHTMLElement6_setAttribute_hook}, + {DISPID_UNKNOWN} + }; static const dispex_hook_t elem2_ie11_hooks[] = { {DISPID_IHTMLELEMENT2_DOSCROLL, NULL}, {DISPID_IHTMLELEMENT2_READYSTATE, NULL}, @@ -6601,7 +6635,7 @@ void HTMLElement_init_dispex_info(dispex_data_t *info, compat_mode_t mode) dispex_info_add_interface(info, IElementSelector_tid, NULL); if(mode >= COMPAT_MODE_IE9) { - dispex_info_add_interface(info, IHTMLElement6_tid, NULL); + dispex_info_add_interface(info, IHTMLElement6_tid, mode >= COMPAT_MODE_IE10 ? elem6_ie10_hooks : NULL); dispex_info_add_interface(info, IElementTraversal_tid, NULL); } diff --git a/dlls/mshtml/mshtml_private.h b/dlls/mshtml/mshtml_private.h index 5cf53bb..6978ed7 100644 --- a/dlls/mshtml/mshtml_private.h +++ b/dlls/mshtml/mshtml_private.h @@ -384,6 +384,7 @@ extern void (__cdecl *note_cc_edge)(nsISupports*,const char*,nsCycleCollectionTr void init_dispatch(DispatchEx*,IUnknown*,dispex_static_data_t*,compat_mode_t) DECLSPEC_HIDDEN; void release_dispex(DispatchEx*) DECLSPEC_HIDDEN; BOOL dispex_query_interface(DispatchEx*,REFIID,void**) DECLSPEC_HIDDEN; +HRESULT change_type(VARIANT*,VARIANT*,VARTYPE,IServiceProvider*) DECLSPEC_HIDDEN; HRESULT dispex_get_dprop_ref(DispatchEx*,const WCHAR*,BOOL,VARIANT**) DECLSPEC_HIDDEN; HRESULT get_dispids(tid_t,DWORD*,DISPID**) DECLSPEC_HIDDEN; HRESULT remove_attribute(DispatchEx*,DISPID,VARIANT_BOOL*) DECLSPEC_HIDDEN; diff --git a/dlls/mshtml/tests/documentmode.js b/dlls/mshtml/tests/documentmode.js index 08fcde4..c2fd8bd 100644 --- a/dlls/mshtml/tests/documentmode.js +++ b/dlls/mshtml/tests/documentmode.js @@ -1136,7 +1136,6 @@ sync_test("elem_attr", function() { ok(r === (v < 8 ? arr : (v < 9 ? "arrval" : null)), "testattr with custom valueOf = " + r); elem.setAttribute("testattr", arr); r = elem.getAttribute("testattr"); - todo_wine_if(v >= 10). ok(r === (v < 8 ? arr : (v < 10 ? "arrval" : "42")), "testattr after setAttribute with custom valueOf = " + r); ok(elem.testattr === arr, "elem.testattr after setAttribute with custom valueOf = " + elem.testattr); r = elem.removeAttribute("testattr"); -- 2.31.1

3 21

[PATCH v4 2/2] scrrun: Implement folder_CreateTextFile.
by Robert Wilhelm Dec. 1, 2021

Dec. 1, 2021

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=51971 Signed-off-by: Robert Wilhelm <robert.wilhelm(a)gmx.net> --- Supersedes 220458. v4: tests: Use ReadFile to check contents and minor cleanups as recommended by Nikolay. --- dlls/scrrun/filesystem.c | 16 ++++++- dlls/scrrun/tests/filesystem.c | 81 ++++++++++++++++++++++++++++++++++ 2 files changed, 95 insertions(+), 2 deletions(-) diff --git a/dlls/scrrun/filesystem.c b/dlls/scrrun/filesystem.c index 359d86bb8fd..7b0b2e110a6 100644 --- a/dlls/scrrun/filesystem.c +++ b/dlls/scrrun/filesystem.c @@ -2518,9 +2518,21 @@ static HRESULT WINAPI folder_get_Files(IFolder *iface, IFileCollection **files) static HRESULT WINAPI folder_CreateTextFile(IFolder *iface, BSTR filename, VARIANT_BOOL overwrite, VARIANT_BOOL unicode, ITextStream **stream) { + DWORD disposition; + BSTR path; + HRESULT hres; + struct folder *This = impl_from_IFolder(iface); - FIXME("(%p)->(%s %x %x %p): stub\n", This, debugstr_w(filename), overwrite, unicode, stream); - return E_NOTIMPL; + + TRACE("%p %s %d %d %p\n", iface, debugstr_w(filename), overwrite, unicode, stream); + + hres = build_path(This->path, filename, &path); + if (FAILED(hres)) return hres; + + disposition = overwrite == VARIANT_TRUE ? CREATE_ALWAYS : CREATE_NEW; + hres = create_textstream(path, disposition, ForWriting, unicode ? TristateTrue : TristateFalse, stream); + SysFreeString(path); + return hres; } static const IFolderVtbl foldervtbl = { diff --git a/dlls/scrrun/tests/filesystem.c b/dlls/scrrun/tests/filesystem.c index 5c55965ce88..91729bb047f 100644 --- a/dlls/scrrun/tests/filesystem.c +++ b/dlls/scrrun/tests/filesystem.c @@ -1535,6 +1535,86 @@ static void test_CreateTextFile(void) SysFreeString(nameW); } +static void test_FolderCreateTextFile(void) +{ + WCHAR pathW[MAX_PATH], dirW[MAX_PATH], buffW[10], buff2W[10]; + ITextStream *stream; + BSTR nameW, str; + HANDLE file; + IFolder *folder; + HRESULT hr; + BOOL ret; + DWORD r; + + get_temp_filepath(testfileW, pathW, dirW); + nameW = SysAllocString(L"foo.txt"); + lstrcpyW(pathW, dirW); + lstrcatW(pathW, nameW); + + ret = CreateDirectoryW(dirW, NULL); + ok(ret, "got %d, %d\n", ret, GetLastError()); + + str = SysAllocString(dirW); + hr = IFileSystem3_GetFolder(fs3, str, &folder); + ok(ret, "got %d, %d\n", ret, GetLastError()); + SysFreeString(str); + + hr = IFolder_CreateTextFile(folder, nameW, VARIANT_FALSE, VARIANT_FALSE, &stream); + ok(hr == S_OK, "got 0x%08x\n", hr); + + test_provideclassinfo(stream, &CLSID_TextStream); + + hr = ITextStream_Read(stream, 1, &str); + ok(hr == CTL_E_BADFILEMODE, "got 0x%08x\n", hr); + + hr = ITextStream_Close(stream); + ok(hr == S_OK, "got 0x%08x\n", hr); + + hr = ITextStream_Read(stream, 1, &str); + ok(hr == CTL_E_BADFILEMODE || hr == E_VAR_NOT_SET, "got 0x%08x\n", hr); + + hr = ITextStream_Close(stream); + ok(hr == S_FALSE || hr == E_VAR_NOT_SET, "got 0x%08x\n", hr); + + ITextStream_Release(stream); + + /* check it's created */ + file = CreateFileW(pathW, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + ok(file != INVALID_HANDLE_VALUE, "got %p\n", file); + CloseHandle(file); + + /* try to create again with no-overwrite mode */ + hr = IFolder_CreateTextFile(folder, nameW, VARIANT_FALSE, VARIANT_FALSE, &stream); + ok(hr == CTL_E_FILEALREADYEXISTS, "got 0x%08x\n", hr); + + /* now overwrite */ + hr = IFolder_CreateTextFile(folder, nameW, VARIANT_TRUE, VARIANT_FALSE, &stream); + ok(hr == S_OK, "got 0x%08x\n", hr); + ITextStream_Release(stream); + + /* overwrite in Unicode mode, check for BOM */ + hr = IFolder_CreateTextFile(folder, nameW, VARIANT_TRUE, VARIANT_TRUE, &stream); + ok(hr == S_OK, "got 0x%08x\n", hr); + ITextStream_Release(stream); + + /* check contents */ + file = CreateFileW(pathW, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + ok(file != INVALID_HANDLE_VALUE, "got %p\n", file); + r = 0; + ret = ReadFile(file, buffW, sizeof(buffW), &r, NULL); + ok(ret && r==2, "read %d, got %d, %d\n", r, ret, GetLastError()); + buffW[r/sizeof(WCHAR)] = 0; + + buff2W[0] = 0xfeff; + buff2W[1] = 0; + ok(!lstrcmpW(buff2W, buffW), "got %s, expected %s\n", wine_dbgstr_w(buffW), wine_dbgstr_w(buff2W)); + CloseHandle(file); + + DeleteFileW(pathW); + RemoveDirectoryW(dirW); + SysFreeString(nameW); +} + static void test_WriteLine(void) { WCHAR pathW[MAX_PATH], dirW[MAX_PATH]; @@ -2516,6 +2596,7 @@ START_TEST(filesystem) test_FileCollection(); test_DriveCollection(); test_CreateTextFile(); + test_FolderCreateTextFile(); test_WriteLine(); test_ReadAll(); test_Read(); -- 2.31.1

2 1

[PATCH v4 1/2] scrrun: Extract code to new helper function build_path.
by Robert Wilhelm Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Robert Wilhelm <robert.wilhelm(a)gmx.net> --- Supersedes 220459. v4: Fix issues as pointed out by Nikolay: Leave EPOINTER check in original function and do not specify calling convention. --- dlls/scrrun/filesystem.c | 103 ++++++++++++++++++++------------------- 1 file changed, 54 insertions(+), 49 deletions(-) diff --git a/dlls/scrrun/filesystem.c b/dlls/scrrun/filesystem.c index 68ef1786af9..359d86bb8fd 100644 --- a/dlls/scrrun/filesystem.c +++ b/dlls/scrrun/filesystem.c @@ -223,6 +223,59 @@ static BSTR get_full_path(BSTR path, const WIN32_FIND_DATAW *data) return SysAllocString(buffW); } +static HRESULT build_path( BSTR Path, BSTR Name, BSTR *Result) +{ + BSTR ret; + + if (Path && Name) + { + int path_len = SysStringLen(Path), name_len = SysStringLen(Name); + + /* if both parts have backslashes strip one from Path */ + if (Path[path_len-1] == '\\' && Name[0] == '\\') + { + path_len -= 1; + + ret = SysAllocStringLen(NULL, path_len + name_len); + if (ret) + { + lstrcpyW(ret, Path); + ret[path_len] = 0; + lstrcatW(ret, Name); + } + } + else if (Path[path_len-1] != '\\' && Name[0] != '\\') + { + ret = SysAllocStringLen(NULL, path_len + name_len + 1); + if (ret) + { + lstrcpyW(ret, Path); + if (Path[path_len-1] != ':') + wcscat(ret, L"\\"); + lstrcatW(ret, Name); + } + } + else + { + ret = SysAllocStringLen(NULL, path_len + name_len); + if (ret) + { + lstrcpyW(ret, Path); + lstrcatW(ret, Name); + } + } + } + else if (Path || Name) + ret = SysAllocString(Path ? Path : Name); + else + ret = SysAllocStringLen(NULL, 0); + + if (!ret) return E_OUTOFMEMORY; + *Result = ret; + + return S_OK; +} + static BOOL textstream_check_iomode(struct textstream *This, enum iotype type) { if (type == IORead) @@ -3034,59 +3087,11 @@ static HRESULT WINAPI filesys_get_Drives(IFileSystem3 *iface, IDriveCollection * static HRESULT WINAPI filesys_BuildPath(IFileSystem3 *iface, BSTR Path, BSTR Name, BSTR *Result) { - BSTR ret; - TRACE("%p %s %s %p\n", iface, debugstr_w(Path), debugstr_w(Name), Result); if (!Result) return E_POINTER; - if (Path && Name) - { - int path_len = SysStringLen(Path), name_len = SysStringLen(Name); - - /* if both parts have backslashes strip one from Path */ - if (Path[path_len-1] == '\\' && Name[0] == '\\') - { - path_len -= 1; - - ret = SysAllocStringLen(NULL, path_len + name_len); - if (ret) - { - lstrcpyW(ret, Path); - ret[path_len] = 0; - lstrcatW(ret, Name); - } - } - else if (Path[path_len-1] != '\\' && Name[0] != '\\') - { - ret = SysAllocStringLen(NULL, path_len + name_len + 1); - if (ret) - { - lstrcpyW(ret, Path); - if (Path[path_len-1] != ':') - wcscat(ret, L"\\"); - lstrcatW(ret, Name); - } - } - else - { - ret = SysAllocStringLen(NULL, path_len + name_len); - if (ret) - { - lstrcpyW(ret, Path); - lstrcatW(ret, Name); - } - } - } - else if (Path || Name) - ret = SysAllocString(Path ? Path : Name); - else - ret = SysAllocStringLen(NULL, 0); - - if (!ret) return E_OUTOFMEMORY; - *Result = ret; - - return S_OK; + return build_path(Path, Name, Result); } static HRESULT WINAPI filesys_GetDriveName(IFileSystem3 *iface, BSTR path, BSTR *drive) -- 2.31.1

2 1

[PATCH v2 1/6] wined3d: Always set GL_PIXEL_UNPACK_BUFFER binding in wined3d_texture_gl_allocate_mutable_storage().
by Zebediah Figura Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/wined3d/texture.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index d4c7082912b..f0ef42065d3 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -930,6 +930,9 @@ static void wined3d_texture_gl_allocate_mutable_storage(struct wined3d_texture_g else layer_count = texture_gl->t.layer_count; + GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0)); + checkGLcall("glBindBuffer"); + for (layer = 0; layer < layer_count; ++layer) { target = wined3d_texture_gl_get_sub_resource_target(texture_gl, layer * level_count); -- 2.32.0

2 11

[PATCH vkd3d v8 1/4] vkd3d-shader/hlsl: Perform a copy propagation pass.
by Giovanni Mascellani Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Giovanni Mascellani <gmascellani(a)codeweavers.com> Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- v8: Address comments in https://source.winehq.org/patches/data/219953 libs/vkd3d-shader/hlsl.c | 21 ++- libs/vkd3d-shader/hlsl.h | 1 + libs/vkd3d-shader/hlsl_codegen.c | 222 ++++++++++++++++++++++++++++++- 3 files changed, 238 insertions(+), 6 deletions(-) diff --git a/libs/vkd3d-shader/hlsl.c b/libs/vkd3d-shader/hlsl.c index 1eee4278..f59e7403 100644 --- a/libs/vkd3d-shader/hlsl.c +++ b/libs/vkd3d-shader/hlsl.c @@ -1097,6 +1097,20 @@ const char *debug_hlsl_writemask(unsigned int writemask) return vkd3d_dbg_sprintf(".%s", string); } +const char *debug_hlsl_swizzle(unsigned int swizzle, unsigned int count) +{ + static const char components[] = {'x', 'y', 'z', 'w'}; + char string[5]; + unsigned int i = 0; + + for (i = 0; i < count; ++i) + { + string[i] = components[(swizzle >> (2 * i)) % 4]; + } + string[count] = '\0'; + return vkd3d_dbg_sprintf(".%s", string); +} + static void dump_ir_constant(struct vkd3d_string_buffer *buffer, const struct hlsl_ir_constant *constant) { struct hlsl_type *type = constant->node.data_type; @@ -1277,18 +1291,15 @@ static void dump_ir_swizzle(struct vkd3d_string_buffer *buffer, const struct hls unsigned int i; dump_src(buffer, &swizzle->val); - vkd3d_string_buffer_printf(buffer, "."); if (swizzle->val.node->data_type->dimy > 1) { + vkd3d_string_buffer_printf(buffer, "."); for (i = 0; i < swizzle->node.data_type->dimx; ++i) vkd3d_string_buffer_printf(buffer, "_m%u%u", (swizzle->swizzle >> i * 8) & 0xf, (swizzle->swizzle >> (i * 8 + 4)) & 0xf); } else { - static const char c[] = {'x', 'y', 'z', 'w'}; - - for (i = 0; i < swizzle->node.data_type->dimx; ++i) - vkd3d_string_buffer_printf(buffer, "%c", c[(swizzle->swizzle >> i * 2) & 0x3]); + vkd3d_string_buffer_printf(buffer, "%s", debug_hlsl_swizzle(swizzle->swizzle, swizzle->node.data_type->dimx)); } } diff --git a/libs/vkd3d-shader/hlsl.h b/libs/vkd3d-shader/hlsl.h index 365ef980..bca59b65 100644 --- a/libs/vkd3d-shader/hlsl.h +++ b/libs/vkd3d-shader/hlsl.h @@ -666,6 +666,7 @@ static inline struct hlsl_type *hlsl_get_numeric_type(const struct hlsl_ctx *ctx const char *debug_hlsl_expr_op(enum hlsl_ir_expr_op op); const char *debug_hlsl_type(struct hlsl_ctx *ctx, const struct hlsl_type *type); const char *debug_hlsl_writemask(unsigned int writemask); +const char *debug_hlsl_swizzle(unsigned int swizzle, unsigned int count); struct vkd3d_string_buffer *hlsl_type_to_string(struct hlsl_ctx *ctx, const struct hlsl_type *type); struct vkd3d_string_buffer *hlsl_modifiers_to_string(struct hlsl_ctx *ctx, unsigned int modifiers); diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c index 4a7e003f..4e1397f6 100644 --- a/libs/vkd3d-shader/hlsl_codegen.c +++ b/libs/vkd3d-shader/hlsl_codegen.c @@ -237,6 +237,221 @@ static void replace_node(struct hlsl_ir_node *old, struct hlsl_ir_node *new) hlsl_free_instr(old); } +struct copy_propagation_value +{ + struct hlsl_ir_node *node; + unsigned int component; +}; + +struct copy_propagation_var_def +{ + struct rb_entry entry; + struct hlsl_ir_var *var; + struct copy_propagation_value values[]; +}; + +struct copy_propagation_state +{ + struct rb_tree variables; +}; + +static int copy_propagation_variable_compare(const void *key, const struct rb_entry *entry) +{ + struct copy_propagation_var_def *variable = RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + uintptr_t key_int = (uintptr_t)key, entry_int = (uintptr_t)variable->var; + + return (key_int > entry_int) - (key_int < entry_int); +} + +static void copy_propagation_variable_destroy(struct rb_entry *entry, void *context) +{ + struct copy_propagation_var_def *variable = RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + + vkd3d_free(variable); +} + +static struct copy_propagation_var_def *copy_propagation_get_variable(struct copy_propagation_state *state, + struct hlsl_ir_var *var) +{ + struct rb_entry *entry = rb_get(&state->variables, var); + + if (entry) + return RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + else + return NULL; +} + +static struct copy_propagation_var_def *copy_propagation_create_variable(struct hlsl_ctx *ctx, + struct copy_propagation_state *state, struct hlsl_ir_var *var) +{ + struct rb_entry *entry = rb_get(&state->variables, var); + struct copy_propagation_var_def *variable; + int res; + + if (entry) + return RB_ENTRY_VALUE(entry, struct copy_propagation_var_def, entry); + + variable = hlsl_alloc(ctx, offsetof(struct copy_propagation_var_def, values[var->data_type->reg_size])); + if (!variable) + return NULL; + + variable->var = var; + + res = rb_put(&state->variables, var, &variable->entry); + assert(!res); + + return variable; +} + +static void copy_propagation_invalidate_whole_variable(struct copy_propagation_var_def *variable) +{ + TRACE("Invalidate variable %s.\n", variable->var->name); + memset(variable->values, 0, sizeof(*variable->values) * variable->var->data_type->reg_size); +} + +static void copy_propagation_set_value(struct copy_propagation_var_def *variable, unsigned int offset, + unsigned char writemask, struct hlsl_ir_node *node) +{ + unsigned int i, j = 0; + + for (i = 0; i < 4; ++i) + { + if (writemask & (1u << i)) + { + TRACE("Variable %s[%u] is written by instruction %p%s.\n", + variable->var->name, offset + i, node, debug_hlsl_writemask(1u << i)); + variable->values[offset + i].node = node; + variable->values[offset + i].component = j++; + } + } +} + +static struct hlsl_ir_node *copy_propagation_compute_replacement(struct copy_propagation_var_def *variable, + unsigned int offset, unsigned int count, unsigned int *swizzle) +{ + struct hlsl_ir_node *node = NULL; + unsigned int i; + + assert(offset + count <= variable->var->data_type->reg_size); + + *swizzle = 0; + + for (i = 0; i < count; ++i) + { + if (!node) + node = variable->values[offset + i].node; + else if (node != variable->values[offset + i].node) + return NULL; + *swizzle |= variable->values[offset + i].component << (2 * i); + } + + return node; +} + +static bool copy_propagation_analyze_load(struct hlsl_ctx *ctx, struct hlsl_ir_load *load, + struct copy_propagation_state *state) +{ + struct hlsl_ir_node *node = &load->node, *new_node; + struct copy_propagation_var_def *variable; + struct hlsl_type *type = node->data_type; + struct hlsl_ir_swizzle *swizzle_node; + struct hlsl_deref *src = &load->src; + struct hlsl_ir_var *var = src->var; + unsigned int offset, swizzle; + + if (type->type != HLSL_CLASS_SCALAR && type->type != HLSL_CLASS_VECTOR) + return false; + + if (!hlsl_offset_from_deref(src, &offset)) + return false; + + variable = copy_propagation_get_variable(state, var); + if (!variable) + return false; + + new_node = copy_propagation_compute_replacement(variable, offset, type->dimx, &swizzle); + + TRACE("Load from %s[%d-%d] reconstructed as instruction %p%s.\n", + var->name, offset, offset + type->dimx, new_node, debug_hlsl_swizzle(swizzle, 4)); + + if (!new_node) + return false; + + if (!(swizzle_node = hlsl_new_swizzle(ctx, swizzle, type->dimx, new_node, &node->loc))) + return false; + list_add_before(&node->entry, &swizzle_node->node.entry); + + replace_node(node, &swizzle_node->node); + + return true; +} + +static void copy_propagation_record_store(struct hlsl_ctx *ctx, struct hlsl_ir_store *store, + struct copy_propagation_state *state) +{ + struct copy_propagation_var_def *variable; + struct hlsl_deref *lhs = &store->lhs; + struct hlsl_ir_var *var = lhs->var; + unsigned int offset; + + variable = copy_propagation_create_variable(ctx, state, var); + if (!variable) + return; + + if (hlsl_offset_from_deref(lhs, &offset)) + copy_propagation_set_value(variable, offset, store->writemask, store->rhs.node); + else + copy_propagation_invalidate_whole_variable(variable); +} + +static bool copy_propagation_transform_block(struct hlsl_ctx *ctx, struct hlsl_block *block, + struct copy_propagation_state *state) +{ + struct hlsl_ir_node *instr, *next; + bool progress = false; + + LIST_FOR_EACH_ENTRY_SAFE(instr, next, &block->instrs, struct hlsl_ir_node, entry) + { + switch (instr->type) + { + case HLSL_IR_LOAD: + progress |= copy_propagation_analyze_load(ctx, hlsl_ir_load(instr), state); + break; + + case HLSL_IR_STORE: + copy_propagation_record_store(ctx, hlsl_ir_store(instr), state); + break; + + case HLSL_IR_IF: + FIXME("Copy propagation doesn't support conditionals yet, leaving.\n"); + return progress; + + case HLSL_IR_LOOP: + FIXME("Copy propagation doesn't support loops yet, leaving.\n"); + return progress; + + default: + break; + } + } + + return progress; +} + +static bool copy_propagation_execute(struct hlsl_ctx *ctx, struct hlsl_block *block) +{ + struct copy_propagation_state state; + bool progress; + + rb_init(&state.variables, copy_propagation_variable_compare); + + progress = copy_propagation_transform_block(ctx, block, &state); + + rb_destroy(&state.variables, copy_propagation_variable_destroy, NULL); + + return progress; +} + static bool is_vec1(const struct hlsl_type *type) { return (type->type == HLSL_CLASS_SCALAR) || (type->type == HLSL_CLASS_VECTOR && type->dimx == 1); @@ -1390,7 +1605,12 @@ int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun progress |= transform_ir(ctx, split_struct_copies, body, NULL); } while (progress); - while (transform_ir(ctx, fold_constants, body, NULL)); + do + { + progress = transform_ir(ctx, fold_constants, body, NULL); + progress |= copy_propagation_execute(ctx, body); + } + while (progress); transform_ir(ctx, remove_trivial_swizzles, body, NULL); if (ctx->profile->major_version < 4) -- 2.33.1

3 6

[PATCH] ntdll: Set rcx and r11 on exit from syscall dispatcher on x64.
by Paul Gofman Dec. 1, 2021

Dec. 1, 2021

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- dlls/ntdll/tests/exception.c | 74 +++++++++++++++++++++++++++++++++ dlls/ntdll/unix/signal_x86_64.c | 13 ++++-- 2 files changed, 83 insertions(+), 4 deletions(-) diff --git a/dlls/ntdll/tests/exception.c b/dlls/ntdll/tests/exception.c index 98187266d50..a592ca9cf3c 100644 --- a/dlls/ntdll/tests/exception.c +++ b/dlls/ntdll/tests/exception.c @@ -4917,6 +4917,79 @@ static void test_unwind_from_apc(void) ok(pass == 4, "Got unexpected pass %d.\n", pass); ok(test_unwind_apc_called, "Test user APC was not called.\n"); } + +static void test_syscall_clobbered_regs(void) +{ + struct regs + { + UINT64 rflags_before; + UINT64 rcx; + UINT64 r11; + }; + static const BYTE code[] = + { + 0xfd, /* std */ + 0x9c, /* pushf */ + 0x41, 0x8f, 0x00, /* pop (%r8) */ + 0x41, 0x50, /* push %r8 */ + 0x41, 0xff, 0xd1, /* callq *r9 */ + 0x41, 0x58, /* pop %r8 */ + 0x49, 0x89, 0x48, 0x08, /* mov %rcx,8(%r8) */ + 0x4d, 0x89, 0x58, 0x10, /* mov %r11,16(%r8) */ + 0xfc, /* cld */ + 0xc3, /* ret */ + }; + + static const unsigned int flags_mask = 0x844; /* ZF, PF, SF. */ + NTSTATUS (WINAPI *func)(void *arg1, void *arg2, struct regs *, void *call_addr); + NTSTATUS (WINAPI *pNtCancelTimer)(HANDLE, BOOLEAN *); + HMODULE hntdll = GetModuleHandleA("ntdll.dll"); + struct regs regs; + CONTEXT context; + NTSTATUS status; + + pNtCancelTimer = (void *)GetProcAddress(hntdll, "NtCancelTimer"); + ok(!!pNtCancelTimer, "NtCancelTimer not found.\n"); + memcpy(code_mem, code, sizeof(code)); + func = code_mem; + memset(&regs, 0, sizeof(regs)); + status = func((HANDLE)0xdeadbeef, NULL, &regs, pNtCancelTimer); + ok(status == STATUS_INVALID_HANDLE, "Got unexpected status %#x.\n", status); + + /* After the syscall instruction rcx contains the address of the instruction next after syscall + * and r11 contains rflags before the instruction. rcx, r11 are set by syscall instruction itself, + * looks like Windows is preserving those (setting the the thread context with NtContinue during + * the syscall is the special case of course). + * ZF, PF, SF (0x44) may be potentially altered in the Nt syscall thunk. */ + ok(!((regs.rflags_before ^ regs.r11) & ~flags_mask), "Got unexpected rflags_before %s, r11 %s.\n", + wine_dbgstr_longlong(regs.rflags_before), wine_dbgstr_longlong(regs.r11)); + ok((BYTE *)regs.rcx > (BYTE *)pNtCancelTimer && (BYTE *)regs.rcx < (BYTE *)pNtCancelTimer + 0x20, + "Got unexpected rcx %s, pNtCancelTimer %p.\n", wine_dbgstr_longlong(regs.rcx), pNtCancelTimer); + + status = func((HANDLE)0xdeadbeef, (BOOLEAN *)0xdeadbeef, &regs, pNtCancelTimer); + ok(status == STATUS_ACCESS_VIOLATION, "Got unexpected status %#x.\n", status); + ok(!((regs.rflags_before ^ regs.r11) & ~flags_mask), "Got unexpected rflags_before %s, r11 %s.\n", + wine_dbgstr_longlong(regs.rflags_before), wine_dbgstr_longlong(regs.r11)); + ok((BYTE *)regs.rcx > (BYTE *)pNtCancelTimer && (BYTE *)regs.rcx < (BYTE *)pNtCancelTimer + 0x20, + "Got unexpected rcx %s, pNtCancelTimer %p.\n", wine_dbgstr_longlong(regs.rcx), pNtCancelTimer); + + context.ContextFlags = CONTEXT_CONTROL; + status = func(GetCurrentThread(), &context, &regs, pNtGetContextThread); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + ok(!((regs.rflags_before ^ regs.r11) & ~flags_mask), "Got unexpected rflags_before %s, r11 %s.\n", + wine_dbgstr_longlong(regs.rflags_before), wine_dbgstr_longlong(regs.r11)); + ok((BYTE *)regs.rcx > (BYTE *)pNtGetContextThread && (BYTE *)regs.rcx < (BYTE *)pNtGetContextThread + 0x20, + "Got unexpected rcx %s, pNtGetContextThread %p.\n", wine_dbgstr_longlong(regs.rcx), pNtGetContextThread); + + status = func(GetCurrentThread(), &context, &regs, pNtSetContextThread); + ok(status == STATUS_SUCCESS, "Got unexpected status %#x.\n", status); + /* For some reason bit 1 (documented as reserved, always 1) is cleared in r11 after NtSetContextThread() + * across all the Win versions. */ + ok(!(((regs.rflags_before & ~2) ^ regs.r11) & ~flags_mask), "Got unexpected rflags_before %s, r11 %s.\n", + wine_dbgstr_longlong(regs.rflags_before), wine_dbgstr_longlong(regs.r11)); + ok((BYTE *)regs.rcx > (BYTE *)pNtGetContextThread && (BYTE *)regs.rcx < (BYTE *)pNtGetContextThread + 0x20, + "Got unexpected rcx %s, pNtGetContextThread %p.\n", wine_dbgstr_longlong(regs.rcx), pNtGetContextThread); +} #elif defined(__arm__) #define UNW_FLAG_NHANDLER 0 @@ -10737,6 +10810,7 @@ START_TEST(exception) test_extended_context(); test_copy_context(); test_unwind_from_apc(); + test_syscall_clobbered_regs(); #elif defined(__aarch64__) diff --git a/dlls/ntdll/unix/signal_x86_64.c b/dlls/ntdll/unix/signal_x86_64.c index 4310c1c6a2f..bd25172b309 100644 --- a/dlls/ntdll/unix/signal_x86_64.c +++ b/dlls/ntdll/unix/signal_x86_64.c @@ -3233,21 +3233,26 @@ __ASM_GLOBAL_FUNC( __wine_syscall_dispatcher, "movq 0x28(%rcx),%rdi\n\t" "movq 0x20(%rcx),%rsi\n\t" "movq 0x08(%rcx),%rbx\n\t" + "movq 0x80(%rcx),%r11\n\t" /* frame->eflags */ "testl $0x3,%edx\n\t" /* CONTEXT_CONTROL | CONTEXT_INTEGER */ "jnz 1f\n\t" "movq 0x88(%rcx),%rsp\n\t" - "jmpq *0x70(%rcx)\n" /* frame->rip */ + "movq 0x70(%rcx),%rcx\n\t" /* frame->rip */ + "jmpq *%rcx\n\t" "1:\tleaq 0x70(%rcx),%rsp\n\t" "testl $0x2,%edx\n\t" /* CONTEXT_INTEGER */ - "jz 1f\n\t" - "movq 0x00(%rcx),%rax\n\t" + "jnz 1f\n\t" + "btr $1,%r11\n\t" + "movq (%rsp),%rcx\n\t" /* frame->rip */ + "iretq\n" + "1:\tmovq 0x00(%rcx),%rax\n\t" "movq 0x18(%rcx),%rdx\n\t" "movq 0x30(%rcx),%r8\n\t" "movq 0x38(%rcx),%r9\n\t" "movq 0x40(%rcx),%r10\n\t" "movq 0x48(%rcx),%r11\n\t" "movq 0x10(%rcx),%rcx\n" - "1:\tiretq\n" + "iretq\n" "5:\tmovl $0xc000000d,%edx\n\t" /* STATUS_INVALID_PARAMETER */ "movq %rsp,%rcx\n" __ASM_NAME("__wine_syscall_dispatcher_return") ":\n\t" -- 2.33.1

2 5