The OpenKiosk MSI installer specifies "x64" for PID_TEMPLATE in its summary information stream, which is rejected by Wine at package open time. While the examples of valid template strings in MSDN suggest that a semicolon is mandatory in a template string, tests of template string validation show that a platform may be specified in a template without the semicolon delimiter.
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52687
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6429
(From https://gitlab.winehq.org/wine/wine/-/merge_requests/6323)
--
v3: winewayland: Get rid of the window surface individual locks.
winewayland: Introduce a new wayland_client_surface_create helper.
winewayland: Get rid of window_surface reference from wayland_win_data.
winewayland: Get rid of wayland_surface reference from window_surface.
winewayland: Move window contents buffer to wayland_win_data struct.
winewayland: Reset the buffer damage region immediately after copy.
winewayland: Introduce a new get_window_surface_contents helper.
winewayland: Introduce a new set_window_surface_contents helper.
winewayland: Introduce a new ensure_window_surface_contents helper.
winewayland: Post WM_WAYLAND_CONFIGURE outside of the surface lock.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6374
This allows to use DLLOVERRIDES with native DLLs, making it more convenient for testing and debugging. This will also makes it possible to create an alternative media source implementation with a different backend without breaking the current one.
--
v2: mfmp4srcsnk: Register the MP3 and MPEG4 sink factory classes.
mfasfsrcsnk: Register the Asf Byte Stream Handler class.
mfmp4srcsnk: Register the MPEG4 Byte Stream Handler class.
mfsrcsnk: Register the WAV Byte Stream Handler class.
mfsrcsnk: Register the AVI Byte Stream Handler class.
mfsrcsnk: Refactor sink class factory helpers.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6362
This is based on work done by Andrew Eikum. It has been in some form in Proton for the last 4 years.
If server's sampling rate is not 48kHz **DOOM Eternal** will try to set it 48kHz for the streams using the implemented interface. There's a whole class of audio devices that use 44.1kHz sampling rate and at least PulseAudio / PipeWire tends to inherit the value from the hardware to avoid resampling. The value can also be overridden by the user via the audio server's config files.
In such cases, if the interface is not present or stubbed, this results in **audio underruns and noticeable crackling**.
It's easy to test with pipewire-pulse:
```
$ cat /etc/pipewire/pipewire.conf.d/sample-rate.conf
context.properties = {
default.clock.rate = 41100
}
```
With PulseAudio this should be doable via setting `default-sample-rate = 41100` in `/etc/pulse/daemon.conf`.
--
v9: winepulse.drv: Implement set_sample_rate.
https://gitlab.winehq.org/wine/wine/-/merge_requests/5585
I'm starting to consider wrapping more vulkan objects in win32u, I think it'll be useful to implement compositing (and incidentally shared resources with interop with the D3DKMT/NtGdi API), starting with nulldrv/offscreen swapchains. Alternatively we could export more functions from win32u and keep all the wrappers in winevulkan, but having access to win32u internals with a generic vulkan object wrapping mechanism seems to be more interesting.
Right now this is not very convenient because the vulkan object hierarchy is only available in winevulkan. This introduces shared structures and API between win32u and winevulkan so they can manipulate the wrapped objects from both side. The interface would only expose what is necessary, ie: the object hierarchy and wrapped handles, the instance and device functions, and the objects rbtree for debugging, so win32u can insert its wrapper there as well.
After moving the surface and swapchain wrappers to win32u, the interface would look like this: https://gitlab.winehq.org/rbernon/wine/-/blob/65ca1280d46a2dff792e298c22242… (I pushed a complete WIP branch to https://gitlab.winehq.org/rbernon/wine/-/commits/wip/vulkan-win32u-driver?r…). We can also consider moving all the winevulkan wrappers to win32u but it's not clear whether it's necessary or desirable, and we can also do that later using this interface.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6427
This activates the new DPI scaling, and stops pretending that every window is per-monitor DPI aware. It uses the GDI scaled surfaces for DPI-unaware windows, instead of the current higher resolution surfaces, which gives more blurry results but this is the same as Windows for DPI-unaware cases.
--
v3: win32u: Stop setting DPI_PER_MONITOR_AWARE by default.
explorer: Make the desktop thread per-monitor DPI aware.
user32: Move dpiaware_init to SYSPARAMS_Init.
server: Pass window's per-monitor DPI in set_window_pos.
win32u: Pass window_from_point dpi to list_children_from_point.
win32u: Map rect to window DPI in expose_window_surface.
winex11: Map message pos to physical DPI in move_resize_window.
winewayland: Remove unnecessary logical to physical DPI mapping.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6396
This activates the new DPI scaling, and stops pretending that every window is per-monitor DPI aware. It uses the GDI scaled surfaces for DPI-unaware windows, instead of the current higher resolution surfaces, which gives more blurry results but this is the same as Windows for DPI-unaware cases.
--
v2: win32u: Stop setting DPI_PER_MONITOR_AWARE by default.
explorer: Make the desktop thread per-monitor DPI aware.
server: Pass window's per-monitor DPI in set_window_pos.
win32u: Pass window_from_point dpi to list_children_from_point.
win32u: Map rect to window DPI in expose_window_surface.
winex11: Map message pos to physical DPI in move_resize_window.
winewayland: Remove unnecessary logical to physical DPI mapping.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6396
This setting is a more extreme version of the ShowSystray setting: In
addition to suppressing the floating systray, it suppresses systray
icons in the host taskbar and in the virtual desktop taskbar.
NoTrayItemsDisplay is the same registry setting that can be set on
Windows to remove the system tray from the taskbar, so if any
application sets it, Wine will now respect the setting.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6424
On Mon Sep 2 06:13:48 2024 +0000, Rémi Bernon wrote:
> I don't know what @DodoGTA meant but it's actually **not** considered
> good practice to push changes unnecessarily.
> Rebasing MRs should only be done when they actually conflict (the Gitlab
> indication on top is often misleading), as rebasing makes Gitlab
> "Compare with previous version" feature much less useful.
I meant only doing that when an MR update is actually needed (because merge commits aren't a good idea)
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6352#note_80667
I don't know what @DodoGTA meant but it's actually **not** considered good practice to push changes unnecessarily.
Rebasing MRs should only be done when they actually conflict (the Gitlab indication on top is often misleading), as rebasing makes Gitlab "Compare with previous version" feature much less useful.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6352#note_80661
> If you're referring to the new RPC structs, I understand. That being said, my one concern is whether stuffing the file path into `dbch_data` could potentially break some code out there that uses `dbch_size` to guess which event is being sent (something like `if (n->dbch_size == (sizeof(DEV_BROADCAST_HANDLE) + sizeof(BTH_RADIO_IN_RANGE)`). It is an extremely stupid way to check for the event, but I'm not sure whether someone doing this can be safely discounted. I'll write some test code to see if this can be done on Windows to begin with.
But as far as I understand, as `plugplay_send_event` is completely non-standard, these structs are only ever sent internally? So you don't really need to bother about abusing some fields or size for the internal notification, you even considered using custom structs which you would convert back and forth on both sides.
Simply put whatever you need in the DEV_BROADCAST_HANDLE struct you send, using any unused field, or some other way, to put the device path in it if you need that, and just make sure you fix it up to a correct DEV_BROADCAST_HANDLE struct before calling the notification callback?
Although I don't feel like it's even worth it you could even use a custom DEV_BROADCAST_HDR based struct, or extend DEV_BROADCAST_HANDLE with a custom derived struct which has an explicit device path, for the internal messages. I just don't think you need to change the DEV_BROADCAST_HDR base, or change the DEV_BROADCAST_DEVICEINTERFACE code in any significant way for this.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80622
On Sat Aug 31 16:30:43 2024 +0000, Elizabeth Figura wrote:
> Sorry it's taken me so long to get to this, but 3/4 seems suspicious.
> I'd think BroadcastDeviceNotification() [or SendMessageNotify() or
> whatever it calls internally] should be making a copy of the message
> data itself. Are we not doing that? Should we be doing that instead?
Yeah, I might be wrong here. A quick inspection of the code does suggest that we do make copies in `(un)pack_message`. MSDN's documentation for `SendNotifyMessageW`\[1\] warned that messages containing pointers could not be sent as they would result in access to a dangling reference, which is what prompted me to write 3/4. However, `DEV_BROADCAST_DEVICEINTERFACE` messages don't contain any pointers, so this doesn't apply here.
\[1\] https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-send…
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80621
> I don't think adding custom structs is justified at this point, especially as it requires rewriting large parts of the code in multiple modules at the same time.
`wine/dbt.h` doesn't really _add_ a new struct. It merely makes `struct device_notification_details` a common public declaration. The struct is currently [a private def in `dlls/sechost/service.c`](https://gitlab.winehq.org/wine/wine/-/blob/055bddab4f14a1f73e887b88b86408d654382c2b/dlls/sechost/service.c?page=2#L1976), and needs to be defined again for any component that utilizes `I_ScRegisterDeviceNotification`. [`dlls/user32/input.c` seems to be the only place where it gets used ATM](https://gitlab.winehq.org/wine/wine/-/blob/055bddab4f14a1f73e887b88b86…, and the motivation behind shifting the definition to a common header was to preempt the possibility of the struct's definition accidentally diverging in the future.
> However, passing process-private handles around ~~to other processes~~ and later getting them back looks wrong. What happens if you register for notification on a handle then close it right away? Does the notification keep firing with the old handle value? It seem surprising and it would be a nice thing to test for instance.
Yeah, this is something I've been curious about as well. I suppose one way to test this would be to also add an implementation for`IoReportTargetDeviceChange` (thanks @zfigura!) to this MR, and test `RegisterDeviceNotification`'s behavior in `dlls/ntoskrnl.exe/tests/driver_pnp.c`.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80620
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v12: bluetoothapis/tests: Add tests for BluetoothSdpEnumAttributes and BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpGetContainerElementData and BluetoothSdpGetElementData.
bluetoothapis: Implement BluetoothSdpEnumAttributes.
bluetoothapis: Implement BluetoothSdpGetContainerElementData.
bluetoothapis: Implement BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
On Fri Aug 30 18:00:21 2024 +0000, Vibhav Pant wrote:
> > Maybe we can avoid sending the paths every time by moving the
> filtering to plugplay, adapting the interface a bit for this. There
> could be additional methods to register paths / get plugplay handles in
> return, and later use these handle as device handles.
> Perhaps, but wouldn't this make both plugplay service, and the
> notification code sechost/service.c a lot more stateful as a result? Re:
> device handles, if you're referring to the `dbch_handle` field in
> `DEV_BROADCAST_HANDLE`, we already get that from the user using
> `RegisterDeviceNotification`, and the current code just uses them for
> sending notifications.
I don't think adding custom structs is justified at this point, especially as it requires rewriting large parts of the code in multiple modules at the same time.
> Perhaps, but wouldn't this make both plugplay service, and the notification code sechost/service.c a lot more stateful as a result? Re: device handles, if you're referring to the `dbch_handle` field in `DEV_BROADCAST_HANDLE`, we already get that from the user using `RegisterDeviceNotification`, and the current code just uses them for sending notifications.
Fwiw I'm fine keeping the paths, and using the `reserved` field to describe them. I was just considering additional improvements but this specifically doesn't need to be done now.
However, passing process-private handles around to other processes and later getting them back looks wrong. What happens if you register for notification on a handle then close it right away? Does the notification keep firing with the old handle value? It seem surprising and it would be a nice thing to test for instance.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80567
I have been putting this off for too long because handling
VK_KHR_maintenance7 is not trivial. But by now a lot of other
extensions have been released, so we should at least support
those.
--
v2: winevulkan: Update to VK spec version 1.3.295.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6420
> Maybe we can avoid sending the paths every time by moving the filtering to plugplay, adapting the interface a bit for this. There could be additional methods to register paths / get plugplay handles in return, and later use these handle as device handles.
Perhaps, but wouldn't this make both plugplay service, and the notification code sechost/service.c a lot more stateful as a result? Re: device handles, if you're referring to the `dbch_handle` field in `DEV_BROADCAST_HANDLE`, we already get that from the user using `RegisterDeviceNotification`, and the current code just uses them for sending notifications.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80535
On Fri Aug 30 05:47:12 2024 +0000, Rémi Bernon wrote:
> > @rbernon I'm okay with using reserved as an offset to pass the device
> path, but we'd still have to pass it for every message for filtering. I
> didn't want to utilize `reserved` mostly out of caution, if it ever
> turned out to be that the field did have some undocumented semantics
> after all.
> Maybe we can avoid sending the paths every time by moving the filtering
> to plugplay, adapting the interface a bit for this. There could be
> additional methods to register paths / get plugplay handles in return,
> and later use these handle as device handles.
That seems like an awful lot of complication just to avoid defining a structure?
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80533
This series is motivated by performance requirements for GetExtendedTcpTable, especially the tables that require owner PIDs. In the worst case, the existing code scans all /proc/\<pid\>/fd directories for all Wine process for every socket, and may repeat the entire scan up to 5 times if the number of connections outgrew the buffer. With esync, processes can easily have hundreds of entries in /proc/\<pid\>/fd. And, in certain environments, reading the files under /proc can be very slow; I've seen GetExtendedTcpTable take almost 2 seconds to complete.
Some applications (GOG Galaxy, Steam) use the TCP table to check that incoming connections to local services are from a set of whitelisted processes. It's possible for the GetExtendedTcpTable to take longer than the timeout on the socket, which results in failed communication between the client and service.
wineserver knows about all sockets and what process they belong to. The only missing information needed for GetExtendedTcpTable is the state of TCP sockets, which is recoverable from getsockopt(TCP_INFO).
I've added a function in server/handle.c that enumerates all handles of a given type in all processes. The new server calls use that to find all sockets and return the needed information.
Apologies for commit 3 being large. I couldn't think of a way to split it without introducing dead code.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6399
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v11: bluetoothapis/tests: Add test for BluetoothSdpEnumAttributes and BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpGetContainerElementData and BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v8: bluetoothapis/tests: Add test for BluetoothSdpGetAttributeValue.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v7: bluetoothapis/tests: Add test for BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpEnumAttributes, BluetoothSdpGetContainerElementData, and BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v6: bluetoothapis/tests: Add test for BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpEnumAttributes, BluetoothSdpGetContainerElementData, and BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
This fixes one of the regression with ShellExecute when using a full patch and an executable without an extension.
--
v2: shell32: Allow FindExecutables to find unix files.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6285
Thanks, LGTM!
Note that with this MR we can sometimes get artifacts in GL applications such as:

However this is not a problem with the change itself, but rather this change is interacting with two existing deficiencies in the driver:
1. `wayland_window_surface_set_clip()` is not implemented, hence we get such artifacts in our committed window surface buffers.
2. OpenGL surfaces not presented opaquely hence we can actually see the artifacts in the window surface behind the GL subsurface. We might want to revisit using EGL_EXT_present_opaque now that https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/28153 has been merged, although this would require a Mesa version check in the Wayland driver to use the feature safely.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6386#note_80510
> @rbernon I'm okay with using reserved as an offset to pass the device path, but we'd still have to pass it for every message for filtering. I didn't want to utilize `reserved` mostly out of caution, if it ever turned out to be that the field did have some undocumented semantics after all.
Maybe we can avoid sending the paths every time by moving the filtering to plugplay, adapting the interface a bit for this. There could be additional methods to register paths / get plugplay handles in return, and later use these handle as device handles.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80507
On Thu Aug 29 23:38:23 2024 +0000, Vibhav Pant wrote:
> @zfigura Testing it is tricky. My plan was to utilize it in the
> bluetooth driver by directly calling `plugplay_send_event` from the
> driver code itself, and I'm not sure what the equivalent of that would
> be in Windows.
> @rbernon I'm okay with using reserved as an offset to pass the device
> path, but we'd still have to pass it for every message for filtering. I
> didn't want to utilize `reserved` mostly out of caution, if it ever
> turned out to be that the field did have some undocumented semantics
> after all.
After doing a bit of research, I believe the Windows interface is IoReportTargetDeviceChange(). See [1], which mentions using that function to report the device notification, and that user mode should register for it with RegisterDeviceNotification().
That function is probably only used for DBT_DEVTYP_HANDLE. I suspect there is no public interface for DBT_DEVTYP_DEVICEINTERFACE. The corresponding kernel-mode identifier for that one is EventCategoryDeviceInterfaceChange, but I suspect that IoReportTargetDeviceChange() only deals with EventCategoryTargetDeviceChange. This would make sense since device interface notifications should only be generated by the kernel anyway.
[I have no idea about the other DBT_DEVTYPE_* values. Are they even ever sent in NT?]
[1] https://learn.microsoft.com/en-us/windows-hardware/drivers/kernel/using-pnp…
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80501
On Fri Aug 30 02:21:05 2024 +0000, Alexandre Julliard wrote:
> Much better, thanks. Could you please fix the authorship information in
> the commit to use your full name?
My apologies. I thought the authorship name was supposed to match the gitlab username instead of full name. It is corrected now.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6299#note_80500
Using IMF2DBuffer2_Lock2DSize with LockFlags_Write dramatically improves
performance over IMFMediaBuffer_Lock when using a DXGI buffer.
IMFMediaBuffer_Lock does not know that this buffer will not be read and
therefore performs an unnecessary transfer of the texture from GPU to CPU
before it is overwritten.
--
v2: winegstreamer: Optimise copy to DXGI buffer.
https://gitlab.winehq.org/wine/wine/-/merge_requests/5978
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v5: bluetoothapis/tests: Add test for BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpEnumAttributes, BluetoothSdpGetContainerElementData, and BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v4: bluetoothapis/tests: Add test for BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpEnumAttributes, BluetoothSdpGetContainerElementData, and BluetoothSdpGetElementData.
bluetoothapis: Implement BluetoothSdpEnumAttributes.
bluetoothapis: Implement BluetoothSdpGetContainerElementData.
bluetoothapis: Implement BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
The MR adds implementations (+ a few tests) for the following methods in `bluetoothapis.h`:
* `BluetoothSdpEnumAttributes`
* `BluetoothSdpGetContainerElementData`
* `BluetoothSdpGetElementData`
* `BluetoothSdpGetAttributeValue`
--
v3: bluetoothapis/tests: Add test for BluetoothSdpGetAttributeValue.
bluetoothapis: Implement BluetoothSdpGetAttributeValue.
bluetoothapis/tests: Add unit tests for BluetoothSdpEnumAttributes, BluetoothSdpGetContainerElementData, and BluetoothSdpGetElementData.
https://gitlab.winehq.org/wine/wine/-/merge_requests/6402
On Thu Aug 29 16:19:09 2024 +0000, Elizabeth Figura wrote:
> Actually, I'm a bit confused, because now I'm not sure where RPC does do
> that? I was assuming it was a user-marshalled type which implicitly
> calls DuplicateHandle(), but that's not the case.
> The lack of tests in this patch set is a little disturbing. Is it
> possible to test this behaviour? I don't know under what circumstances
> handle events are sent [and I can't easily find anyone successfully
> using DBT_DEVTYP_HANDLE online]. We do have support for testing PnP
> drivers, though, if that's necessary; see dlls/ntoskrnl.exe/tests/driver_pnp.c.
@zfigura Testing it is tricky. My plan was to utilize it in the bluetooth driver by directly calling `plugplay_send_event` from the driver code itself, and I'm not sure what the equivalent of that would be in Windows.
@rbernon I'm okay with using reserved as an offset to pass the device path, but we'd still have to pass it for every message for filtering. I didn't want to utilize `reserved` mostly out of caution, if it ever turned out to be that the field did have some undocumented semantics after all.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/6315#note_80493