This allows initializing locale from Mac locale identifiers like
'zh-Hans-US'. The current implementation recognizes it as 'zh-US'
which isn't a valid locale identifier for Windows.
This patch will try again with the 'lang-script' identifier after
get_win_locale() fails with the 'lang-region' identifier.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/4357
The major problem with adding true rawinput support is that there is no way suppress auto-generating rawinput events on normal motion events. We end up with the normal "accelerated" motion being translated to relative input and xinput2 clashing with that. We really just want the "unaccelerated" input and thus need to prevent a normal motion event from generating rawinput.
This patch set does two main things:
- Add plumbing to server to allow graphics driver to prevent the server from making rawinput from INPUT_MOUSE and INPUT_KEYBOARD events so a graphics driver can inject its own INPUT_HARDWARE events with impunity.
- Major refactor for x11drv xinput2 (listen for events based on focus, use raw unaccelerated values for XI_RawMotion)
I have a version of this patch that is a minimal diff to the x11drv xinput2 handler (maybe I got carried away here...), but I think it might be better to focus on the send_hardware_message() plumbing to make sure it is good for other graphics drivers.
Tested on XWayland only with MouseTester.exe (https://github.com/microe1/MouseTester/releases) and Quake Live (ported this set of patches to proton).
--
v5: x11drv: lets get raw input really working
rawinput: add trace and avoid re-processing
https://gitlab.winehq.org/wine/wine/-/merge_requests/4356
Goes atop !436 and !441. The last seven commits belong to this MR.
--
v2: vkd3d-shader/spirv: Avoid redundant bool-to-bool conversions in spirv_compiler_emit_movc().
vkd3d-shader/dxil: Implement the DXIL VSELECT instruction.
tests/shader-runner: Introduce an sm6 condition for test directives.
tests/shader-runner: Add tests for 64-bit casts.
vkd3d-shader/spirv: Return an error if an invalid handler is encountered.
tests/shader-runner: Add a test for float comparisons.
vkd3d-shader/spirv: Introduce orderedness to comparison instructions.
vkd3d-shader/dxil: Implement the DXIL CMP2 instruction.
vkd3d-shader/spirv: Support bool dst register in spirv_compiler_emit_comparison_instruction().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/459
The major problem with adding true rawinput support is that there is no way suppress auto-generating rawinput events on normal motion events. We end up with the normal "accelerated" motion being translated to relative input and xinput2 clashing with that. We really just want the "unaccelerated" input and thus need to prevent a normal motion event from generating rawinput.
This patch set does two main things:
- Add plumbing to server to allow graphics driver to prevent the server from making rawinput from INPUT_MOUSE and INPUT_KEYBOARD events so a graphics driver can inject its own INPUT_HARDWARE events with impunity.
- Major refactor for x11drv xinput2 (listen for events based on focus, use raw unaccelerated values for XI_RawMotion)
I have a version of this patch that is a minimal diff to the x11drv xinput2 handler (maybe I got carried away here...), but I think it might be better to focus on the send_hardware_message() plumbing to make sure it is good for other graphics drivers.
Tested on XWayland only with MouseTester.exe (https://github.com/microe1/MouseTester/releases) and Quake Live (ported this set of patches to proton).
--
v4: x11drv: lets get raw input really working
https://gitlab.winehq.org/wine/wine/-/merge_requests/4356
Prevents applications that accidentally attempt to allocate massive amounts of memory from getting OOM killed
(An example of such an application is EverQuest's DX11 beta, which has some corrupted asset files that result in it trying to allocate ~18TB of memory)
BTW, is it okay to have a test that's likely to get OOM killed on a failing implementation? If not, any recommendations on how else to test this?
--
v2: ntdll/tests: Add test for reserving massive amounts of memory.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4328
The major problem with adding true rawinput support is that there is no way suppress auto-generating rawinput events on normal motion events. We end up with the normal "accelerated" motion being translated to relative input and xinput2 clashing with that. We really just want the "unaccelerated" input and thus need to prevent a normal motion event from generating rawinput.
This patch set does two main things:
- Add plumbing to server to allow graphics driver to prevent the server from making rawinput from INPUT_MOUSE and INPUT_KEYBOARD events so a graphics driver can inject its own INPUT_HARDWARE events with impunity.
- Major refactor for x11drv xinput2 (listen for events based on focus, use raw unaccelerated values for XI_RawMotion)
I have a version of this patch that is a minimal diff to the x11drv xinput2 handler (maybe I got carried away here...), but I think it might be better to focus on the send_hardware_message() plumbing to make sure it is good for other graphics drivers.
Tested on XWayland only with MouseTester.exe (https://github.com/microe1/MouseTester/releases) and Quake Live (ported this set of patches to proton).
--
v3: x11drv: lets get raw input really working
rawinput: add trace and avoid re-processing
https://gitlab.winehq.org/wine/wine/-/merge_requests/4356
The major problem with the existing rawinput support is that it does not suppress auto-generating rawinput events from the server on normal motion events. So we end up with the "accelerated" input being translated to relative input. We really want the "unaccelerated" input and thus need to prevent a normal motion event from generating rawinput.
This patch set does two main things:
- Add plumbing to server to allow graphics driver to prevent the server from making rawinput from INPUT_MOUSE and INPUT_KEYBOARD events
- Major refactor for x11drv xinput2 (listen for events based on focus, use raw unaccelerated values for XI_RawMotion)
Tested on XWayland only with MouseTester.exe (https://github.com/microe1/MouseTester/releases) and Quake Live (ported this set of patches to proton).
--
v2: x11drv: lets get raw input really working
rawinput: add trace and avoid re-processing
win32u: SendInput should not cause rawinput events
win32u: allow passing noraw flags to send_hardware_message
https://gitlab.winehq.org/wine/wine/-/merge_requests/4356
The major problem with the existing rawinput support is that it does not suppress auto-generating rawinput events from the server on normal motion events. So we end up with the "accelerated" input being translated to relative input. We really want the "unaccelerated" input and thus need to prevent a normal motion event from generating rawinput.
This patch set does two main things:
- Add plumbing to server to allow graphics driver to prevent the server from making rawinput from INPUT_MOUSE and INPUT_KEYBOARD events
- Major refactor for x11drv xinput2 (listen for events based on focus)
Tested on XWayland only with MouseTester.exe (https://github.com/microe1/MouseTester/releases) and Quake Live (ported this set of patches to proton).
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/4356
This is the first of (tentatively) 3 MRs that add Vulkan support to the Wayland driver. Here is the proposed breakdown:
* part 10.1 (this one): Basic setup and VkSurfaceKHR integration
* part 10.2: VkSwapchainKHR integration
* part 10.3: Everything else (mostly passthrough implementations of other Vulkan functions)
I chose to go with Vulkan first, instead of OpenGL, since the integration is more straightforward, and allows us to implement required core driver changes (which will also be used for OpenGL later) with fewer distractions.
Please note that all 3 parts need to land before the Vulkan support is actually usable in applications/games. I have uploaded the full (tentative) series for people that want to take a look or try out the final state: https://gitlab.winehq.org/afrantzis/wine/-/tree/wayland-part-10
Finally, part 10 is not based on part 9, so they can land in either order. However, there are interactions and conflicts between the two, so whichever part lands last will need to be (slightly) adapted. Note, though, that without part 9, some things won't work well on scaled outputs (esp. fullscreen).
Thanks!
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/4340
Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com>
--
v7: vkd3d-shader/tpf: Initial support for writing fx_4_0/fx_4_1 binaries.
vkd3d-shader: Add separate binary target type for effects.
vkd3d-shader/hlsl: Handle effect group statement.
vkd3d-shader/hlsl: Add variables for techniques.
vkd3d-shader/hlsl: Rename rule for top-level techniques.
vkd3d-shader/hlsl: Add 'fxgroup' token.
tests: Add some tests for effects groups syntax.
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/443
--
v2: dmime: Better implement performance times with tempo track.
dmime: Support playing secondary and control segments.
dmime/tests: Test playing tempo track effect on performance times.
dmime/tests: Add helpers to scale and check music time with tempo.
dmime: Fix tempo track GetParam with GUID_TempoParam implementation.
dmime/tests: Test tempo track GetParam with GUID_TempoParam.
dmime/tests: Test tempo track Play and DMUS_PMSGT_TEMPO messages.
dmime: Implement IDirectMusicPerformance_GetSegmentState semi-stub.
dmime/tests: Test IDirectMusicPerformance_GetSegmentState.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4338
Currently we are not properly handling register(cX) reservations for SM1, this is one of the things required for the SNK shaders (CW Bug Bug 18092).
register(cX) reservations also change the offset in the $Globals buffer in SM4, so support for this is also included.
---
Patch 1/4 is required to specify:
```
[require]
shader model < 4.0
```
so that the tests that follow do not get run with the vulkan backend on SM4. I think nobody disagreed with that patch.
--
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/458
_(w)environ[] do have a distinct allocation chunk for each entry, so
that _(w)environ[i] pointer and (pointed) string don't change when
updating/deleting any other entry.
Proposed implementation still differs from native:
- allocation is done on process heap, while native uses msvcrt's heap
- first ANSI allocated _environ[] doesn't have per entry allocation.
This is only activated after a change (update/deletion) to _environ[]
is made.
--
v4: msvcrt: Fix getmainargs() family to return correct environment block.
msvcrt: Use msvcrt heap for allocating envionment data.
msvcrt: Test adding UNICODE env variables.
msvcrt/tests: Add tests about intricating kernel32 and msvcrt env calls.
msvcrt/tests: Add tests about allocation of environment entries.
msvcrt: Improve environment tests (initial conditions).
https://gitlab.winehq.org/wine/wine/-/merge_requests/4313
There are applications that uses SRWLOCK in an invalid way and then checks its binary
representation. ~~Specifically they releases an unlocked SRWLOCK then check its bit pattern is
all-ones.~~
Tweak the representation a bit so they are happy.
--
v15: ntdll: Tweak the binary representation of SRWLOCK.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4310
--
v2: vkd3d-shader/ir: Validate index count for IMMCONST64 registers.
vkd3d-shader/ir: Validate index count for IMMCONST registers.
vkd3d-shader/ir: Validate index count for NULL registers.
vkd3d-shader/ir: Validate register indices.
vkd3d-shader/ir: Use vsir_register_init() to initialize a register.
vkd3d-shader/ir: Validate the TEMP register indices in each HS phase.
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/462
This fixes some inconsistency issues when it comes to inner vs outer windows. On second patch I keep ref again to outer windows from the inner windows, and there are several reasons for this:
* It fixes the existing tests to match native IE.
* It simplifies the code (it's always valid now, no second-guessing or what-ifs needed) and gets rid of `outer_window` in HTMLDocumentNode.
* It **fixes** the `outer_window` in HTMLDocumentNode → it was basically prone to crashes in niche cases since it didn't hold a ref before. We can't couple it to the inner `window` field either, because that one gets detached, and that will fail *existing* tests. For example: `events.c:3224: Test failed: put_URL failed: 80004005`.
* Instead of having to keep outer window refs in specific objects, it's simpler to have it consistent everywhere.
--
https://gitlab.winehq.org/wine/wine/-/merge_requests/4312
Valgrind support requires a fork, which I've published to https://gitlab.winehq.org/rbernon/valgrind. The fork implements loading DWARF debug info from PE files, instead of the old and broken upstream PDB support. I've tried to upstream these changes a long time ago but didn't receive any feedback.
I think we could maybe consider keeping a fork, which I'm happy to maintain, as the changes aren't too large. We may want to investigate adding 32-on-64 support, which may require a bit more changes (to VEX specifically, because its amd64 guest doesn't support segment register manipulation).
The changes here are not all related to Valgrind, and I'll create separate MR for those which may make sense independently from Valgrind / GDB.
Also included is a suppression file to silent some annoying false positives, many of which are coming from the cross-stack accesses during syscalls, which are confusing Valgrind's stack heuristics. One can try this out with something like:
`WINELOADERNOEXEC=1 valgrind --suppressions=tools/valgrind.supp wine64/loader/wine64 wine64/programs/winecfg/winecfg.exe`
--
v11: ntdll: Avoid writing to invalid memory in i386 unix dispatcher.
ntdll: Fix incorrect i386 call_user_mode_callback CFI.
ntdll: Avoid marking freed block header as undefined for valgrind.
ntdll: Force HEAP_TAIL_CHECKING_ENABLED flag with valgrind.
ntdll: Fix valgrind notifications from ntdll.so.
ntdll: Import valgrind headers for PE side ntdll.
loader: Implement SystemTap RTLD probes.
configure.ac: Check for systemtap sys/sdt.h header.
gitlab: Install systemtap-sdt-dev packages.
ntdll: Maintain a PE module link map and expose it to GDB.
loader: Expose a shadow copy of ld.so link map to GDB.
https://gitlab.winehq.org/wine/wine/-/merge_requests/1074
Using a dedicated exit jmpbuf and removing the need for assembly
routines.
When Wine handles an exception in unix code, we return to user mode by
jumping to the last syscall frame. This can leave some pthread cancel
cleanups registered, in the pthread internal linked list, and at the
same time later overwrite the stack frame they were registered for.
In the same way, jumping to the exit frame on thread exit or abort, can
also leave some cleanup handlers registered for invalid stack frames.
Depending on the implementation, calling pthread_exit will cause all the
registered pthread cleanup handlers to be called, possibly jumping back
to now overwritten stack frames and causing segmentation faults.
Exiting a pthread normally, by returning from its procedure, or calling
exit(0) for the main thread doesn't run pthread_exit and doesn't call
cleanup handlers, avoiding that situation.
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=52213
### Additional note:
For robustness, we should probably try to execute these cleanup handlers
when unwinding the stack frames, as we would otherwise leave pthread
objects in a potential problematic state (like a mutex locked, etc).
It is however hard to do so when the handlers are registered from some C
code: pthread C implementation is done by calling some internal pthread
functions to register the handlers, and they aren't registered as
standard unwind handlers.
Only pthread_cancel and pthread_exit can unwind and call / unregister
the C handlers, but interrupting that procedure, for instance calling
setjmp / longjmp from withing our own handler isn't supported.
From C++ code, pthread cleanup handlers are registered through C++ class
constructors / destructors, and it would then be possible to partially
unwind and call them at the same time.
--
v11: ntdll: Unwind i386 syscall stack frames on thread abort.
ntdll: Add a syscall_cfa member to the i386 syscall frame.
ntdll: Unwind x86_64 syscall stack frames on thread abort.
ntdll: Add a syscall_cfa member to the x86_64 syscall frame.
ntdll: Add comments to stack switches in dispatchers.
https://gitlab.winehq.org/wine/wine/-/merge_requests/1088
Goes atop !436. The last three commits belong to this MR.
--
v6: vkd3d-shader/spirv: Introduce orderedness to comparison instructions.
vkd3d-shader/dxil: Implement the DXIL CMP2 instruction.
vkd3d-shader/spirv: Support bool dst register in spirv_compiler_emit_comparison_instruction().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/441
Goes atop !436. The last three commits belong to this MR.
--
v5: vkd3d-shader/dxil: Implement the DXIL CMP2 instruction.
vkd3d-shader/spirv: Support orderedness inversion in comparison instructions.
vkd3d-shader/spirv: Support bool result in spirv_compiler_emit_comparison_instruction().
vkd3d-shader/dxil: Implement the DXIL CAST instruction.
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/441
This fixes the following issue:
- Thread X holds the typelib cache list CS, and is iterating through the list.
- Thread Y calls Release on the typelib interface, reference count hits 0, it's waiting for the cache list CS to remove this typelib.
- Thread X finds the typelib in the cache list, returns it, exits the CS.
- Thread Y enters now the CS, removes the typelib from the cache list, and proceeds to free all of the resources associated with the typelib.
- Thread X tries to use the typelib, use after free.
The method used here to prevent incrementing the reference count is borrowed from MR !2752.
An alternative could be to decouple the actual typelib data from the `ITypeLib2` interface itself, e.g what gets stored into the typelib cache is just the data for the typelib, which would have its own private reference count locked behind the cache list CS. When the public `ITypeLib2` interface's reference count hits 0, it'd lock the typelib cache list CS, decrement the private reference count, and if the private reference count is 0 remove it from the list.
The alternative method would require major restructuring of the code, which is why I'd prefer to use the one in this MR.
--
v3: oleaut32: Lock ITypeLib2 interface reference count behind the typelib cache critical section on Release.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4002
This fixes the following issue:
- Thread X holds the typelib cache list CS, and is iterating through the list.
- Thread Y calls Release on the typelib interface, reference count hits 0, it's waiting for the cache list CS to remove this typelib.
- Thread X finds the typelib in the cache list, returns it, exits the CS.
- Thread Y enters now the CS, removes the typelib from the cache list, and proceeds to free all of the resources associated with the typelib.
- Thread X tries to use the typelib, use after free.
The method used here to prevent incrementing the reference count is borrowed from MR !2752.
An alternative could be to decouple the actual typelib data from the `ITypeLib2` interface itself, e.g what gets stored into the typelib cache is just the data for the typelib, which would have its own private reference count locked behind the cache list CS. When the public `ITypeLib2` interface's reference count hits 0, it'd lock the typelib cache list CS, decrement the private reference count, and if the private reference count is 0 remove it from the list.
The alternative method would require major restructuring of the code, which is why I'd prefer to use the one in this MR.
--
v2: oleaut32: Lock ITypeLib2 interface reference count behind the typelib cache critical section.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4002
--
v4: dmloader: Mark cached objects as loaded.
dmsynth: Don't leak modulators.
dmsynth: Free the allocated presets manually.
dmsynth: Remove useless private data checks.
dmsynth: Create one FluidSynth sample per wave.
dmsynth: Use generators to set root key and fine tune.
dmsynth: Keep track of voice/wave mapping.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4339
In general, ucrtbase allocation are used here (and later ucrtbase.free for freeing memory). RtlCreateUnicodeStringFromAsciiz() is using RtlAllocateHeap(GetProcessHeap(),...) for allocation. Using ucrtbase.free() may results in freeing from a different heap which leaks the string as best or aborts the program when heap validation is enabled.
--
v3: winmm: Fix pszSound allocation in PlaySound_Alloc().
https://gitlab.winehq.org/wine/wine/-/merge_requests/4233
On Thu Nov 9 04:30:28 2023 +0000, Henri Verbeet wrote:
> > > Sure. I think the main alternative would be to split the IR in two
> (or more) separate IRs though. I.e., you'd have a representation of the
> parsed TPF, then convert that to VSIR, and from there to SPIR-V.
> >
> > The alternative I was considering would rather be to have only one IR,
> and use it for all shader language conversions, but not for
> disassembling. And then, for each language for which we support
> disassembling, have a dedicated disassembler (which probably doesn't
> really need an IR: it can emit as it parses). If we supported assembling
> too, we'd also have a dedicated assembler.
> Well, we could debate at which point something gets to be called an
> "IR", but essentially, we'd need to have some function that would e.g.
> parse TPF bytecode, and return something that might be called a "struct
> tpf_instruction". We'd then pass that to either the disassembler, or
> something that translates it to vsir. The main point is that we wouldn't
> be able to parse directly into vsir structures, unless we'd duplicate
> the parsing code for the disassembler.
> > In my mind, assembling/disassembling and compiling (or transpiling, if
> we want to look more modern!) are two different beasts. For compiling
> it's useful to have an IR which is flexible and simple, but it doesn't
> need to faithfully represent precisely all the features of any other
> language. OTOH for assembling/disassembling you don't really care about
> flexibility, but it's important to represent faithfully every detail of
> the language.
> >
> > My feeling is that trying to shove all these features (simplicity,
> flexibility, faithfullness to any language) on a single language is a
> bit overconstraining. Write dedicated assemblers and disassemblers is
> some additional work too, but I'm not sure the balance is in favor of
> our solution.
> I tend to think it is, but I could certainly imagine different people
> striking different balances.
> I suppose the good news is that it's relatively easy to have a go at
> giving it a try. My guess is that we'd end up duplicating most of the
> vsir structures, duplicate most of the disassembler, introduce extra
> tpf->vsir and vsir->tpf passes, and then would be able to remove some
> fields and enum elements from the vsir data structures. It's entirely
> possible that I'm underestimating the benefits though. And sure, I can
> see the appeal of having a more restricted/pure IR, having stronger
> separation between d3dbc/tpf/dxil/spirv/etc.; the practical benefits
> aren't quite as clear to me though.
> > > The disassembler would operate on TPF IR, as would certain lowering
> passes. That's certainly a valid choice, but I think it's important to
> point out that while it would make some thing easier, it would also make
> some things harder. The most obvious is perhaps that we'd need separate
> disassemblers for d3dbc, tpf, dxil, and vsir. Somewhat less obvious is
> perhaps that we may need to duplicate certain lowering passes between
> e.g. d3dbc and tpf, because we'd no longer be able to express them in
> vsir. It may also make it slightly harder to do something like HLSL IR
> -> vsir -> d3dbc, because we'd have to get rid of complex texturing
> instructions when converting HLSL IR to vsir, and then reintroduce them
> when converting vsir to d3dbc.
> >
> > If VSIR features are useful for translating between languages, then I
> agree it's sensible to have then. The part I don't like is having
> features only because some of the languages we support need to
> faithfully represent all their features (e.g., having to keep operations
> like NEG and ABS as register modifiers instead of as regular operators).
> Note that NEG and ABS modifiers aren't only used by the disassembler
> though; we also use these when writing output for the HLSL compiler. And
> sure, there are other ways to handle that as well, but as far as I can
> see they'd all be variants of "introduce struct tpf_instruction".
> > > We may want to tweak the vkd3d_shader_instruction_array data
> structure somewhat, but I don't think we'll need to do anything as
> drastic as converting the instruction array to a linked list; gap
> buffers tend to handle this kind of thing fairly well, and we may even
> be able to improve on that in specific instances.
> >
> > I don't know much about gap buffers, but after some reading on
> Wikipedia I'm not convinced. It seems that a gap buffers makes sense
> when you have a concept of a cursor that mostly moves locally, while our
> passes usually scan the whole program each time. With a gap buffer you
> would end up copying the whole program each time, and by that token you
> could directly rewrite it in a new array each time.
> I think that's a misunderstanding; the amount of data you'd move would
> only be the difference between the previous insertion position and the
> new insertion position. I.e., if you start with a sufficiently large gap
> at the front of the buffer, and move through the instructions from first
> to last, you'll move at most a single copy of the entire program in the
> worst case, and likely a fair bit less in typical cases.
> > Also, random insertion with gap buffers seems to be comparable to arrays.
> Random insertion should be rare though(!); the more typical case would
> be to go through the instructions from first to last, or possibly from
> last to first.
> > Following some link on Wikipedia, a
> [rope](https://en.wikipedia.org/wiki/Rope_\(data_structure\)) might be a
> better match for us, being essentially a compromise between an array and
> a link-based structure.
> Yeah, I'm aware of ropes. It doesn't seem obvious to me that they'd be
> better suited for our purposes, but ultimately I think this is one of
> those things where you start with the naive implementation, and then see
> whether making it more complicated makes it better.
FWIW I have largely complete backend code for a low-level IR (without registers), which I wrote early on in SM6 development. It's a bit over half the size of the existing backend, but the lowering phase for TPF would certainly make up for that. I guess the only reason to make such a major change would be so it's simpler to add new backends.
--
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/409#note_51640
The patch set is ready now.
--
v9: winegstreamer: Implement finalize for media sink.
winestreamer: Implement wg_muxer_finalize.
winegstreamer: Introduce media_sink_write_stream.
winestreamer: Implement wg_muxer_{get,copy,free}_buffer.
winegstreamer: Implement ProcessSample for media sink.
winegstreamer: Implement wg_muxer_push_sample.
winegstreamer: Implement wg_muxer_add_stream.
winegstreamer: Create wg_muxer for media sink.
winegstreamer: Implement seeking query for wg_muxer sink pad.
winegstreamer: Introduce new wg_muxer struct.
https://gitlab.winehq.org/wine/wine/-/merge_requests/3303
Goes atop !436. The last three commits belong to this MR.
--
v4: vkd3d-shader/dxil: Implement the DXIL CMP2 instruction.
vkd3d-shader/spirv: Support orderedness inversion in comparison instructions.
vkd3d-shader/spirv: Support bool result in spirv_compiler_emit_comparison_instruction().
vkd3d-shader/dxil: Implement the DXIL CAST instruction.
vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftou().
vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftoi().
vkd3d-shader/spirv: Handle unsigned result in spirv_compiler_emit_ftoi().
vkd3d-shader/spirv: Introduce integer width cast instructions.
vkd3d-shader/spirv: Support bool cast in spirv_compiler_emit_alu_instruction().
vkd3d-shader/spirv: Support bool logic ops in spirv_compiler_emit_alu_instruction().
vkd3d-shader/spirv: Support bitcast in spirv_compiler_emit_load_ssa_reg().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/441
--
v2: kernelbase: Put 0 to output string even for 1 char buffer in LoadStringW().
kernelbase: Return empty string from LoadStringW() if resource is not found.
user32: Put 0 to output string even for 1 char buffer in LoadStringW().
user32: Return empty string from LoadStringW() if resource is not found.
https://gitlab.winehq.org/wine/wine/-/merge_requests/4344
--
v9: vkd3d-shader/dxil: Implement the DXIL CAST instruction.
vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftou().
vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftoi().
vkd3d-shader/spirv: Handle unsigned result in spirv_compiler_emit_ftoi().
vkd3d-shader/spirv: Introduce integer width cast instructions.
vkd3d-shader/spirv: Support bool cast in spirv_compiler_emit_alu_instruction().
vkd3d-shader/spirv: Support bool logic ops in spirv_compiler_emit_alu_instruction().
vkd3d-shader/spirv: Support bitcast in spirv_compiler_emit_load_ssa_reg().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/436
--
v8: vkd3d-shader/dxil: Implement the DXIL CAST instruction.
vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftou().
vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftoi().
vkd3d-shader/spirv: Handle unsigned result in spirv_compiler_emit_ftoi().
vkd3d-shader/spirv: Introduce integer width cast instructions.
vkd3d-shader/spirv: Support bool cast in spirv_compiler_emit_alu_instruction().
vkd3d-shader/spirv: Support bool logic ops in spirv_compiler_emit_alu_instruction().
vkd3d-shader/spirv: Support bitcast in spirv_compiler_emit_load_ssa_reg().
https://gitlab.winehq.org/wine/vkd3d/-/merge_requests/436