September 2019 - Wine-devel

Re: widl: Set name return value (passed by reference) in the alias case alias case in get_user_type.
by Alexandre Julliard 22 Nov '20

22 Nov '20

Gerald Pfeifer <gerald(a)pfeifer.com> writes: > So, I admit I don't really know this code, but looking at it (triggered > by a warning issued by GCC development versions), I noticed that this > variable passed by reference is not initialized here. It's initialized when we return a type, and it doesn't need to be initialized on NULL return. The code is correct, but you could probably set the variable to NULL in the caller to silence the warning. -- Alexandre Julliard julliard(a)winehq.org

2 1

Error handling in RpcBindingVectorFree (dlls/rpcrt4/rpc_binding.c)
by Gerald Pfeifer 22 Nov '20

22 Nov '20

Looking at RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector ) { RPC_STATUS status; ULONG c; TRACE("(%p)\n", BindingVector); for (c=0; c<(*BindingVector)->Count; c++) { status = RpcBindingFree(&(*BindingVector)->BindingH[c]); } HeapFree(GetProcessHeap(), 0, *BindingVector); *BindingVector = NULL; return RPC_S_OK; } we currently always ignore the outcome of RpcBindingFree and return RPC_S_OK. However, there is one case where RpcBindingFree returns something different (which is if *Binding is null when RPC_S_INVALID_BINDING is returned). What is the proper way of handling this? Just keeping the code as is and removing the unused status variable? Breaking the loop once RpcBindingFree returns something different from RPC_S_OK? Continuing and returning the first / the last status different from RPC_S_OK? Gerald

1 1

TestBot and graphics tests
by Francois Gouget 24 Aug '20

24 Aug '20

Here are some things I've learned about PCI-passthrough recently, which would be one way (probably the best) to add "real hardware" to the TestBot. I don't want to give anyone false hopes though: this just went from "this is a mysterious thing I need to learn about" to "I think I know how to do it but have not tried it yet". So graphics card PCI-passthrough is now relatively well documented on the Internet and seems to have seen some use-cases that would indicate it may even be reasonably usable. * There are two machines intended to run real GPU tests for Wine: cw1-hd6800 and cw2-gtx560. For now they are only used to run WineTest daily on Windows 8.1, Windows 10 1507, 1709, 1809 and Linux. That's quite a bunch but it would be much better if they were integrated with the TestBot as that would allow developers to submit their own tests. So I had a look at what it would imply to convert them to VM hosts using QEmu + PCI-passthrough. * First one needs a processor with hardware virtualisation support. For Intel that's VT-d. Both machines have an Intel Core 2600 which supports VT-d. Good. * Second the motherboard too needs to support VT-d. Both machines have an ASRock P67 Extreme4 motherboard. Unfortunately UEFI says "unsupported" next to the "VT-d" setting for the motherboard :-( It looks like there was some confusion as to whether the P67 chipset supported VT-d initially. From what I gathered it's only Q67 that does but this caused some manufacturers, among which ASRock, to initially claim support and later retract it. * Then one needs to add the intel_iommu=on option to the kernel command line (resp. amd_iommu). This is should make all the PCI devices appear in /sys/kernel/iommu_groups. But that folder remains empty which confirms that full VT-d support is missing. * Another important aspect is to have a graphics card which is hot-restartable. In some cases when a VM's graphics card is crashed the only way to reset it is to reboot the host. The TestBot is likely to crash the graphics card, particularly if we do a hard-power off on the VMs like we currently do, and it would relaly be annoying to have to reboot the host everytime the graphics card goes belly up. I don't know if the AMD HD6800 and Nvidia GTX560 are suitable but it's quite possible they are not. All I know for now is that we should avoid AMD's R9 line of graphics cards. I still need to find a couple of suitable reasonably lower power graphics cards: one AMD and one Nvidia. * Then one needs to prevent the host from using the graphics card. Usually that's done by having the host use the processor's IGP and dedicating the discrete GPU to the VMs. Unfortunately the 2600's IGP cannot be active when there's a discrete card so that route is denied to us. Fortunately there's quite a bit of documentation on how to shut down not just X but also the Linux virtual consoles to free the GPU and hand it over to the VMs after boot. Doing so means losing KVM access to the host which is a bit annoying in case something goes wrong. So ideally we'd make sure this does not happen in grub's "safe mode" boot option. * Although I have not done any test yet I'm reasonably certain that PCI-passthrough rules out live snapshots: QEmu would have no way to restore the graphics card's internal state. - For Windows VMs that's not an issue: if we provide a power off snapshot the TestBot already knows how to power on the VM and wait for it to boot (as long as the boot is shorter than the connection timeout but it works out usually). - For Linux VM's that's more of an issue: the TestBot will power on the VM as usual. The problem is when it updates Wine: after recompiling everything it deletes the old snapshot and creates a new one from the current state of the VM, which means a live snapshot. So the TestBot will need to be modified so it knows when and how to power off the VM and take a powered off snapshot. * Since the VM has full control of the graphics card QEmu has no access to the content of the screen. That's not an issue for the normal TestBot operation, just for the initial VM setup. Fortunately the graphics card is connected to a KVM so the screen can be accessed through that means. It does mean assigning the mouse and keyboard to the VM too. Should that prove impractical there are a bunch of other options too: VNC, LookingGlass, Synergy, etc. But the less needs to be installed in the VMs the better. * Also the TestBot uses QEmu to take the screenshots. But QEmu does not have access to the content of the screen. The fix is to use a tool to take the screenshots from within the VM and use TestAgent to retrieve them. On Linux there are standard tools we can use. On Windows there's code floating around we can use. So the next steps would be: * Maybe test on my box using the builtin IGP. But that likely won't be very conclusive beyond confirming the snapshot issues, screen access, etc. * Find a suitable AMD or Nvidia graphics card and test that on my box. That would allow me to fully test integration with the TestBot, check for stability issues, etc. * Then see what can be done with the existing cw1 and cw2 boxes. -- Francois Gouget <fgouget(a)codeweavers.com>

4 10

[PATCH v2 1/4] d3dcompiler: Get rid of the "node" field from struct hlsl_ir_function_decl.
by Zebediah Figura 05 Feb '20

05 Feb '20

Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- dlls/d3dcompiler_43/d3dcompiler_private.h | 4 ++-- dlls/d3dcompiler_43/hlsl.y | 20 ++++++++++---------- dlls/d3dcompiler_43/utils.c | 4 +--- 3 files changed, 13 insertions(+), 15 deletions(-) diff --git a/dlls/d3dcompiler_43/d3dcompiler_private.h b/dlls/d3dcompiler_43/d3dcompiler_private.h index 1ab343de2d8..01f6ce0e60a 100644 --- a/dlls/d3dcompiler_43/d3dcompiler_private.h +++ b/dlls/d3dcompiler_43/d3dcompiler_private.h @@ -712,7 +712,6 @@ enum hlsl_ir_node_type HLSL_IR_CONSTRUCTOR, HLSL_IR_DEREF, HLSL_IR_EXPR, - HLSL_IR_FUNCTION_DECL, HLSL_IR_IF, HLSL_IR_LOOP, HLSL_IR_JUMP, @@ -776,7 +775,8 @@ struct hlsl_ir_function struct hlsl_ir_function_decl { - struct hlsl_ir_node node; + struct hlsl_type *return_type; + struct source_location loc; struct wine_rb_entry entry; struct hlsl_ir_function *func; const char *semantic; diff --git a/dlls/d3dcompiler_43/hlsl.y b/dlls/d3dcompiler_43/hlsl.y index 5585b899463..7c14ad0091c 100644 --- a/dlls/d3dcompiler_43/hlsl.y +++ b/dlls/d3dcompiler_43/hlsl.y @@ -1084,28 +1084,28 @@ hlsl_prog: /* empty */ { if (decl->body && $2.decl->body) { - hlsl_report_message($2.decl->node.loc.file, $2.decl->node.loc.line, - $2.decl->node.loc.col, HLSL_LEVEL_ERROR, + hlsl_report_message($2.decl->loc.file, $2.decl->loc.line, + $2.decl->loc.col, HLSL_LEVEL_ERROR, "redefinition of function %s", debugstr_a($2.name)); YYABORT; } - else if (!compare_hlsl_types(decl->node.data_type, $2.decl->node.data_type)) + else if (!compare_hlsl_types(decl->return_type, $2.decl->return_type)) { - hlsl_report_message($2.decl->node.loc.file, $2.decl->node.loc.line, - $2.decl->node.loc.col, HLSL_LEVEL_ERROR, + hlsl_report_message($2.decl->loc.file, $2.decl->loc.line, + $2.decl->loc.col, HLSL_LEVEL_ERROR, "redefining function %s with a different return type", debugstr_a($2.name)); - hlsl_report_message(decl->node.loc.file, decl->node.loc.line, decl->node.loc.col, HLSL_LEVEL_NOTE, + hlsl_report_message(decl->loc.file, decl->loc.line, decl->loc.col, HLSL_LEVEL_NOTE, "%s previously declared here", debugstr_a($2.name)); YYABORT; } } - if ($2.decl->node.data_type->base_type == HLSL_TYPE_VOID && $2.decl->semantic) + if ($2.decl->return_type->base_type == HLSL_TYPE_VOID && $2.decl->semantic) { - hlsl_report_message($2.decl->node.loc.file, $2.decl->node.loc.line, - $2.decl->node.loc.col, HLSL_LEVEL_ERROR, + hlsl_report_message($2.decl->loc.file, $2.decl->loc.line, + $2.decl->loc.col, HLSL_LEVEL_ERROR, "void function with a semantic"); } @@ -1280,7 +1280,7 @@ func_prototype: var_modifiers type var_identifier '(' parameters ')' c } $$.name = $3; $$.decl->semantic = $7.semantic; - set_location(&$$.decl->node.loc, &@3); + set_location(&$$.decl->loc, &@3); } compound_statement: '{' '}' diff --git a/dlls/d3dcompiler_43/utils.c b/dlls/d3dcompiler_43/utils.c index 5ecbbc9dc1d..ad2d02e1452 100644 --- a/dlls/d3dcompiler_43/utils.c +++ b/dlls/d3dcompiler_43/utils.c @@ -1577,8 +1577,7 @@ struct hlsl_ir_function_decl *new_func_decl(struct hlsl_type *return_type, struc ERR("Out of memory.\n"); return NULL; } - decl->node.type = HLSL_IR_FUNCTION_DECL; - decl->node.data_type = return_type; + decl->return_type = return_type; decl->parameters = parameters; return decl; @@ -1775,7 +1774,6 @@ static const char *debug_node_type(enum hlsl_ir_node_type type) "HLSL_IR_CONSTRUCTOR", "HLSL_IR_DEREF", "HLSL_IR_EXPR", - "HLSL_IR_FUNCTION_DECL", "HLSL_IR_IF", "HLSL_IR_JUMP", "HLSL_IR_SWIZZLE", -- 2.20.1

2 5

Wine Gecko status
by Michael Cronenworth 07 Nov '19

07 Nov '19

Hi, What is the status of development regarding Wine Gecko? The last general release was June 2016. As the maintainer in Fedora I have a few concerns that I would like to address. 1. The build scripts require Python 2. Fedora is dropping Python 2 in Fedora 31/32. 31 is only a few months away from GA. 2. I have been unable to build from source with the latest MinGW toolset since November 2016. I've last reported this directly to Jacek in 2018, but I have never heard from him. 3. If no support arrives, I don't have the time to patch wine-gecko. It will be dropped from Fedora and users will be downloading the binaries from winehq.org. This provides a reduced user experience and I would like to prevent it. Thanks, Michael

4 15

[PATCH v2] ddraw: implement Pick() and GetPickRecords().
by MattKC 07 Nov '19

07 Nov '19

3 5

[PATCH] gdi32: Implement GetCharWidthFloat().
by Zebediah Figura 17 Oct '19

17 Oct '19

Needed by Cygwin's mintty.exe. Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- dlls/gdi32/font.c | 57 ++++++++++++++++++++++++++++++++++------- dlls/gdi32/tests/font.c | 46 +++++++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+), 9 deletions(-) diff --git a/dlls/gdi32/font.c b/dlls/gdi32/font.c index b06ff6d354a..d451f30c3ee 100644 --- a/dlls/gdi32/font.c +++ b/dlls/gdi32/font.c @@ -36,6 +36,7 @@ #include "winreg.h" #include "gdi_private.h" #include "wine/exception.h" +#include "wine/heap.h" #include "wine/unicode.h" #include "wine/debug.h" @@ -3471,23 +3472,61 @@ done: /************************************************************************* * GetCharWidthFloatA [GDI32.@] */ -BOOL WINAPI GetCharWidthFloatA(HDC hdc, UINT iFirstChar, - UINT iLastChar, PFLOAT pxBuffer) +BOOL WINAPI GetCharWidthFloatA( HDC hdc, UINT first, UINT last, float *buffer ) { - FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer); - return FALSE; + WCHAR *wstr; + int i, wlen; + char *str; + + if (!(str = FONT_GetCharsByRangeA( hdc, first, last, &i ))) + return FALSE; + wstr = FONT_mbtowc( hdc, str, i, &wlen, NULL ); + heap_free(str); + + for (i = 0; i < wlen; ++i) + { + if (!GetCharWidthFloatW( hdc, wstr[i], wstr[i], &buffer[i] )) + { + heap_free(wstr); + return FALSE; + } + } + heap_free(wstr); + return TRUE; } /************************************************************************* * GetCharWidthFloatW [GDI32.@] */ -BOOL WINAPI GetCharWidthFloatW(HDC hdc, UINT iFirstChar, - UINT iLastChar, PFLOAT pxBuffer) +BOOL WINAPI GetCharWidthFloatW( HDC hdc, UINT first, UINT last, float *buffer ) { - FIXME("%p, %u, %u, %p: stub!\n", hdc, iFirstChar, iLastChar, pxBuffer); - return FALSE; -} + DC *dc = get_dc_ptr( hdc ); + int *ibuffer; + PHYSDEV dev; + BOOL ret; + UINT i; + + TRACE("dc %p, first %#x, last %#x, buffer %p\n", dc, first, last, buffer); + + if (!dc) return FALSE; + if (!(ibuffer = heap_alloc( (last - first + 1) * sizeof(int) ))) + { + release_dc_ptr( dc ); + return FALSE; + } + + dev = GET_DC_PHYSDEV( dc, pGetCharWidth ); + if ((ret = dev->funcs->pGetCharWidth( dev, first, last, ibuffer ))) + { + float scale = fabs( dc->xformVport2World.eM11 ) / 16.0f; + for (i = first; i <= last; ++i) + buffer[i - first] = ibuffer[i - first] * scale; + } + + heap_free(ibuffer); + return ret; +} /*********************************************************************** * * diff --git a/dlls/gdi32/tests/font.c b/dlls/gdi32/tests/font.c index b57effd349d..ccae09edc19 100644 --- a/dlls/gdi32/tests/font.c +++ b/dlls/gdi32/tests/font.c @@ -7189,6 +7189,51 @@ static void test_GetCharWidthInfo(void) ReleaseDC(NULL, hdc); } +static int CALLBACK get_char_width_proc(const LOGFONTA *lf, + const TEXTMETRICA *tm, DWORD type, LPARAM ctx) +{ + HFONT font = CreateFontIndirectA(lf); + HDC dc = GetDC(NULL); + const char c = 'm'; + ABCFLOAT abcf; + int i, i32; + BOOL ret; + float f; + ABC abc; + + SelectObject(dc, font); + + ret = GetCharWidthFloatA(dc, c, c, &f); + ok(ret, "%s: GetCharWidthFloat() failed\n", lf->lfFaceName); + ret = GetCharWidth32A(dc, c, c, &i32); + ok(ret, "%s: GetCharWidth32A() failed\n", lf->lfFaceName); + ret = GetCharWidthA(dc, c, c, &i); + ok(ret, "%s: GetCharWidthA() failed\n", lf->lfFaceName); + ok(i == i32, "%s: mismatched widths %d/%d\n", lf->lfFaceName, i, i32); + ok((float)i / 16.0f == f, "%s: mismatched widths %d/%.8e\n", lf->lfFaceName, i, f); + + ret = GetCharABCWidthsFloatA(dc, c, c, &abcf); + ok(ret, "%s: GetCharABCWidths() failed\n", lf->lfFaceName); + if (GetCharABCWidthsA(dc, c, c, &abc)) + ok((float)abc.abcB == abcf.abcfB, "%s: mismatched widths %d/%.8e\n", + lf->lfFaceName, abc.abcB, abcf.abcfB); + + ReleaseDC(NULL, dc); + DeleteObject(font); + return 1; +} + +static void test_char_width(void) +{ + HDC dc = GetDC(NULL); + LOGFONTA lf = {0}; + + lf.lfCharSet = DEFAULT_CHARSET; + EnumFontFamiliesExA(dc, &lf, get_char_width_proc, 0, 0); + + ReleaseDC(NULL, dc); +} + START_TEST(font) { static const char *test_names[] = @@ -7271,6 +7316,7 @@ START_TEST(font) test_bitmap_font_glyph_index(); test_GetCharWidthI(); test_long_names(); + test_char_width(); /* These tests should be last test until RemoveFontResource * is properly implemented. -- 2.23.0

2 3

[PATCH 1/2] user32/combo: Draw comboboxes with correct background
by Fabian Maurer 16 Oct '19

16 Oct '19

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=46417 Signed-off-by: Fabian Maurer <dark.shadow4(a)web.de> --- dlls/user32/combo.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/dlls/user32/combo.c b/dlls/user32/combo.c index 59c2e6484c..a126922a74 100644 --- a/dlls/user32/combo.c +++ b/dlls/user32/combo.c @@ -1912,6 +1912,9 @@ LRESULT ComboWndProc_common( HWND hwnd, UINT message, WPARAM wParam, LPARAM lPar } else return CB_ERR; + case WM_CTLCOLORSTATIC: + case WM_CTLCOLOREDIT: + return (LRESULT)GetSysColorBrush(COLOR_WINDOW); case WM_DRAWITEM: case WM_DELETEITEM: case WM_COMPAREITEM: -- 2.23.0

3 8

[PATCH v3] x3daudio: fix lib exports
by Rafał Mużyło 08 Oct '19

08 Oct '19

x3daudio: fix lib exports 1. in case of x3daudio1_{0,1,2}, two exported functions are for some reason decorated (though only on 32bit) 2. tests show these functions should be stdcall, not cdecl; more exactly, header for 1.1 shows that too (1.7 header shows that changed at some point) Signed-off-by: Rafał Mużyło <galtgendo(a)o2.pl>

4 6

[PATCH 1/6] vkd3d: Enable MSVC to compile.
by Hans-Kristian Arntzen 07 Oct '19

07 Oct '19

Tested on MSVC 2017. This patches makes it viable to build standalone and debuggable .dlls of vkd3d. This commit fixes various compatibility issues with MSVC 2017. The only non-trivial change is the addition of a trivial pthread wrapper. This requires Windows Vista and up due to condition variable support being non-existent in XP. Signed-off-by: Hans-Kristian Arntzen <post(a)arntzen-software.no> --- include/private/vkd3d_common.h | 18 ++- include/private/vkd3d_debug.h | 4 +- include/private/vkd3d_threads.h | 166 +++++++++++++++++++++++ libs/vkd3d-shader/spirv.c | 2 +- libs/vkd3d-shader/vkd3d_shader_private.h | 1 - libs/vkd3d/device.c | 2 +- libs/vkd3d/resource.c | 2 +- libs/vkd3d/state.c | 2 +- libs/vkd3d/utils.c | 4 +- libs/vkd3d/vkd3d_private.h | 17 +-- libs/vkd3d/vulkan_procs.h | 4 +- 11 files changed, 197 insertions(+), 25 deletions(-) create mode 100644 include/private/vkd3d_threads.h diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index 1ac8a63..fab0cd4 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -26,6 +26,10 @@ #include <limits.h> #include <stdbool.h> +#ifdef _MSC_VER +#include <intrin.h> +#endif + #ifndef ARRAY_SIZE # define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x))) #endif @@ -51,7 +55,9 @@ static inline size_t align(size_t addr, size_t alignment) static inline unsigned int vkd3d_popcount(unsigned int v) { -#ifdef HAVE_BUILTIN_POPCOUNT +#ifdef _MSC_VER + return __popcnt(v); +#elif defined(HAVE_BUILTIN_POPCOUNT) return __builtin_popcount(v); #else v -= (v >> 1) & 0x55555555; @@ -78,7 +84,11 @@ static inline bool vkd3d_bitmask_is_contiguous(unsigned int mask) /* Undefined for x == 0. */ static inline unsigned int vkd3d_log2i(unsigned int x) { -#ifdef HAVE_BUILTIN_CLZ +#ifdef _MSC_VER + unsigned long result; + _BitScanReverse(&result, x); + return (unsigned int)x; +#elif defined(HAVE_BUILTIN_CLZ) return __builtin_clz(x) ^ 0x1f; #else static const unsigned int l[] = @@ -152,8 +162,8 @@ static inline LONG InterlockedDecrement(LONG volatile *x) #if HAVE_SYNC_ADD_AND_FETCH # define atomic_add_fetch(ptr, val) __sync_add_and_fetch(ptr, val) -#else -# error "atomic_add_fetch() not implemented for this platform" +#elif defined(_MSC_VER) +# define atomic_add_fetch(ptr, val) InterlockedAdd(ptr, val) #endif /* HAVE_SYNC_ADD_AND_FETCH */ static inline void vkd3d_parse_version(const char *version, int *major, int *minor) diff --git a/include/private/vkd3d_debug.h b/include/private/vkd3d_debug.h index 1a44cb9..c37c841 100644 --- a/include/private/vkd3d_debug.h +++ b/include/private/vkd3d_debug.h @@ -67,8 +67,8 @@ const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN; vkd3d_dbg_next_time = true; \ VKD3D_DBG_PRINTF -#define VKD3D_DBG_PRINTF(args...) \ - vkd3d_dbg_printf(vkd3d_dbg_level, __FUNCTION__, args); } while (0) +#define VKD3D_DBG_PRINTF(...) \ + vkd3d_dbg_printf(vkd3d_dbg_level, __FUNCTION__, __VA_ARGS__); } while (0) #ifndef TRACE #define TRACE VKD3D_DBG_LOG(TRACE) diff --git a/include/private/vkd3d_threads.h b/include/private/vkd3d_threads.h new file mode 100644 index 0000000..b613b50 --- /dev/null +++ b/include/private/vkd3d_threads.h @@ -0,0 +1,166 @@ +/* + * Copyright 2019 Hans-Kristian Arntzen for Valve + * + * 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 __VKD3D_THREADS_H +#define __VKD3D_THREADS_H + +#include "config.h" + +#if defined(HAVE_PTHREAD_H) +#include <pthread.h> + +#elif defined(_WIN32) /* HAVE_PTHREAD_H */ + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> + +typedef struct pthread +{ + HANDLE thread; + DWORD id; +} pthread_t; + +typedef struct pthread_mutex +{ + CRITICAL_SECTION *lock; +} pthread_mutex_t; + +typedef struct pthread_cond +{ + CONDITION_VARIABLE *cond; +} pthread_cond_t; + +struct vkd3d_pthread_wrapper_struct +{ + void * (*routine)(void *); + void *arg; +}; + +static DWORD WINAPI win32_thread_wrapper_routine(struct vkd3d_pthread_wrapper_struct *wrapper) +{ + struct vkd3d_pthread_wrapper_struct tmp = *wrapper; + vkd3d_free(wrapper); + tmp.routine(tmp.arg); + return 0; +} + +static inline int pthread_create(pthread_t *thread, void *attr, void * (*thread_fun)(void *), void *arg) +{ + (void)attr; + struct vkd3d_pthread_wrapper_struct *wrapper = vkd3d_malloc(sizeof(*wrapper)); + if (!wrapper) + return -1; + wrapper->routine = thread_fun; + wrapper->arg = arg; + thread->thread = CreateThread(NULL, 0, win32_thread_wrapper_routine, wrapper, 0, &thread->id); + if (!thread->thread) + { + vkd3d_free(wrapper); + return -1; + } + return 0; +} + +static inline int pthread_join(pthread_t thread, void **ret) +{ + (void)ret; + int success = WaitForSingleObject(thread.thread, INFINITE) == WAIT_OBJECT_0; + CloseHandle(thread.thread); + return success ? 0 : -1; +} + +static inline int pthread_mutex_init(pthread_mutex_t *lock, void *attr) +{ + (void)attr; + lock->lock = vkd3d_malloc(sizeof(CRITICAL_SECTION)); + if (!lock->lock) + return -1; + InitializeCriticalSection(lock->lock); + return 0; +} + +static inline int pthread_mutex_lock(pthread_mutex_t *lock) +{ + EnterCriticalSection(lock->lock); + return 0; +} + +static inline int pthread_mutex_unlock(pthread_mutex_t *lock) +{ + LeaveCriticalSection(lock->lock); + return 0; +} + +static inline int pthread_mutex_destroy(pthread_mutex_t *lock) +{ + DeleteCriticalSection(lock->lock); + vkd3d_free(lock->lock); + return 0; +} + +static inline int pthread_cond_init(pthread_cond_t *cond, void *attr) +{ + (void)attr; + cond->cond = vkd3d_malloc(sizeof(CONDITION_VARIABLE)); + if (!cond->cond) + return -1; + InitializeConditionVariable(cond->cond); + return 0; +} + +static inline void pthread_cond_destroy(pthread_cond_t *cond) +{ + vkd3d_free(cond->cond); +} + +static inline int pthread_cond_signal(pthread_cond_t *cond) +{ + WakeConditionVariable(cond->cond); + return 0; +} + +static inline int pthread_cond_broadcast(pthread_cond_t *cond) +{ + WakeAllConditionVariable(cond->cond); + return 0; +} + +static inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *lock) +{ + bool ret = SleepConditionVariableCS(cond->cond, lock->lock, INFINITE); + return ret ? 0 : -1; +} + +#else /* HAVE_PTHREAD_H */ +#error "Threads are not supported. Cannot build." +#endif /* HAVE_PTHREAD_H */ + +static inline void vkd3d_set_thread_name(const char *name) +{ +#if defined(_MSC_VER) + (void)name; +#elif defined(HAVE_PTHREAD_SETNAME_NP_2) + pthread_setname_np(pthread_self(), name); +#elif defined(HAVE_PTHREAD_SETNAME_NP_1) + pthread_setname_np(name); +#else + (void)name; +#endif +} + +#endif /* __VKD3D_THREADS_H */ diff --git a/libs/vkd3d-shader/spirv.c b/libs/vkd3d-shader/spirv.c index fe8935c..580230f 100644 --- a/libs/vkd3d-shader/spirv.c +++ b/libs/vkd3d-shader/spirv.c @@ -4540,7 +4540,7 @@ static void vkd3d_dxbc_compiler_emit_store_shader_output(struct vkd3d_dxbc_compi static void vkd3d_dxbc_compiler_emit_shader_epilogue_function(struct vkd3d_dxbc_compiler *compiler) { - uint32_t param_type_id[MAX_REG_OUTPUT + 1], param_id[MAX_REG_OUTPUT + 1] = {}; + uint32_t param_type_id[MAX_REG_OUTPUT + 1], param_id[MAX_REG_OUTPUT + 1] = {0}; uint32_t void_id, type_id, ptr_type_id, function_type_id, function_id; struct vkd3d_spirv_builder *builder = &compiler->spirv_builder; const struct vkd3d_shader_signature *signature; diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 47764e5..940cb76 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -56,7 +56,6 @@ #include <limits.h> #include <stdbool.h> #include <string.h> -#include <strings.h> #define VKD3D_VEC4_SIZE 4 diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 3da4273..460bdf9 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -453,7 +453,7 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, bool *user_extension_supported = NULL; VkApplicationInfo application_info; VkInstanceCreateInfo instance_info; - char application_name[PATH_MAX]; + char application_name[VKD3D_PATH_MAX]; uint32_t extension_count; const char **extensions; VkInstance vk_instance; diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index aebe1fa..88f184d 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1388,7 +1388,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_resource_ReadFromSubresource(ID3D12Resour size = (box.right - box.left) / format->block_width * format->byte_count * format->block_byte_count; for (z = box.front; z < box.back; ++z) { - dst = dst_data + (z - box.front) * dst_slice_pitch; + dst = (uint8_t *)dst_data + (z - box.front) * dst_slice_pitch; src = src_data + z * vk_layout.depthPitch + box.top / format->block_height * vk_layout.rowPitch; for (y = box.top; y < box.bottom; y += format->block_height) { diff --git a/libs/vkd3d/state.c b/libs/vkd3d/state.c index 12a711b..9dc5cff 100644 --- a/libs/vkd3d/state.c +++ b/libs/vkd3d/state.c @@ -1342,7 +1342,7 @@ static HRESULT create_shader_stage(struct d3d12_device *device, struct vkd3d_shader_code dxbc = {code->pShaderBytecode, code->BytecodeLength}; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; struct VkShaderModuleCreateInfo shader_desc; - struct vkd3d_shader_code spirv = {}; + struct vkd3d_shader_code spirv = {0}; VkResult vr; int ret; diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index 6a910a7..624b14f 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -804,7 +804,7 @@ HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs, return S_OK; } -#ifdef _GNU_SOURCE +#if defined(_GNU_SOURCE) && !defined(_WIN32) bool vkd3d_get_program_name(char program_name[PATH_MAX]) { @@ -840,7 +840,7 @@ bool vkd3d_get_program_name(char program_name[PATH_MAX]) #else -bool vkd3d_get_program_name(char program_name[PATH_MAX]) +bool vkd3d_get_program_name(char program_name[VKD3D_PATH_MAX]) { *program_name = '\0'; return false; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 59f0eac..a51ca4d 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -31,11 +31,11 @@ #include "vkd3d.h" #include "vkd3d_shader.h" +#include "vkd3d_threads.h" #include <assert.h> #include <inttypes.h> #include <limits.h> -#include <pthread.h> #include <stdbool.h> #define VK_CALL(f) (vk_procs->f) @@ -1231,16 +1231,13 @@ HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs, extern const char vkd3d_build[]; -bool vkd3d_get_program_name(char program_name[PATH_MAX]) DECLSPEC_HIDDEN; - -static inline void vkd3d_set_thread_name(const char *name) -{ -#if defined(HAVE_PTHREAD_SETNAME_NP_2) - pthread_setname_np(pthread_self(), name); -#elif defined(HAVE_PTHREAD_SETNAME_NP_1) - pthread_setname_np(name); +#ifdef PATH_MAX +#define VKD3D_PATH_MAX PATH_MAX +#else +#define VKD3D_PATH_MAX 256 #endif -} + +bool vkd3d_get_program_name(char program_name[VKD3D_PATH_MAX]) DECLSPEC_HIDDEN; VkResult vkd3d_set_vk_object_name_utf8(struct d3d12_device *device, uint64_t vk_object, VkDebugReportObjectTypeEXT vk_object_type, const char *name) DECLSPEC_HIDDEN; diff --git a/libs/vkd3d/vulkan_procs.h b/libs/vkd3d/vulkan_procs.h index 702cfd2..ec29eb4 100644 --- a/libs/vkd3d/vulkan_procs.h +++ b/libs/vkd3d/vulkan_procs.h @@ -178,8 +178,8 @@ VK_DEVICE_PFN(vkUpdateDescriptorSets) VK_DEVICE_PFN(vkWaitForFences) /* VK_KHR_draw_indirect_count */ -VK_DEVICE_EXT_PFN(vkCmdDrawIndirectCountKHR); -VK_DEVICE_EXT_PFN(vkCmdDrawIndexedIndirectCountKHR); +VK_DEVICE_EXT_PFN(vkCmdDrawIndirectCountKHR) +VK_DEVICE_EXT_PFN(vkCmdDrawIndexedIndirectCountKHR) /* VK_KHR_get_memory_requirements2 */ VK_DEVICE_EXT_PFN(vkGetBufferMemoryRequirements2KHR) -- 2.23.0

7 49