November 2020 - 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] include: add AV1 support to dxva.h
by Steve Lhomme Aug. 9, 2021

Aug. 9, 2021

Based on the DXVA AV1 specs https://www.microsoft.com/en-us/download/details.aspx?id=101577 The structures and the associated define are available in Windows SDK since at least 10.0.20231.0. The GUIDs were present in previous SDKs as well. --- include/dxva.h | 279 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 279 insertions(+) diff --git a/include/dxva.h b/include/dxva.h index 4f18f2e60da..b474bd87111 100644 --- a/include/dxva.h +++ b/include/dxva.h @@ -563,6 +563,285 @@ typedef struct _DXVA_Status_VPx USHORT wNumMbsAffected; } DXVA_Status_VPx, *LPDXVA_Status_VPx; + +#define _DIRECTX_AV1_VA_ + +/* AV1 decoder GUIDs */ +DEFINE_GUID(DXVA_ModeAV1_VLD_Profile0, 0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a); +DEFINE_GUID(DXVA_ModeAV1_VLD_Profile1, 0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08); +DEFINE_GUID(DXVA_ModeAV1_VLD_Profile2, 0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8); +DEFINE_GUID(DXVA_ModeAV1_VLD_12bit_Profile2, 0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0); +DEFINE_GUID(DXVA_ModeAV1_VLD_12bit_Profile2_420, 0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8); + +/* AV1 picture entry data structure */ +typedef struct _DXVA_PicEntry_AV1 { + UINT width; + UINT height; + + // Global motion parameters + INT wmmat[6]; + union { + struct { + UCHAR wminvalid : 1; + UCHAR wmtype : 2; + UCHAR Reserved : 5; + }; + UCHAR GlobalMotionFlags; + }; + UCHAR Index; + USHORT Reserved16Bits; +} DXVA_PicEntry_AV1, *LPDXVA_PicEntry_AV1; + +/* AV1 picture parameters data structure */ +typedef struct _DXVA_PicParams_AV1 { + UINT width; + UINT height; + + UINT max_width; + UINT max_height; + + UCHAR CurrPicTextureIndex; + UCHAR superres_denom; + UCHAR bitdepth; + UCHAR seq_profile; + + // Tiles: + struct { + UCHAR cols; + UCHAR rows; + USHORT context_update_id; + USHORT widths[64]; + USHORT heights[64]; + } tiles; + + // Coding Tools + union { + struct { + UINT use_128x128_superblock : 1; + UINT intra_edge_filter : 1; + UINT interintra_compound : 1; + UINT masked_compound : 1; + UINT warped_motion : 1; + UINT dual_filter : 1; + UINT jnt_comp : 1; + UINT screen_content_tools : 1; + UINT integer_mv : 1; + UINT cdef : 1; + UINT restoration : 1; + UINT film_grain : 1; + UINT intrabc : 1; + UINT high_precision_mv : 1; + UINT switchable_motion_mode : 1; + UINT filter_intra : 1; + UINT disable_frame_end_update_cdf : 1; + UINT disable_cdf_update : 1; + UINT reference_mode : 1; + UINT skip_mode : 1; + UINT reduced_tx_set : 1; + UINT superres : 1; + UINT tx_mode : 2; + UINT use_ref_frame_mvs : 1; + UINT enable_ref_frame_mvs : 1; + UINT reference_frame_update : 1; + UINT Reserved : 5; + }; + UINT32 CodingParamToolFlags; + } coding; + + // Format & Picture Info flags + union { + struct { + UCHAR frame_type : 2; + UCHAR show_frame : 1; + UCHAR showable_frame : 1; + UCHAR subsampling_x : 1; + UCHAR subsampling_y : 1; + UCHAR mono_chrome : 1; + UCHAR Reserved : 1; + }; + UCHAR FormatAndPictureInfoFlags; + } format; + + // References + UCHAR primary_ref_frame; + UCHAR order_hint; + UCHAR order_hint_bits; + + DXVA_PicEntry_AV1 frame_refs[7]; + UCHAR RefFrameMapTextureIndex[8]; + + // Loop filter parameters + struct { + UCHAR filter_level[2]; + UCHAR filter_level_u; + UCHAR filter_level_v; + + UCHAR sharpness_level; + union { + struct { + UCHAR mode_ref_delta_enabled : 1; + UCHAR mode_ref_delta_update : 1; + UCHAR delta_lf_multi : 1; + UCHAR delta_lf_present : 1; + UCHAR Reserved : 4; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + CHAR ref_deltas[8]; + CHAR mode_deltas[2]; + UCHAR delta_lf_res; + UCHAR frame_restoration_type[3]; + USHORT log2_restoration_unit_size[3]; + UINT16 Reserved16Bits; + } loop_filter; + + // Quantization + struct { + union { + struct { + UCHAR delta_q_present : 1; + UCHAR delta_q_res : 2; + UCHAR Reserved : 5; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + + UCHAR base_qindex; + CHAR y_dc_delta_q; + CHAR u_dc_delta_q; + CHAR v_dc_delta_q; + CHAR u_ac_delta_q; + CHAR v_ac_delta_q; + // using_qmatrix: + UCHAR qm_y; + UCHAR qm_u; + UCHAR qm_v; + UINT16 Reserved16Bits; + } quantization; + + // Cdef parameters + struct { + union { + struct { + UCHAR damping : 2; + UCHAR bits : 2; + UCHAR Reserved : 4; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + + union { + struct { + UCHAR primary : 6; + UCHAR secondary : 2; + }; + UCHAR combined; + } y_strengths[8]; + + union { + struct { + UCHAR primary : 6; + UCHAR secondary : 2; + }; + UCHAR combined; + } uv_strengths[8]; + + } cdef; + + UCHAR interp_filter; + + // Segmentation + struct { + union { + struct { + UCHAR enabled : 1; + UCHAR update_map : 1; + UCHAR update_data : 1; + UCHAR temporal_update : 1; + UCHAR Reserved : 4; + }; + UCHAR ControlFlags; + } DUMMYUNIONNAME; + UCHAR Reserved24Bits[3]; + + union { + struct { + UCHAR alt_q : 1; + UCHAR alt_lf_y_v : 1; + UCHAR alt_lf_y_h : 1; + UCHAR alt_lf_u : 1; + UCHAR alt_lf_v : 1; + UCHAR ref_frame : 1; + UCHAR skip : 1; + UCHAR globalmv : 1; + }; + UCHAR mask; + } feature_mask[8]; + + SHORT feature_data[8][8]; + + } segmentation; + + struct { + union { + struct { + USHORT apply_grain : 1; + USHORT scaling_shift_minus8 : 2; + USHORT chroma_scaling_from_luma : 1; + USHORT ar_coeff_lag : 2; + USHORT ar_coeff_shift_minus6 : 2; + USHORT grain_scale_shift : 2; + USHORT overlap_flag : 1; + USHORT clip_to_restricted_range : 1; + USHORT matrix_coeff_is_identity : 1; + USHORT Reserved : 3; + }; + USHORT ControlFlags; + } DUMMYUNIONNAME; + + USHORT grain_seed; + UCHAR scaling_points_y[14][2]; + UCHAR num_y_points; + UCHAR scaling_points_cb[10][2]; + UCHAR num_cb_points; + UCHAR scaling_points_cr[10][2]; + UCHAR num_cr_points; + UCHAR ar_coeffs_y[24]; + UCHAR ar_coeffs_cb[25]; + UCHAR ar_coeffs_cr[25]; + UCHAR cb_mult; + UCHAR cb_luma_mult; + UCHAR cr_mult; + UCHAR cr_luma_mult; + UCHAR Reserved8Bits; + SHORT cb_offset; + SHORT cr_offset; + } film_grain; + + UINT Reserved32Bits; + UINT StatusReportFeedbackNumber; +} DXVA_PicParams_AV1, *LPDXVA_PicParams_AV1; + +/* AV1 tile data structure */ +typedef struct _DXVA_Tile_AV1 { + UINT DataOffset; + UINT DataSize; + USHORT row; + USHORT column; + USHORT Reserved16Bits; + UCHAR anchor_frame; + UCHAR Reserved8Bits; +} DXVA_Tile_AV1, *LPDXVA_Tile_AV1; + +typedef struct _DXVA_Status_AV1 { + UINT StatusReportFeedbackNumber; + DXVA_PicEntry_AV1 CurrPic; + UCHAR bBufType; + UCHAR bStatus; + UCHAR bReserved8Bits; + USHORT wNumMbsAffected; +} DXVA_Status_AV1, *LPDXVA_Status_AV1; + #include <poppack.h> typedef enum _DXVA_VideoChromaSubsampling -- 2.26.2

4 7

[PATCH vkd3d] build: Make the default symbol visibility "hidden".
by Zebediah Figura July 12, 2021

July 12, 2021

We tag far fewer symbols this way. Signed-off-by: Zebediah Figura <zfigura(a)codeweavers.com> --- configure.ac | 1 + include/private/vkd3d_common.h | 6 + include/private/vkd3d_debug.h | 19 ++- include/private/vkd3d_memory.h | 3 +- include/private/vkd3d_utf8.h | 2 +- libs/vkd3d-common/debug.c | 2 +- libs/vkd3d-shader/dxbc.c | 6 +- libs/vkd3d-shader/vkd3d_shader_main.c | 24 +-- libs/vkd3d-shader/vkd3d_shader_private.h | 48 +++--- libs/vkd3d-utils/vkd3d_utils_main.c | 22 +-- libs/vkd3d/command.c | 6 +- libs/vkd3d/device.c | 16 +- libs/vkd3d/resource.c | 6 +- libs/vkd3d/utils.c | 4 +- libs/vkd3d/vkd3d_main.c | 10 +- libs/vkd3d/vkd3d_private.h | 188 +++++++++++------------ 16 files changed, 184 insertions(+), 179 deletions(-) diff --git a/configure.ac b/configure.ac index d5f6588..e9c135a 100644 --- a/configure.ac +++ b/configure.ac @@ -47,6 +47,7 @@ AC_SUBST([VKD3D_CFLAGS]) AS_IF([test "x${GCC}" = "xyes"], [VKD3D_CFLAGS="-Wall -pipe" VKD3D_CHECK_CFLAGS([-std=c99]) + VKD3D_CHECK_CFLAGS([-fvisibility=hidden]) VKD3D_CHECK_CFLAGS([-Wdeclaration-after-statement]) VKD3D_CHECK_CFLAGS([-Wimplicit-fallthrough]) VKD3D_CHECK_CFLAGS([-Wmissing-prototypes]) diff --git a/include/private/vkd3d_common.h b/include/private/vkd3d_common.h index ac217e9..fd62ae8 100644 --- a/include/private/vkd3d_common.h +++ b/include/private/vkd3d_common.h @@ -53,6 +53,12 @@ static inline size_t align(size_t addr, size_t alignment) # define VKD3D_UNUSED #endif /* __GNUC__ */ +#if defined(__GNUC__) && !defined(__MINGW32__) +# define VKD3D_API __attribute__((visibility("default"))) +#else +# define VKD3D_API +#endif + static inline unsigned int vkd3d_popcount(unsigned int v) { #ifdef _MSC_VER diff --git a/include/private/vkd3d_debug.h b/include/private/vkd3d_debug.h index c37c841..a206a92 100644 --- a/include/private/vkd3d_debug.h +++ b/include/private/vkd3d_debug.h @@ -44,15 +44,14 @@ enum vkd3d_dbg_level VKD3D_DBG_LEVEL_TRACE, }; -enum vkd3d_dbg_level vkd3d_dbg_get_level(void) DECLSPEC_HIDDEN; +enum vkd3d_dbg_level vkd3d_dbg_get_level(void); -void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, - const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; +void vkd3d_dbg_printf(enum vkd3d_dbg_level level, const char *function, const char *fmt, ...) VKD3D_PRINTF_FUNC(3, 4); -const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2) DECLSPEC_HIDDEN; -const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args) DECLSPEC_HIDDEN; -const char *debugstr_a(const char *str) DECLSPEC_HIDDEN; -const char *debugstr_w(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN; +const char *vkd3d_dbg_sprintf(const char *fmt, ...) VKD3D_PRINTF_FUNC(1, 2); +const char *vkd3d_dbg_vsprintf(const char *fmt, va_list args); +const char *debugstr_a(const char *str); +const char *debugstr_w(const WCHAR *wstr, size_t wchar_size); #define VKD3D_DBG_LOG(level) \ do { \ @@ -103,7 +102,7 @@ static inline const char *debugstr_guid(const GUID *guid) guid->Data4[5], guid->Data4[6], guid->Data4[7]); } -unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value) DECLSPEC_HIDDEN; +unsigned int vkd3d_env_var_as_uint(const char *name, unsigned int default_value); struct vkd3d_debug_option { @@ -111,8 +110,8 @@ struct vkd3d_debug_option uint64_t flag; }; -bool vkd3d_debug_list_has_member(const char *string, const char *member) DECLSPEC_HIDDEN; +bool vkd3d_debug_list_has_member(const char *string, const char *member); uint64_t vkd3d_parse_debug_options(const char *string, - const struct vkd3d_debug_option *options, unsigned int option_count) DECLSPEC_HIDDEN; + const struct vkd3d_debug_option *options, unsigned int option_count); #endif /* __VKD3D_DEBUG_H */ diff --git a/include/private/vkd3d_memory.h b/include/private/vkd3d_memory.h index df93abf..8bbc691 100644 --- a/include/private/vkd3d_memory.h +++ b/include/private/vkd3d_memory.h @@ -54,7 +54,6 @@ static inline void vkd3d_free(void *ptr) free(ptr); } -bool vkd3d_array_reserve(void **elements, size_t *capacity, - size_t element_count, size_t element_size) DECLSPEC_HIDDEN; +bool vkd3d_array_reserve(void **elements, size_t *capacity, size_t element_count, size_t element_size); #endif /* __VKD3D_MEMORY_H */ diff --git a/include/private/vkd3d_utf8.h b/include/private/vkd3d_utf8.h index ab32884..ccb9e17 100644 --- a/include/private/vkd3d_utf8.h +++ b/include/private/vkd3d_utf8.h @@ -21,6 +21,6 @@ #include "vkd3d_common.h" -char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size) DECLSPEC_HIDDEN; +char *vkd3d_strdup_w_utf8(const WCHAR *wstr, size_t wchar_size); #endif /* __VKD3D_UTF8_H */ diff --git a/libs/vkd3d-common/debug.c b/libs/vkd3d-common/debug.c index 33deed6..a4d5a3d 100644 --- a/libs/vkd3d-common/debug.c +++ b/libs/vkd3d-common/debug.c @@ -31,7 +31,7 @@ #define VKD3D_DEBUG_BUFFER_COUNT 64 #define VKD3D_DEBUG_BUFFER_SIZE 512 -extern const char *vkd3d_dbg_env_name DECLSPEC_HIDDEN; +extern const char *vkd3d_dbg_env_name; static const char *debug_level_names[] = { diff --git a/libs/vkd3d-shader/dxbc.c b/libs/vkd3d-shader/dxbc.c index 973a80d..231c48b 100644 --- a/libs/vkd3d-shader/dxbc.c +++ b/libs/vkd3d-shader/dxbc.c @@ -2726,7 +2726,7 @@ static int rts0_handler(const char *data, DWORD data_size, DWORD tag, void *cont return shader_parse_root_signature(data, data_size, desc); } -int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc, +VKD3D_API int vkd3d_shader_parse_root_signature(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_versioned_root_signature_desc *root_signature, char **messages) { struct vkd3d_shader_message_context message_context; @@ -3288,7 +3288,7 @@ static int validate_root_signature_desc(const struct vkd3d_shader_versioned_root return ret; } -int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature, +VKD3D_API int vkd3d_shader_serialize_root_signature(const struct vkd3d_shader_versioned_root_signature_desc *root_signature, struct vkd3d_shader_code *dxbc, char **messages) { struct root_signature_writer_context context; @@ -3592,7 +3592,7 @@ fail: return ret; } -int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst, +VKD3D_API int vkd3d_shader_convert_root_signature(struct vkd3d_shader_versioned_root_signature_desc *dst, enum vkd3d_shader_root_signature_version version, const struct vkd3d_shader_versioned_root_signature_desc *src) { int ret; diff --git a/libs/vkd3d-shader/vkd3d_shader_main.c b/libs/vkd3d-shader/vkd3d_shader_main.c index 16d895f..4d49eef 100644 --- a/libs/vkd3d-shader/vkd3d_shader_main.c +++ b/libs/vkd3d-shader/vkd3d_shader_main.c @@ -292,14 +292,14 @@ static int vkd3d_shader_validate_compile_info(const struct vkd3d_shader_compile_ return VKD3D_OK; } -void vkd3d_shader_free_messages(char *messages) +VKD3D_API void vkd3d_shader_free_messages(char *messages) { TRACE("messages %p.\n", messages); vkd3d_free(messages); } -int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, +VKD3D_API int vkd3d_shader_compile(const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *out, char **messages) { struct vkd3d_shader_scan_descriptor_info scan_descriptor_info; @@ -837,7 +837,7 @@ static int vkd3d_shader_scan_instruction(struct vkd3d_shader_scan_context *conte return VKD3D_OK; } -int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages) +VKD3D_API int vkd3d_shader_scan(const struct vkd3d_shader_compile_info *compile_info, char **messages) { struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info; struct vkd3d_shader_message_context *message_context; @@ -912,14 +912,14 @@ done: return ret; } -void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) +VKD3D_API void vkd3d_shader_free_scan_descriptor_info(struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info) { TRACE("scan_descriptor_info %p.\n", scan_descriptor_info); vkd3d_free(scan_descriptor_info->descriptors); } -void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code) +VKD3D_API void vkd3d_shader_free_shader_code(struct vkd3d_shader_code *shader_code) { TRACE("shader_code %p.\n", shader_code); @@ -960,7 +960,7 @@ static void vkd3d_shader_free_root_signature_v_1_1(struct vkd3d_shader_root_sign memset(root_signature, 0, sizeof(*root_signature)); } -void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *desc) +VKD3D_API void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signature_desc *desc) { TRACE("desc %p.\n", desc); @@ -981,7 +981,7 @@ void vkd3d_shader_free_root_signature(struct vkd3d_shader_versioned_root_signatu desc->version = 0; } -int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, +VKD3D_API int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, struct vkd3d_shader_signature *signature, char **messages) { struct vkd3d_shader_message_context message_context; @@ -1004,7 +1004,7 @@ int vkd3d_shader_parse_input_signature(const struct vkd3d_shader_code *dxbc, return ret; } -struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element( +VKD3D_API struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element( const struct vkd3d_shader_signature *signature, const char *semantic_name, unsigned int semantic_index, unsigned int stream_index) { @@ -1026,7 +1026,7 @@ struct vkd3d_shader_signature_element *vkd3d_shader_find_signature_element( return NULL; } -void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature) +VKD3D_API void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature) { TRACE("signature %p.\n", signature); @@ -1034,7 +1034,7 @@ void vkd3d_shader_free_shader_signature(struct vkd3d_shader_signature *signature signature->elements = NULL; } -const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor) +VKD3D_API const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor) { int x, y; @@ -1052,7 +1052,7 @@ const char *vkd3d_shader_get_version(unsigned int *major, unsigned int *minor) return "vkd3d-shader " PACKAGE_VERSION VKD3D_VCS_ID; } -const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count) +VKD3D_API const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(unsigned int *count) { static const enum vkd3d_shader_source_type types[] = { @@ -1065,7 +1065,7 @@ const enum vkd3d_shader_source_type *vkd3d_shader_get_supported_source_types(uns return types; } -const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types( +VKD3D_API const enum vkd3d_shader_target_type *vkd3d_shader_get_supported_target_types( enum vkd3d_shader_source_type source_type, unsigned int *count) { static const enum vkd3d_shader_target_type dxbc_tpf_types[] = diff --git a/libs/vkd3d-shader/vkd3d_shader_private.h b/libs/vkd3d-shader/vkd3d_shader_private.h index 1acb01f..1291148 100644 --- a/libs/vkd3d-shader/vkd3d_shader_private.h +++ b/libs/vkd3d-shader/vkd3d_shader_private.h @@ -809,18 +809,18 @@ static inline bool vkd3d_shader_register_is_output(const struct vkd3d_shader_reg return reg->type == VKD3DSPR_OUTPUT || reg->type == VKD3DSPR_COLOROUT; } -void vkd3d_shader_trace(void *data) DECLSPEC_HIDDEN; +void vkd3d_shader_trace(void *data); -const char *shader_get_type_prefix(enum vkd3d_shader_type type) DECLSPEC_HIDDEN; +const char *shader_get_type_prefix(enum vkd3d_shader_type type); void *shader_sm4_init(const DWORD *byte_code, size_t byte_code_size, - const struct vkd3d_shader_signature *output_signature) DECLSPEC_HIDDEN; -void shader_sm4_free(void *data) DECLSPEC_HIDDEN; + const struct vkd3d_shader_signature *output_signature); +void shader_sm4_free(void *data); void shader_sm4_read_header(void *data, const DWORD **ptr, - struct vkd3d_shader_version *shader_version) DECLSPEC_HIDDEN; + struct vkd3d_shader_version *shader_version); void shader_sm4_read_instruction(void *data, const DWORD **ptr, - struct vkd3d_shader_instruction *ins) DECLSPEC_HIDDEN; -bool shader_sm4_is_end(void *data, const DWORD **ptr) DECLSPEC_HIDDEN; + struct vkd3d_shader_instruction *ins); +bool shader_sm4_is_end(void *data, const DWORD **ptr); struct vkd3d_string_buffer { @@ -829,9 +829,9 @@ struct vkd3d_string_buffer unsigned int content_size; }; -void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN; -bool vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer) DECLSPEC_HIDDEN; -int vkd3d_string_buffer_vprintf(struct vkd3d_string_buffer *buffer, const char *format, va_list args) DECLSPEC_HIDDEN; +void vkd3d_string_buffer_cleanup(struct vkd3d_string_buffer *buffer); +bool vkd3d_string_buffer_init(struct vkd3d_string_buffer *buffer); +int vkd3d_string_buffer_vprintf(struct vkd3d_string_buffer *buffer, const char *format, va_list args); struct vkd3d_shader_message_context { @@ -841,39 +841,39 @@ struct vkd3d_shader_message_context struct vkd3d_string_buffer messages; }; -void vkd3d_shader_message_context_cleanup(struct vkd3d_shader_message_context *context) DECLSPEC_HIDDEN; -char *vkd3d_shader_message_context_copy_messages(struct vkd3d_shader_message_context *context) DECLSPEC_HIDDEN; +void vkd3d_shader_message_context_cleanup(struct vkd3d_shader_message_context *context); +char *vkd3d_shader_message_context_copy_messages(struct vkd3d_shader_message_context *context); bool vkd3d_shader_message_context_init(struct vkd3d_shader_message_context *context, - enum vkd3d_shader_log_level log_level, const char *source_name) DECLSPEC_HIDDEN; + enum vkd3d_shader_log_level log_level, const char *source_name); void vkd3d_shader_message_context_trace_messages_(const struct vkd3d_shader_message_context *context, - const char *function) DECLSPEC_HIDDEN; + const char *function); #define vkd3d_shader_message_context_trace_messages(context) \ vkd3d_shader_message_context_trace_messages_(context, __FUNCTION__) void vkd3d_shader_error(struct vkd3d_shader_message_context *context, enum vkd3d_shader_error error, - const char *format, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; + const char *format, ...) VKD3D_PRINTF_FUNC(3, 4); void vkd3d_shader_verror(struct vkd3d_shader_message_context *context, - enum vkd3d_shader_error error, const char *format, va_list args) DECLSPEC_HIDDEN; + enum vkd3d_shader_error error, const char *format, va_list args); int shader_extract_from_dxbc(const void *dxbc, size_t dxbc_length, - struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN; -void free_shader_desc(struct vkd3d_shader_desc *desc) DECLSPEC_HIDDEN; + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_desc *desc); +void free_shader_desc(struct vkd3d_shader_desc *desc); int shader_parse_input_signature(const void *dxbc, size_t dxbc_length, - struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature) DECLSPEC_HIDDEN; + struct vkd3d_shader_message_context *message_context, struct vkd3d_shader_signature *signature); struct vkd3d_dxbc_compiler; struct vkd3d_dxbc_compiler *vkd3d_dxbc_compiler_create(const struct vkd3d_shader_version *shader_version, const struct vkd3d_shader_desc *shader_desc, const struct vkd3d_shader_compile_info *compile_info, const struct vkd3d_shader_scan_descriptor_info *scan_descriptor_info, - struct vkd3d_shader_message_context *message_context) DECLSPEC_HIDDEN; + struct vkd3d_shader_message_context *message_context); int vkd3d_dxbc_compiler_handle_instruction(struct vkd3d_dxbc_compiler *compiler, - const struct vkd3d_shader_instruction *instruction) DECLSPEC_HIDDEN; + const struct vkd3d_shader_instruction *instruction); int vkd3d_dxbc_compiler_generate_spirv(struct vkd3d_dxbc_compiler *compiler, - const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv) DECLSPEC_HIDDEN; -void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler) DECLSPEC_HIDDEN; + const struct vkd3d_shader_compile_info *compile_info, struct vkd3d_shader_code *spirv); +void vkd3d_dxbc_compiler_destroy(struct vkd3d_dxbc_compiler *compiler); -void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4]) DECLSPEC_HIDDEN; +void vkd3d_compute_dxbc_checksum(const void *dxbc, size_t size, uint32_t checksum[4]); static inline enum vkd3d_shader_component_type vkd3d_component_type_from_data_type( enum vkd3d_data_type data_type) diff --git a/libs/vkd3d-utils/vkd3d_utils_main.c b/libs/vkd3d-utils/vkd3d_utils_main.c index c19fe7f..b64693e 100644 --- a/libs/vkd3d-utils/vkd3d_utils_main.c +++ b/libs/vkd3d-utils/vkd3d_utils_main.c @@ -21,14 +21,14 @@ VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG"); -HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug) +VKD3D_API HRESULT WINAPI D3D12GetDebugInterface(REFIID iid, void **debug) { FIXME("iid %s, debug %p stub!\n", debugstr_guid(iid), debug); return E_NOTIMPL; } -HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, +VKD3D_API HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device, enum vkd3d_api_version api_version) { struct vkd3d_optional_instance_extensions_info optional_extensions_info; @@ -85,13 +85,13 @@ HRESULT WINAPI D3D12CreateDeviceVKD3D(IUnknown *adapter, D3D_FEATURE_LEVEL minim return vkd3d_create_device(&device_create_info, iid, device); } -HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, +VKD3D_API HRESULT WINAPI D3D12CreateDevice(IUnknown *adapter, D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device) { return D3D12CreateDeviceVKD3D(adapter, minimum_feature_level, iid, device, VKD3D_API_VERSION_1_0); } -HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { TRACE("data %p, data_size %lu, iid %s, deserializer %p.\n", @@ -100,7 +100,7 @@ HRESULT WINAPI D3D12CreateRootSignatureDeserializer(const void *data, SIZE_T dat return vkd3d_create_root_signature_deserializer(data, data_size, iid, deserializer); } -HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, SIZE_T data_size, REFIID iid,void **deserializer) { TRACE("data %p, data_size %lu, iid %s, deserializer %p.\n", @@ -109,7 +109,7 @@ HRESULT WINAPI D3D12CreateVersionedRootSignatureDeserializer(const void *data, S return vkd3d_create_versioned_root_signature_deserializer(data, data_size, iid, deserializer); } -HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc, D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob) { TRACE("desc %p, version %#x, blob %p, error_blob %p.\n", desc, version, blob, error_blob); @@ -117,7 +117,7 @@ HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *desc return vkd3d_serialize_root_signature(desc, version, blob, error_blob); } -HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob) { TRACE("desc %p, blob %p, error_blob %p.\n", desc, blob, error_blob); @@ -126,7 +126,7 @@ HRESULT WINAPI D3D12SerializeVersionedRootSignature(const D3D12_VERSIONED_ROOT_S } /* Events */ -HANDLE vkd3d_create_event(void) +VKD3D_API HANDLE vkd3d_create_event(void) { struct vkd3d_event *event; int rc; @@ -157,7 +157,7 @@ HANDLE vkd3d_create_event(void) return event; } -unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds) +VKD3D_API unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds) { struct vkd3d_event *impl = event; int rc; @@ -200,7 +200,7 @@ unsigned int vkd3d_wait_event(HANDLE event, unsigned int milliseconds) return VKD3D_WAIT_FAILED; } -HRESULT vkd3d_signal_event(HANDLE event) +VKD3D_API HRESULT vkd3d_signal_event(HANDLE event) { struct vkd3d_event *impl = event; int rc; @@ -219,7 +219,7 @@ HRESULT vkd3d_signal_event(HANDLE event) return S_OK; } -void vkd3d_destroy_event(HANDLE event) +VKD3D_API void vkd3d_destroy_event(HANDLE event) { struct vkd3d_event *impl = event; int rc; diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index e5c6791..4ff510a 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -6251,21 +6251,21 @@ HRESULT d3d12_command_queue_create(struct d3d12_device *device, return S_OK; } -uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue) +VKD3D_API uint32_t vkd3d_get_vk_queue_family_index(ID3D12CommandQueue *queue) { struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue); return d3d12_queue->vkd3d_queue->vk_family_index; } -VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue) +VKD3D_API VkQueue vkd3d_acquire_vk_queue(ID3D12CommandQueue *queue) { struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue); return vkd3d_queue_acquire(d3d12_queue->vkd3d_queue); } -void vkd3d_release_vk_queue(ID3D12CommandQueue *queue) +VKD3D_API void vkd3d_release_vk_queue(ID3D12CommandQueue *queue) { struct d3d12_command_queue *d3d12_queue = impl_from_ID3D12CommandQueue(queue); diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index bef6477..38d3d56 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -589,7 +589,7 @@ static HRESULT vkd3d_instance_init(struct vkd3d_instance *instance, return S_OK; } -HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info, +VKD3D_API HRESULT vkd3d_create_instance(const struct vkd3d_instance_create_info *create_info, struct vkd3d_instance **instance) { struct vkd3d_instance *object; @@ -637,7 +637,7 @@ static void vkd3d_destroy_instance(struct vkd3d_instance *instance) vkd3d_free(instance); } -ULONG vkd3d_instance_incref(struct vkd3d_instance *instance) +VKD3D_API ULONG vkd3d_instance_incref(struct vkd3d_instance *instance) { ULONG refcount = InterlockedIncrement(&instance->refcount); @@ -646,7 +646,7 @@ ULONG vkd3d_instance_incref(struct vkd3d_instance *instance) return refcount; } -ULONG vkd3d_instance_decref(struct vkd3d_instance *instance) +VKD3D_API ULONG vkd3d_instance_decref(struct vkd3d_instance *instance) { ULONG refcount = InterlockedDecrement(&instance->refcount); @@ -658,7 +658,7 @@ ULONG vkd3d_instance_decref(struct vkd3d_instance *instance) return refcount; } -VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance) +VKD3D_API VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance) { return instance->vk_instance; } @@ -3828,28 +3828,28 @@ HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_ha return hr; } -IUnknown *vkd3d_get_device_parent(ID3D12Device *device) +VKD3D_API IUnknown *vkd3d_get_device_parent(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); return d3d12_device->parent; } -VkDevice vkd3d_get_vk_device(ID3D12Device *device) +VKD3D_API VkDevice vkd3d_get_vk_device(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); return d3d12_device->vk_device; } -VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device) +VKD3D_API VkPhysicalDevice vkd3d_get_vk_physical_device(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); return d3d12_device->vk_physical_device; } -struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device) +VKD3D_API struct vkd3d_instance *vkd3d_instance_from_device(ID3D12Device *device) { struct d3d12_device *d3d12_device = impl_from_ID3D12Device(device); diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index a9d4d46..a432806 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1983,7 +1983,7 @@ HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, return S_OK; } -HRESULT vkd3d_create_image_resource(ID3D12Device *device, +VKD3D_API HRESULT vkd3d_create_image_resource(ID3D12Device *device, const struct vkd3d_image_resource_create_info *create_info, ID3D12Resource **resource) { struct d3d12_device *d3d12_device = unsafe_impl_from_ID3D12Device(device); @@ -2035,13 +2035,13 @@ HRESULT vkd3d_create_image_resource(ID3D12Device *device, return S_OK; } -ULONG vkd3d_resource_incref(ID3D12Resource *resource) +VKD3D_API ULONG vkd3d_resource_incref(ID3D12Resource *resource) { TRACE("resource %p.\n", resource); return d3d12_resource_incref(impl_from_ID3D12Resource(resource)); } -ULONG vkd3d_resource_decref(ID3D12Resource *resource) +VKD3D_API ULONG vkd3d_resource_decref(ID3D12Resource *resource) { TRACE("resource %p.\n", resource); return d3d12_resource_decref(impl_from_ID3D12Resource(resource)); diff --git a/libs/vkd3d/utils.c b/libs/vkd3d/utils.c index 7abfd42..ea11f3a 100644 --- a/libs/vkd3d/utils.c +++ b/libs/vkd3d/utils.c @@ -506,7 +506,7 @@ void vkd3d_format_copy_data(const struct vkd3d_format *format, const uint8_t *sr } } -VkFormat vkd3d_get_vk_format(DXGI_FORMAT format) +VKD3D_API VkFormat vkd3d_get_vk_format(DXGI_FORMAT format) { const struct vkd3d_format *vkd3d_format; @@ -516,7 +516,7 @@ VkFormat vkd3d_get_vk_format(DXGI_FORMAT format) return vkd3d_format->vk_format; } -DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format) +VKD3D_API DXGI_FORMAT vkd3d_get_dxgi_format(VkFormat format) { DXGI_FORMAT dxgi_format; VkFormat vk_format; diff --git a/libs/vkd3d/vkd3d_main.c b/libs/vkd3d/vkd3d_main.c index 327cdf8..4c0d6c5 100644 --- a/libs/vkd3d/vkd3d_main.c +++ b/libs/vkd3d/vkd3d_main.c @@ -21,7 +21,7 @@ VKD3D_DEBUG_ENV_NAME("VKD3D_DEBUG"); -HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info, +VKD3D_API HRESULT vkd3d_create_device(const struct vkd3d_device_create_info *create_info, REFIID iid, void **device) { struct vkd3d_instance *instance; @@ -216,7 +216,7 @@ static HRESULT d3d12_root_signature_deserializer_init(struct d3d12_root_signatur return S_OK; } -HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT vkd3d_create_root_signature_deserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { struct vkd3d_shader_code dxbc = {data, data_size}; @@ -400,7 +400,7 @@ static HRESULT d3d12_versioned_root_signature_deserializer_init(struct d3d12_ver return S_OK; } -HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size, +VKD3D_API HRESULT vkd3d_create_versioned_root_signature_deserializer(const void *data, SIZE_T data_size, REFIID iid, void **deserializer) { struct d3d12_versioned_root_signature_deserializer *object; @@ -537,7 +537,7 @@ static HRESULT d3d_blob_create(void *buffer, SIZE_T size, struct d3d_blob **blob return S_OK; } -HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc, D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob) { struct vkd3d_shader_versioned_root_signature_desc vkd3d_desc; @@ -592,7 +592,7 @@ HRESULT vkd3d_serialize_root_signature(const D3D12_ROOT_SIGNATURE_DESC *desc, return S_OK; } -HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, +VKD3D_API HRESULT vkd3d_serialize_versioned_root_signature(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *desc, ID3DBlob **blob, ID3DBlob **error_blob) { const struct vkd3d_shader_versioned_root_signature_desc *vkd3d_desc; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 9f0982d..54077f9 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -82,9 +82,9 @@ struct vkd3d_vk_device_procs }; #undef DECLARE_VK_PFN -HRESULT hresult_from_errno(int rc) DECLSPEC_HIDDEN; -HRESULT hresult_from_vk_result(VkResult vr) DECLSPEC_HIDDEN; -HRESULT hresult_from_vkd3d_result(int vkd3d_result) DECLSPEC_HIDDEN; +HRESULT hresult_from_errno(int rc); +HRESULT hresult_from_vk_result(VkResult vr); +HRESULT hresult_from_vkd3d_result(int vkd3d_result); struct vkd3d_vulkan_info { @@ -161,8 +161,8 @@ union vkd3d_thread_handle }; HRESULT vkd3d_create_thread(struct vkd3d_instance *instance, - PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread) DECLSPEC_HIDDEN; -HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_handle *thread) DECLSPEC_HIDDEN; + PFN_vkd3d_thread thread_main, void *data, union vkd3d_thread_handle *thread); +HRESULT vkd3d_join_thread(struct vkd3d_instance *instance, union vkd3d_thread_handle *thread); struct vkd3d_waiting_fence { @@ -199,9 +199,9 @@ struct vkd3d_fence_worker }; HRESULT vkd3d_fence_worker_start(struct vkd3d_fence_worker *worker, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); HRESULT vkd3d_fence_worker_stop(struct vkd3d_fence_worker *worker, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); struct vkd3d_gpu_va_allocation { @@ -230,11 +230,11 @@ struct vkd3d_gpu_va_allocator }; D3D12_GPU_VIRTUAL_ADDRESS vkd3d_gpu_va_allocator_allocate(struct vkd3d_gpu_va_allocator *allocator, - size_t alignment, size_t size, void *ptr) DECLSPEC_HIDDEN; + size_t alignment, size_t size, void *ptr); void *vkd3d_gpu_va_allocator_dereference(struct vkd3d_gpu_va_allocator *allocator, - D3D12_GPU_VIRTUAL_ADDRESS address) DECLSPEC_HIDDEN; + D3D12_GPU_VIRTUAL_ADDRESS address); void vkd3d_gpu_va_allocator_free(struct vkd3d_gpu_va_allocator *allocator, - D3D12_GPU_VIRTUAL_ADDRESS address) DECLSPEC_HIDDEN; + D3D12_GPU_VIRTUAL_ADDRESS address); struct vkd3d_render_pass_key { @@ -257,11 +257,11 @@ struct vkd3d_render_pass_cache }; void vkd3d_render_pass_cache_cleanup(struct vkd3d_render_pass_cache *cache, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); HRESULT vkd3d_render_pass_cache_find(struct vkd3d_render_pass_cache *cache, struct d3d12_device *device, const struct vkd3d_render_pass_key *key, - VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN; -void vkd3d_render_pass_cache_init(struct vkd3d_render_pass_cache *cache) DECLSPEC_HIDDEN; + VkRenderPass *vk_render_pass); +void vkd3d_render_pass_cache_init(struct vkd3d_render_pass_cache *cache); struct vkd3d_private_store { @@ -317,11 +317,11 @@ static inline void vkd3d_private_store_destroy(struct vkd3d_private_store *store } HRESULT vkd3d_get_private_data(struct vkd3d_private_store *store, - const GUID *tag, unsigned int *out_size, void *out) DECLSPEC_HIDDEN; + const GUID *tag, unsigned int *out_size, void *out); HRESULT vkd3d_set_private_data(struct vkd3d_private_store *store, - const GUID *tag, unsigned int data_size, const void *data) DECLSPEC_HIDDEN; + const GUID *tag, unsigned int data_size, const void *data); HRESULT vkd3d_set_private_data_interface(struct vkd3d_private_store *store, - const GUID *tag, const IUnknown *object) DECLSPEC_HIDDEN; + const GUID *tag, const IUnknown *object); struct vkd3d_signaled_semaphore { @@ -362,7 +362,7 @@ struct d3d12_fence }; HRESULT d3d12_fence_create(struct d3d12_device *device, - uint64_t initial_value, D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence) DECLSPEC_HIDDEN; + uint64_t initial_value, D3D12_FENCE_FLAGS flags, struct d3d12_fence **fence); /* ID3D12Heap */ struct d3d12_heap @@ -386,8 +386,8 @@ struct d3d12_heap }; HRESULT d3d12_heap_create(struct d3d12_device *device, const D3D12_HEAP_DESC *desc, - const struct d3d12_resource *resource, struct d3d12_heap **heap) DECLSPEC_HIDDEN; -struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface) DECLSPEC_HIDDEN; + const struct d3d12_resource *resource, struct d3d12_heap **heap); +struct d3d12_heap *unsafe_impl_from_ID3D12Heap(ID3D12Heap *iface); #define VKD3D_RESOURCE_PUBLIC_FLAGS \ (VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION) @@ -435,29 +435,29 @@ static inline bool d3d12_resource_is_texture(const struct d3d12_resource *resour return resource->desc.Dimension != D3D12_RESOURCE_DIMENSION_BUFFER; } -bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource) DECLSPEC_HIDDEN; -HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device) DECLSPEC_HIDDEN; +bool d3d12_resource_is_cpu_accessible(const struct d3d12_resource *resource); +HRESULT d3d12_resource_validate_desc(const D3D12_RESOURCE_DESC *desc, struct d3d12_device *device); HRESULT d3d12_committed_resource_create(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); HRESULT d3d12_placed_resource_create(struct d3d12_device *device, struct d3d12_heap *heap, uint64_t heap_offset, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); HRESULT d3d12_reserved_resource_create(struct d3d12_device *device, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_state, - const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource) DECLSPEC_HIDDEN; -struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface) DECLSPEC_HIDDEN; + const D3D12_CLEAR_VALUE *optimized_clear_value, struct d3d12_resource **resource); +struct d3d12_resource *unsafe_impl_from_ID3D12Resource(ID3D12Resource *iface); HRESULT vkd3d_allocate_buffer_memory(struct d3d12_device *device, VkBuffer vk_buffer, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size) DECLSPEC_HIDDEN; + VkDeviceMemory *vk_memory, uint32_t *vk_memory_type, VkDeviceSize *vk_memory_size); HRESULT vkd3d_create_buffer(struct d3d12_device *device, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags, - const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer) DECLSPEC_HIDDEN; + const D3D12_RESOURCE_DESC *desc, VkBuffer *vk_buffer); HRESULT vkd3d_get_image_allocation_info(struct d3d12_device *device, - const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info) DECLSPEC_HIDDEN; + const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_ALLOCATION_INFO *allocation_info); enum vkd3d_view_type { @@ -495,8 +495,8 @@ struct vkd3d_view } info; }; -void vkd3d_view_decref(struct vkd3d_view *view, struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_view_incref(struct vkd3d_view *view) DECLSPEC_HIDDEN; +void vkd3d_view_decref(struct vkd3d_view *view, struct d3d12_device *device); +void vkd3d_view_incref(struct vkd3d_view *view); struct vkd3d_texture_view_desc { @@ -511,9 +511,9 @@ struct vkd3d_texture_view_desc }; bool vkd3d_create_buffer_view(struct d3d12_device *device, VkBuffer vk_buffer, const struct vkd3d_format *format, - VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view) DECLSPEC_HIDDEN; + VkDeviceSize offset, VkDeviceSize size, struct vkd3d_view **view); bool vkd3d_create_texture_view(struct d3d12_device *device, VkImage vk_image, - const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view) DECLSPEC_HIDDEN; + const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view); struct d3d12_desc { @@ -537,24 +537,24 @@ static inline struct d3d12_desc *d3d12_desc_from_gpu_handle(D3D12_GPU_DESCRIPTOR } void d3d12_desc_copy(struct d3d12_desc *dst, const struct d3d12_desc *src, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); void d3d12_desc_create_cbv(struct d3d12_desc *descriptor, - struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_device *device, const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc); void d3d12_desc_create_srv(struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, - const D3D12_SHADER_RESOURCE_VIEW_DESC *desc) DECLSPEC_HIDDEN; + const D3D12_SHADER_RESOURCE_VIEW_DESC *desc); void d3d12_desc_create_uav(struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, struct d3d12_resource *counter_resource, - const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc) DECLSPEC_HIDDEN; + const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc); void d3d12_desc_create_sampler(struct d3d12_desc *sampler, - struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_device *device, const D3D12_SAMPLER_DESC *desc); void d3d12_desc_write_atomic(struct d3d12_desc *dst, const struct d3d12_desc *src, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); bool vkd3d_create_raw_buffer_view(struct d3d12_device *device, - D3D12_GPU_VIRTUAL_ADDRESS gpu_address, VkBufferView *vk_buffer_view) DECLSPEC_HIDDEN; + D3D12_GPU_VIRTUAL_ADDRESS gpu_address, VkBufferView *vk_buffer_view); HRESULT vkd3d_create_static_sampler(struct d3d12_device *device, - const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler) DECLSPEC_HIDDEN; + const D3D12_STATIC_SAMPLER_DESC *desc, VkSampler *vk_sampler); struct d3d12_rtv_desc { @@ -574,7 +574,7 @@ static inline struct d3d12_rtv_desc *d3d12_rtv_desc_from_cpu_handle(D3D12_CPU_DE } void d3d12_rtv_desc_create_rtv(struct d3d12_rtv_desc *rtv_desc, struct d3d12_device *device, - struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_resource *resource, const D3D12_RENDER_TARGET_VIEW_DESC *desc); struct d3d12_dsv_desc { @@ -594,7 +594,7 @@ static inline struct d3d12_dsv_desc *d3d12_dsv_desc_from_cpu_handle(D3D12_CPU_DE } void d3d12_dsv_desc_create_dsv(struct d3d12_dsv_desc *dsv_desc, struct d3d12_device *device, - struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc) DECLSPEC_HIDDEN; + struct d3d12_resource *resource, const D3D12_DEPTH_STENCIL_VIEW_DESC *desc); /* ID3D12DescriptorHeap */ struct d3d12_descriptor_heap @@ -612,7 +612,7 @@ struct d3d12_descriptor_heap }; HRESULT d3d12_descriptor_heap_create(struct d3d12_device *device, - const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap) DECLSPEC_HIDDEN; + const D3D12_DESCRIPTOR_HEAP_DESC *desc, struct d3d12_descriptor_heap **descriptor_heap); /* ID3D12QueryHeap */ struct d3d12_query_heap @@ -630,8 +630,8 @@ struct d3d12_query_heap }; HRESULT d3d12_query_heap_create(struct d3d12_device *device, const D3D12_QUERY_HEAP_DESC *desc, - struct d3d12_query_heap **heap) DECLSPEC_HIDDEN; -struct d3d12_query_heap *unsafe_impl_from_ID3D12QueryHeap(ID3D12QueryHeap *iface) DECLSPEC_HIDDEN; + struct d3d12_query_heap **heap); +struct d3d12_query_heap *unsafe_impl_from_ID3D12QueryHeap(ID3D12QueryHeap *iface); /* A Vulkan query has to be issued at least one time before the result is * available. In D3D12 it is legal to get query reults for not issued queries. @@ -731,11 +731,11 @@ struct d3d12_root_signature }; HRESULT d3d12_root_signature_create(struct d3d12_device *device, const void *bytecode, - size_t bytecode_length, struct d3d12_root_signature **root_signature) DECLSPEC_HIDDEN; -struct d3d12_root_signature *unsafe_impl_from_ID3D12RootSignature(ID3D12RootSignature *iface) DECLSPEC_HIDDEN; + size_t bytecode_length, struct d3d12_root_signature **root_signature); +struct d3d12_root_signature *unsafe_impl_from_ID3D12RootSignature(ID3D12RootSignature *iface); int vkd3d_parse_root_signature_v_1_0(const struct vkd3d_shader_code *dxbc, - struct vkd3d_shader_versioned_root_signature_desc *desc) DECLSPEC_HIDDEN; + struct vkd3d_shader_versioned_root_signature_desc *desc); struct d3d12_graphics_pipeline_state { @@ -829,13 +829,13 @@ static inline bool d3d12_pipeline_state_has_unknown_dsv_format(struct d3d12_pipe } HRESULT d3d12_pipeline_state_create_compute(struct d3d12_device *device, - const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN; + const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state); HRESULT d3d12_pipeline_state_create_graphics(struct d3d12_device *device, - const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state) DECLSPEC_HIDDEN; + const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc, struct d3d12_pipeline_state **state); VkPipeline d3d12_pipeline_state_get_or_create_pipeline(struct d3d12_pipeline_state *state, D3D12_PRIMITIVE_TOPOLOGY topology, const uint32_t *strides, VkFormat dsv_format, - VkRenderPass *vk_render_pass) DECLSPEC_HIDDEN; -struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface) DECLSPEC_HIDDEN; + VkRenderPass *vk_render_pass); +struct d3d12_pipeline_state *unsafe_impl_from_ID3D12PipelineState(ID3D12PipelineState *iface); struct vkd3d_buffer { @@ -895,7 +895,7 @@ struct d3d12_command_allocator }; HRESULT d3d12_command_allocator_create(struct d3d12_device *device, - D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator) DECLSPEC_HIDDEN; + D3D12_COMMAND_LIST_TYPE type, struct d3d12_command_allocator **allocator); struct vkd3d_push_descriptor { @@ -987,7 +987,7 @@ struct d3d12_command_list HRESULT d3d12_command_list_create(struct d3d12_device *device, UINT node_mask, D3D12_COMMAND_LIST_TYPE type, ID3D12CommandAllocator *allocator_iface, - ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list) DECLSPEC_HIDDEN; + ID3D12PipelineState *initial_pipeline_state, struct d3d12_command_list **list); struct vkd3d_queue { @@ -1014,12 +1014,12 @@ struct vkd3d_queue VkSemaphore old_vk_semaphores[VKD3D_MAX_VK_SYNC_OBJECTS]; }; -VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; +VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue); HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, const VkQueueFamilyProperties *properties, - struct vkd3d_queue **queue) DECLSPEC_HIDDEN; -void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_queue_release(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; + struct vkd3d_queue **queue); +void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device); +void vkd3d_queue_release(struct vkd3d_queue *queue); /* ID3D12CommandQueue */ struct d3d12_command_queue @@ -1040,7 +1040,7 @@ struct d3d12_command_queue }; HRESULT d3d12_command_queue_create(struct d3d12_device *device, - const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue) DECLSPEC_HIDDEN; + const D3D12_COMMAND_QUEUE_DESC *desc, struct d3d12_command_queue **queue); /* ID3D12CommandSignature */ struct d3d12_command_signature @@ -1056,8 +1056,8 @@ struct d3d12_command_signature }; HRESULT d3d12_command_signature_create(struct d3d12_device *device, const D3D12_COMMAND_SIGNATURE_DESC *desc, - struct d3d12_command_signature **signature) DECLSPEC_HIDDEN; -struct d3d12_command_signature *unsafe_impl_from_ID3D12CommandSignature(ID3D12CommandSignature *iface) DECLSPEC_HIDDEN; + struct d3d12_command_signature **signature); +struct d3d12_command_signature *unsafe_impl_from_ID3D12CommandSignature(ID3D12CommandSignature *iface); /* NULL resources */ struct vkd3d_null_resources @@ -1076,9 +1076,9 @@ struct vkd3d_null_resources }; HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); void vkd3d_destroy_null_resources(struct vkd3d_null_resources *null_resources, - struct d3d12_device *device) DECLSPEC_HIDDEN; + struct d3d12_device *device); struct vkd3d_format_compatibility_list { @@ -1116,8 +1116,8 @@ struct vkd3d_uav_clear_state struct vkd3d_uav_clear_pipelines pipelines_uint; }; -HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device) DECLSPEC_HIDDEN; +HRESULT vkd3d_uav_clear_state_init(struct vkd3d_uav_clear_state *state, struct d3d12_device *device); +void vkd3d_uav_clear_state_cleanup(struct vkd3d_uav_clear_state *state, struct d3d12_device *device); /* ID3D12Device */ struct d3d12_device @@ -1173,13 +1173,13 @@ struct d3d12_device }; HRESULT d3d12_device_create(struct vkd3d_instance *instance, - const struct vkd3d_device_create_info *create_info, struct d3d12_device **device) DECLSPEC_HIDDEN; + const struct vkd3d_device_create_info *create_info, struct d3d12_device **device); struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, - D3D12_COMMAND_LIST_TYPE type) DECLSPEC_HIDDEN; -bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent) DECLSPEC_HIDDEN; + D3D12_COMMAND_LIST_TYPE type); +bool d3d12_device_is_uma(struct d3d12_device *device, bool *coherent); void d3d12_device_mark_as_removed(struct d3d12_device *device, HRESULT reason, - const char *message, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; -struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface) DECLSPEC_HIDDEN; + const char *message, ...) VKD3D_PRINTF_FUNC(3, 4); +struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface); static inline HRESULT d3d12_device_query_interface(struct d3d12_device *device, REFIID iid, void **object) { @@ -1254,15 +1254,15 @@ static inline bool vkd3d_format_is_compressed(const struct vkd3d_format *format) void vkd3d_format_copy_data(const struct vkd3d_format *format, const uint8_t *src, unsigned int src_row_pitch, unsigned int src_slice_pitch, uint8_t *dst, unsigned int dst_row_pitch, - unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d) DECLSPEC_HIDDEN; + unsigned int dst_slice_pitch, unsigned int w, unsigned int h, unsigned int d); const struct vkd3d_format *vkd3d_get_format(const struct d3d12_device *device, - DXGI_FORMAT dxgi_format, bool depth_stencil) DECLSPEC_HIDDEN; + DXGI_FORMAT dxgi_format, bool depth_stencil); const struct vkd3d_format *vkd3d_find_uint_format(const struct d3d12_device *device, - DXGI_FORMAT dxgi_format) DECLSPEC_HIDDEN; + DXGI_FORMAT dxgi_format); -HRESULT vkd3d_init_format_info(struct d3d12_device *device) DECLSPEC_HIDDEN; -void vkd3d_cleanup_format_info(struct d3d12_device *device) DECLSPEC_HIDDEN; +HRESULT vkd3d_init_format_info(struct d3d12_device *device); +void vkd3d_cleanup_format_info(struct d3d12_device *device); static inline const struct vkd3d_format *vkd3d_format_from_d3d12_resource_desc( const struct d3d12_device *device, const D3D12_RESOURCE_DESC *desc, DXGI_FORMAT view_format) @@ -1310,24 +1310,24 @@ static inline unsigned int vkd3d_compute_workgroup_count(unsigned int thread_cou return (thread_count + workgroup_size - 1) / workgroup_size; } -VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op) DECLSPEC_HIDDEN; -VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc(const DXGI_SAMPLE_DESC *desc) DECLSPEC_HIDDEN; -VkSampleCountFlagBits vk_samples_from_sample_count(unsigned int sample_count) DECLSPEC_HIDDEN; +VkCompareOp vk_compare_op_from_d3d12(D3D12_COMPARISON_FUNC op); +VkSampleCountFlagBits vk_samples_from_dxgi_sample_desc(const DXGI_SAMPLE_DESC *desc); +VkSampleCountFlagBits vk_samples_from_sample_count(unsigned int sample_count); -bool is_valid_feature_level(D3D_FEATURE_LEVEL feature_level) DECLSPEC_HIDDEN; +bool is_valid_feature_level(D3D_FEATURE_LEVEL feature_level); -bool is_valid_resource_state(D3D12_RESOURCE_STATES state) DECLSPEC_HIDDEN; -bool is_write_resource_state(D3D12_RESOURCE_STATES state) DECLSPEC_HIDDEN; +bool is_valid_resource_state(D3D12_RESOURCE_STATES state); +bool is_write_resource_state(D3D12_RESOURCE_STATES state); HRESULT return_interface(void *iface, REFIID iface_iid, - REFIID requested_iid, void **object) DECLSPEC_HIDDEN; + REFIID requested_iid, void **object); -const char *debug_d3d12_box(const D3D12_BOX *box) DECLSPEC_HIDDEN; -const char *debug_d3d12_shader_component_mapping(unsigned int mapping) DECLSPEC_HIDDEN; -const char *debug_vk_extent_3d(VkExtent3D extent) DECLSPEC_HIDDEN; -const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags) DECLSPEC_HIDDEN; -const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags) DECLSPEC_HIDDEN; -const char *debug_vk_queue_flags(VkQueueFlags flags) DECLSPEC_HIDDEN; +const char *debug_d3d12_box(const D3D12_BOX *box); +const char *debug_d3d12_shader_component_mapping(unsigned int mapping); +const char *debug_vk_extent_3d(VkExtent3D extent); +const char *debug_vk_memory_heap_flags(VkMemoryHeapFlags flags); +const char *debug_vk_memory_property_flags(VkMemoryPropertyFlags flags); +const char *debug_vk_queue_flags(VkQueueFlags flags); static inline void debug_ignored_node_mask(unsigned int mask) { @@ -1336,15 +1336,15 @@ static inline void debug_ignored_node_mask(unsigned int mask) } HRESULT vkd3d_load_vk_global_procs(struct vkd3d_vk_global_procs *procs, - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) DECLSPEC_HIDDEN; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr); HRESULT vkd3d_load_vk_instance_procs(struct vkd3d_vk_instance_procs *procs, - const struct vkd3d_vk_global_procs *global_procs, VkInstance instance) DECLSPEC_HIDDEN; + const struct vkd3d_vk_global_procs *global_procs, VkInstance instance); HRESULT vkd3d_load_vk_device_procs(struct vkd3d_vk_device_procs *procs, - const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device) DECLSPEC_HIDDEN; + const struct vkd3d_vk_instance_procs *parent_procs, VkDevice device); extern const char vkd3d_build[]; -bool vkd3d_get_program_name(char program_name[PATH_MAX]) DECLSPEC_HIDDEN; +bool vkd3d_get_program_name(char program_name[PATH_MAX]); static inline void vkd3d_set_thread_name(const char *name) { @@ -1356,9 +1356,9 @@ static inline void vkd3d_set_thread_name(const char *name) } VkResult vkd3d_set_vk_object_name_utf8(struct d3d12_device *device, uint64_t vk_object, - VkDebugReportObjectTypeEXT vk_object_type, const char *name) DECLSPEC_HIDDEN; + VkDebugReportObjectTypeEXT vk_object_type, const char *name); HRESULT vkd3d_set_vk_object_name(struct d3d12_device *device, uint64_t vk_object, - VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name) DECLSPEC_HIDDEN; + VkDebugReportObjectTypeEXT vk_object_type, const WCHAR *name); static inline void vk_prepend_struct(void *header, void *structure) { -- 2.28.0

5 6

[PATCH 1/7] include: Update _XSTATE_CONFIGURATION structure definition.
by Paul Gofman May 27, 2021

May 27, 2021

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- include/ddk/wdm.h | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/include/ddk/wdm.h b/include/ddk/wdm.h index 9fcb1387012..b8bb7bd971f 100644 --- a/include/ddk/wdm.h +++ b/include/ddk/wdm.h @@ -1207,16 +1207,24 @@ typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE typedef struct _XSTATE_FEATURE { - ULONG Offset; - ULONG Size; + ULONG Offset; + ULONG Size; } XSTATE_FEATURE, *PXSTATE_FEATURE; typedef struct _XSTATE_CONFIGURATION { - ULONG64 EnabledFeatures; - ULONG Size; - ULONG OptimizedSave:1; - XSTATE_FEATURE Features[MAXIMUM_XSTATE_FEATURES]; + ULONG64 EnabledFeatures; + ULONG64 EnabledVolatileFeatures; + ULONG Size; + ULONG OptimizedSave:1; + ULONG CompactionEnabled:1; + XSTATE_FEATURE Features[MAXIMUM_XSTATE_FEATURES]; + + ULONG64 EnabledSupervisorFeatures; + ULONG64 AlignedFeatures; + ULONG AllFeatureSize; + ULONG AllFeatures[MAXIMUM_XSTATE_FEATURES]; + ULONG64 EnabledUserVisibleSupervisorFeatures; } XSTATE_CONFIGURATION, *PXSTATE_CONFIGURATION; typedef struct _KUSER_SHARED_DATA { -- 2.26.2

3 16

[PATCH] user32: Keep toplevel minimized windows offscreen if they're already.
by Gabriel Ivăncescu Feb. 4, 2021

Feb. 4, 2021

Some applications (e.g. Lego Worlds) use (-32000,-32000) to determine whether a window is minimized. Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/user32/tests/win.c | 52 +++++++++++++++++++++++++++++++++++++++++ dlls/user32/winpos.c | 8 +++++++ 2 files changed, 60 insertions(+) diff --git a/dlls/user32/tests/win.c b/dlls/user32/tests/win.c index 843da89..19a0db2 100644 --- a/dlls/user32/tests/win.c +++ b/dlls/user32/tests/win.c @@ -11593,6 +11593,58 @@ todo_wine ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", wine_dbgstr_rect(&wp.rcNormalPosition)); + wp.flags = WPF_SETMINPOSITION; + wp.showCmd = SW_NORMAL; + wp.ptMinPosition.x = wp.ptMinPosition.y = 100; + wp.ptMaxPosition.x = wp.ptMaxPosition.y = 100; + wp.rcNormalPosition = orig; + ret = SetWindowPlacement(hwnd, &wp); + ok(ret, "failed to set window placement, error %u\n", GetLastError()); + + ShowWindow(hwnd, SW_MINIMIZE); + + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %u\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, + "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); +todo_wine + ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, + "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + + ret = SetWindowPos(hwnd, NULL, 100, 100, 151, 151, SWP_NOACTIVATE | SWP_NOZORDER); + ok(ret, "failed to set window pos, error %u\n", GetLastError()); + + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %u\n", GetLastError()); + ok(wp.showCmd == SW_SHOWMINIMIZED, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, + "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); +todo_wine + ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, + "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + GetWindowRect(hwnd, &rect); + ok(rect.left == -32000 && rect.top == -32000, "got window rect %s\n", wine_dbgstr_rect(&rect)); + + ShowWindow(hwnd, SW_SHOWNORMAL); + + ret = GetWindowPlacement(hwnd, &wp); + ok(ret, "failed to get window placement, error %u\n", GetLastError()); + ok(wp.showCmd == SW_NORMAL, "got show cmd %u\n", wp.showCmd); + ok(wp.ptMinPosition.x == -32000 && wp.ptMinPosition.y == -32000, + "got minimized pos (%d,%d)\n", wp.ptMinPosition.x, wp.ptMinPosition.y); +todo_wine + ok(wp.ptMaxPosition.x == -1 && wp.ptMaxPosition.y == -1, + "got maximized pos (%d,%d)\n", wp.ptMaxPosition.x, wp.ptMaxPosition.y); + ok(EqualRect(&wp.rcNormalPosition, &orig), "got normal pos %s\n", + wine_dbgstr_rect(&wp.rcNormalPosition)); + GetWindowRect(hwnd, &rect); + ok(EqualRect(&rect, &orig), "got window rect %s\n", wine_dbgstr_rect(&rect)); + DestroyWindow(hwnd); } diff --git a/dlls/user32/winpos.c b/dlls/user32/winpos.c index b45b74c..3ccd939 100644 --- a/dlls/user32/winpos.c +++ b/dlls/user32/winpos.c @@ -1688,6 +1688,14 @@ static BOOL SWP_DoWinPosChanging( WINDOWPOS *pWinpos, RECT *old_window_rect, REC } if (!(pWinpos->flags & SWP_NOMOVE)) { + /* If the window is toplevel minimized off-screen, force keep it there */ + if ((wndPtr->dwStyle & WS_MINIMIZE) && + wndPtr->window_rect.left <= -32000 && wndPtr->window_rect.top <= -32000 && + (!wndPtr->parent || wndPtr->parent == GetDesktopWindow())) + { + pWinpos->x = -32000; + pWinpos->y = -32000; + } new_window_rect->left = pWinpos->x; new_window_rect->top = pWinpos->y; new_window_rect->right += pWinpos->x - old_window_rect->left; -- 2.21.0

3 3

Re: Wine staging 5.19 release
by Gerald Pfeifer Dec. 5, 2020

Dec. 5, 2020

Alistair Leslie-Hughes wrote: > As always, if you find a bug, please report it via > https://bugs.winehq.org I did that with https://bugs.winehq.org/show_bug.cgi?id=49829 ("file.c:237:37: error: 'EXTATTR_NAMESPACE_USER' undeclared on FreeBSD") and even have debugged this and found a first fix. Alas the instructions at https://wiki.winehq.org/Wine-Staging do not really apply: The link provided goes into Bugzilla. Anyway, here is that first step towards fixing things up on FreeBSD. Gerald Properly include sys/extattr.h when available. dlls/ntdll/unix/file.c special cases when sys/extattr.h is available, alas failed to actually include that file. Signed-off-by: Gerald Pfeifer <gerald(a)pfeifer.com> --- dlls/ntdll/unix/file.c.orig 2020-10-14 19:03:39.476740000 +0000 +++ dlls/ntdll/unix/file.c 2020-10-14 19:49:03.226593000 +0000 @@ -112,6 +112,9 @@ #elif defined(HAVE_SYS_XATTR_H) #include <sys/xattr.h> #endif +#ifdef HAVE_SYS_EXTATTR_H +#include <sys/extattr.h> +#endif #include <time.h> #ifdef HAVE_UNISTD_H # include <unistd.h>

4 10

[PATCH 1/3] include: Emit assembly function size when compiling without MinGW.
by Rémi Bernon Dec. 4, 2020

Dec. 4, 2020

Signed-off-by: Rémi Bernon <rbernon(a)codeweavers.com> --- This series restores Valgrind support in Wine, including stacktraces support in all modules, be PE or ELF. It requires however some Valgrind patches that I submitted upstream, as linked in PATCH 3. include/wine/asm.h | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/include/wine/asm.h b/include/wine/asm.h index b4b6fb50eb8..7975e377341 100644 --- a/include/wine/asm.h +++ b/include/wine/asm.h @@ -65,6 +65,14 @@ # define __ASM_FUNC_TYPE(name) ".type " name ",@function" #endif +#ifdef _WIN32 +# define __ASM_FUNC_SIZE(name) "" +#elif defined(__APPLE__) +# define __ASM_FUNC_SIZE(name) "" +#else +# define __ASM_FUNC_SIZE(name) ".size " name ", . - " name +#endif + #if !defined(__GNUC__) && !defined(__clang__) # define __ASM_BLOCK_BEGIN(name) void __asm_dummy_##name(void) { # define __ASM_BLOCK_END } @@ -76,7 +84,7 @@ #define __ASM_DEFINE_FUNC(name,code) \ __ASM_BLOCK_BEGIN(__LINE__) \ asm(".text\n\t.align 4\n\t.globl " name "\n\t" __ASM_FUNC_TYPE(name) __ASM_SEH("\n\t.seh_proc " name) "\n" name ":\n\t" \ - __ASM_CFI(".cfi_startproc\n\t") code __ASM_CFI("\n\t.cfi_endproc") __ASM_SEH("\n\t.seh_endproc") ); \ + __ASM_CFI(".cfi_startproc\n\t") code __ASM_CFI("\n\t.cfi_endproc") __ASM_SEH("\n\t.seh_endproc") "\n\t" __ASM_FUNC_SIZE(name) "\n" ); \ __ASM_BLOCK_END #define __ASM_GLOBAL_FUNC(name,code) __ASM_DEFINE_FUNC(__ASM_NAME(#name),code) -- 2.29.2

1 3

[PATCH] ntdll/sec: Add RtlDefaultNpAcl stub.
by Biswapriyo Nath Dec. 4, 2020

Dec. 4, 2020

1 1

[PATCH] crypt32: Fix reading and writing CRYPT_KEY_PROV_INFO certificate property.
by Dmitry Timoshkov Dec. 3, 2020

Dec. 3, 2020

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50024 Signed-off-by: Dmitry Timoshkov <dmitry(a)baikal.ru> --- dlls/crypt32/cert.c | 251 +++++++++++++-------------------- dlls/crypt32/crypt32_private.h | 8 -- dlls/crypt32/serialize.c | 187 +++++++++++++++++++++++- dlls/crypt32/tests/cert.c | 96 +++++++++++++ 4 files changed, 375 insertions(+), 167 deletions(-) diff --git a/dlls/crypt32/cert.c b/dlls/crypt32/cert.c index ef871155b9..a41eb99500 100644 --- a/dlls/crypt32/cert.c +++ b/dlls/crypt32/cert.c @@ -435,6 +435,84 @@ void CRYPT_ConvertKeyContext(const struct store_CERT_KEY_CONTEXT *src, CERT_KEY_ dst->dwKeySpec = src->dwKeySpec; } +/* + * Fix offsets in a continuous block of memory of CRYPT_KEY_PROV_INFO with + * its associated data. + */ +static void fix_KeyProvInfoProperty(CRYPT_KEY_PROV_INFO *info) +{ + BYTE *data; + DWORD i; + + data = (BYTE *)(info + 1) + sizeof(CRYPT_KEY_PROV_PARAM) * info->cProvParam; + + if (info->pwszContainerName) + { + info->pwszContainerName = (LPWSTR)data; + data += (lstrlenW(info->pwszContainerName) + 1) * sizeof(WCHAR); + } + + if (info->pwszProvName) + { + info->pwszProvName = (LPWSTR)data; + data += (lstrlenW(info->pwszProvName) + 1) * sizeof(WCHAR); + } + + info->rgProvParam = info->cProvParam ? (CRYPT_KEY_PROV_PARAM *)(info + 1) : NULL; + + for (i = 0; i < info->cProvParam; i++) + { + info->rgProvParam[i].pbData = info->rgProvParam[i].cbData ? data : NULL; + data += info->rgProvParam[i].cbData; + } +} + +/* + * Copy to a continuous block of memory of CRYPT_KEY_PROV_INFO with + * its associated data. + */ +static void copy_KeyProvInfoProperty(const CRYPT_KEY_PROV_INFO *from, CRYPT_KEY_PROV_INFO *to) +{ + BYTE *data; + DWORD i; + + data = (BYTE *)(to + 1) + sizeof(CRYPT_KEY_PROV_PARAM) * from->cProvParam; + + if (from->pwszContainerName) + { + to->pwszContainerName = (LPWSTR)data; + lstrcpyW((LPWSTR)data, from->pwszContainerName); + data += (lstrlenW(from->pwszContainerName) + 1) * sizeof(WCHAR); + } + else + to->pwszContainerName = NULL; + + if (from->pwszProvName) + { + to->pwszProvName = (LPWSTR)data; + lstrcpyW((LPWSTR)data, from->pwszProvName); + data += (lstrlenW(from->pwszProvName) + 1) * sizeof(WCHAR); + } + else + to->pwszProvName = NULL; + + to->dwProvType = from->dwProvType; + to->dwFlags = from->dwFlags; + to->cProvParam = from->cProvParam; + to->rgProvParam = from->cProvParam ? (CRYPT_KEY_PROV_PARAM *)(to + 1) : NULL; + to->dwKeySpec = from->dwKeySpec; + + for (i = 0; i < from->cProvParam; i++) + { + to->rgProvParam[i].dwParam = from->rgProvParam[i].dwParam; + to->rgProvParam[i].dwFlags = from->rgProvParam[i].dwFlags; + to->rgProvParam[i].cbData = from->rgProvParam[i].cbData; + to->rgProvParam[i].pbData = from->rgProvParam[i].cbData ? data : NULL; + memcpy(data, from->rgProvParam[i].pbData, from->rgProvParam[i].cbData); + data += from->rgProvParam[i].cbData; + } +} + static BOOL CertContext_GetProperty(cert_t *cert, DWORD dwPropId, void *pvData, DWORD *pcbData) { @@ -536,87 +614,6 @@ static BOOL CertContext_GetProperty(cert_t *cert, DWORD dwPropId, return ret; } -/* 64-bit compatible layout, so that 64-bit crypt32 is able to read - * the structure saved by 32-bit crypt32. - */ -typedef struct -{ - ULONG64 pwszContainerName; - ULONG64 pwszProvName; - DWORD dwProvType; - DWORD dwFlags; - DWORD cProvParam; - ULONG64 rgProvParam; - DWORD dwKeySpec; -} store_CRYPT_KEY_PROV_INFO; - -typedef struct -{ - DWORD dwParam; - ULONG64 pbData; - DWORD cbData; - DWORD dwFlags; -} store_CRYPT_KEY_PROV_PARAM; - -void CRYPT_FixKeyProvInfoPointers(PCRYPT_KEY_PROV_INFO buf) -{ - CRYPT_KEY_PROV_INFO info; - store_CRYPT_KEY_PROV_INFO *store = (store_CRYPT_KEY_PROV_INFO *)buf; - BYTE *p = (BYTE *)(store + 1); - - if (store->pwszContainerName) - { - info.pwszContainerName = (LPWSTR)((BYTE *)store + store->pwszContainerName); - p += (lstrlenW(info.pwszContainerName) + 1) * sizeof(WCHAR); - } - else - info.pwszContainerName = NULL; - - if (store->pwszProvName) - { - info.pwszProvName = (LPWSTR)((BYTE *)store + store->pwszProvName); - p += (lstrlenW(info.pwszProvName) + 1) * sizeof(WCHAR); - } - else - info.pwszProvName = NULL; - - info.dwProvType = store->dwProvType; - info.dwFlags = store->dwFlags; - info.dwKeySpec = store->dwKeySpec; - info.cProvParam = store->cProvParam; - - if (info.cProvParam) - { - DWORD i; - - info.rgProvParam = (CRYPT_KEY_PROV_PARAM *)p; - - for (i = 0; i < store->cProvParam; i++) - { - CRYPT_KEY_PROV_PARAM param; - store_CRYPT_KEY_PROV_PARAM *store_param; - - store_param = (store_CRYPT_KEY_PROV_PARAM *)p; - p += sizeof(*store_param); - - param.dwParam = store_param[i].dwParam; - param.dwFlags = store_param[i].dwFlags; - param.cbData = store_param[i].cbData; - param.pbData = param.cbData ? p : NULL; - p += store_param[i].cbData; - - memcpy(&info.rgProvParam[i], &param, sizeof(param)); - } - } - else - info.rgProvParam = NULL; - - TRACE("%s,%s,%u,%08x,%u,%p,%u\n", debugstr_w(info.pwszContainerName), debugstr_w(info.pwszProvName), - info.dwProvType, info.dwFlags, info.cProvParam, info.rgProvParam, info.dwKeySpec); - - *buf = info; -} - BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, DWORD dwPropId, void *pvData, DWORD *pcbData) { @@ -650,10 +647,9 @@ BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, break; } case CERT_KEY_PROV_INFO_PROP_ID: - ret = CertContext_GetProperty(cert, dwPropId, pvData, - pcbData); + ret = CertContext_GetProperty(cert, dwPropId, pvData, pcbData); if (ret && pvData) - CRYPT_FixKeyProvInfoPointers(pvData); + fix_KeyProvInfoProperty(pvData); break; default: ret = CertContext_GetProperty(cert, dwPropId, pvData, @@ -664,69 +660,14 @@ BOOL WINAPI CertGetCertificateContextProperty(PCCERT_CONTEXT pCertContext, return ret; } -/* Copies key provider info from from into to, where to is assumed to be a - * contiguous buffer of memory large enough for from and all its associated - * data, but whose pointers are uninitialized. - * Upon return, to contains a contiguous copy of from, packed in the following - * order: - * - store_CRYPT_KEY_PROV_INFO - * - pwszContainerName - * - pwszProvName - * - store_CRYPT_KEY_PROV_PARAM[0] - * - store_CRYPT_KEY_PROV_PARAM[0].data - * - ... +/* + * Create a continuous block of memory for CRYPT_KEY_PROV_INFO with + * its associated data, and add it to the certificate properties. */ -static void CRYPT_CopyKeyProvInfo(store_CRYPT_KEY_PROV_INFO *to, const CRYPT_KEY_PROV_INFO *from) +static BOOL CertContext_SetKeyProvInfoProperty(CONTEXT_PROPERTY_LIST *properties, const CRYPT_KEY_PROV_INFO *info) { - DWORD i; - BYTE *p; - store_CRYPT_KEY_PROV_PARAM *param; - - p = (BYTE *)(to + 1); - - if (from->pwszContainerName) - { - to->pwszContainerName = p - (BYTE *)to; - lstrcpyW((LPWSTR)p, from->pwszContainerName); - p += (lstrlenW(from->pwszContainerName) + 1) * sizeof(WCHAR); - } - else - to->pwszContainerName = 0; - - if (from->pwszProvName) - { - to->pwszProvName = p - (BYTE *)to; - lstrcpyW((LPWSTR)p, from->pwszProvName); - p += (lstrlenW(from->pwszProvName) + 1) * sizeof(WCHAR); - } - else - to->pwszProvName = 0; - - to->dwProvType = from->dwProvType; - to->dwFlags = from->dwFlags; - to->cProvParam = from->cProvParam; - to->rgProvParam = 0; - to->dwKeySpec = from->dwKeySpec; - - for (i = 0; i < to->cProvParam; i++) - { - param = (store_CRYPT_KEY_PROV_PARAM *)p; - p += sizeof(*param); - - param->dwParam = from->rgProvParam[i].dwParam; - param->pbData = 0; - param->cbData = from->rgProvParam[i].cbData; - param->dwFlags = from->rgProvParam[i].dwFlags; - memcpy(p, from->rgProvParam[i].pbData, from->rgProvParam[i].cbData); - p += from->rgProvParam[i].cbData; - } -} - -static BOOL CertContext_SetKeyProvInfoProperty(CONTEXT_PROPERTY_LIST *properties, - const CRYPT_KEY_PROV_INFO *info) -{ - BYTE *buf; - DWORD size = sizeof(store_CRYPT_KEY_PROV_INFO), i; + CRYPT_KEY_PROV_INFO *prop; + DWORD size = sizeof(CRYPT_KEY_PROV_INFO), i; BOOL ret; if (info->pwszContainerName) @@ -735,18 +676,20 @@ static BOOL CertContext_SetKeyProvInfoProperty(CONTEXT_PROPERTY_LIST *properties size += (lstrlenW(info->pwszProvName) + 1) * sizeof(WCHAR); for (i = 0; i < info->cProvParam; i++) - size += sizeof(store_CRYPT_KEY_PROV_PARAM) + info->rgProvParam[i].cbData; + size += sizeof(CRYPT_KEY_PROV_PARAM) + info->rgProvParam[i].cbData; - buf = CryptMemAlloc(size); - if (buf) + prop = HeapAlloc(GetProcessHeap(), 0, size); + if (!prop) { - CRYPT_CopyKeyProvInfo((store_CRYPT_KEY_PROV_INFO *)buf, info); - ret = ContextPropertyList_SetProperty(properties, - CERT_KEY_PROV_INFO_PROP_ID, buf, size); - CryptMemFree(buf); + SetLastError(ERROR_OUTOFMEMORY); + return FALSE; } - else - ret = FALSE; + + copy_KeyProvInfoProperty(info, prop); + + ret = ContextPropertyList_SetProperty(properties, CERT_KEY_PROV_INFO_PROP_ID, (const BYTE *)prop, size); + HeapFree(GetProcessHeap(), 0, prop); + return ret; } diff --git a/dlls/crypt32/crypt32_private.h b/dlls/crypt32/crypt32_private.h index c552bdf949..300eb939bd 100644 --- a/dlls/crypt32/crypt32_private.h +++ b/dlls/crypt32/crypt32_private.h @@ -370,14 +370,6 @@ BOOL CRYPT_ReadSerializedStoreFromFile(HANDLE file, HCERTSTORE store) DECLSPEC_H BOOL CRYPT_ReadSerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob, HCERTSTORE store) DECLSPEC_HIDDEN; -/* Fixes up the pointers in info, where info is assumed to be a - * CRYPT_KEY_PROV_INFO, followed by its container name, provider name, and any - * provider parameters, in a contiguous buffer, but where info's pointers are - * assumed to be invalid. Upon return, info's pointers point to the - * appropriate memory locations. - */ -void CRYPT_FixKeyProvInfoPointers(PCRYPT_KEY_PROV_INFO info) DECLSPEC_HIDDEN; - struct store_CERT_KEY_CONTEXT { DWORD cbSize; diff --git a/dlls/crypt32/serialize.c b/dlls/crypt32/serialize.c index 7f7a4bc369..a50598dcd2 100644 --- a/dlls/crypt32/serialize.c +++ b/dlls/crypt32/serialize.c @@ -39,6 +39,86 @@ typedef struct _WINE_CERT_PROP_HEADER DWORD cb; } WINE_CERT_PROP_HEADER; +struct store_CRYPT_KEY_PROV_INFO +{ + DWORD pwszContainerName; + DWORD pwszProvName; + DWORD dwProvType; + DWORD dwFlags; + DWORD cProvParam; + DWORD rgProvParam; + DWORD dwKeySpec; +}; + +struct store_CRYPT_KEY_PROV_PARAM +{ + DWORD dwParam; + DWORD pbData; + DWORD cbData; + DWORD dwFlags; +}; + +static DWORD serialize_KeyProvInfoProperty(const CRYPT_KEY_PROV_INFO *info, struct store_CRYPT_KEY_PROV_INFO **ret) +{ + struct store_CRYPT_KEY_PROV_INFO *store; + struct store_CRYPT_KEY_PROV_PARAM *param; + DWORD size = sizeof(struct store_CRYPT_KEY_PROV_INFO), i; + BYTE *data; + + if (info->pwszContainerName) + size += (lstrlenW(info->pwszContainerName) + 1) * sizeof(WCHAR); + if (info->pwszProvName) + size += (lstrlenW(info->pwszProvName) + 1) * sizeof(WCHAR); + + for (i = 0; i < info->cProvParam; i++) + size += sizeof(struct store_CRYPT_KEY_PROV_PARAM) + info->rgProvParam[i].cbData; + + if (!ret) return size; + + store = HeapAlloc(GetProcessHeap(), 0, size); + if (!store) return 0; + + param = (struct store_CRYPT_KEY_PROV_PARAM *)(store + 1); + data = (BYTE *)param + sizeof(struct store_CRYPT_KEY_PROV_PARAM) * info->cProvParam; + + if (info->pwszContainerName) + { + store->pwszContainerName = data - (BYTE *)store; + lstrcpyW((LPWSTR)data, info->pwszContainerName); + data += (lstrlenW(info->pwszContainerName) + 1) * sizeof(WCHAR); + } + else + store->pwszContainerName = 0; + + if (info->pwszProvName) + { + store->pwszProvName = data - (BYTE *)store; + lstrcpyW((LPWSTR)data, info->pwszProvName); + data += (lstrlenW(info->pwszProvName) + 1) * sizeof(WCHAR); + } + else + store->pwszProvName = 0; + + store->dwProvType = info->dwProvType; + store->dwFlags = info->dwFlags; + store->cProvParam = info->cProvParam; + store->rgProvParam = info->cProvParam ? (BYTE *)param - (BYTE *)store : 0; + store->dwKeySpec = info->dwKeySpec; + + for (i = 0; i < info->cProvParam; i++) + { + param[i].dwParam = info->rgProvParam[i].dwParam; + param[i].dwFlags = info->rgProvParam[i].dwFlags; + param[i].cbData = info->rgProvParam[i].cbData; + param[i].pbData = param[i].cbData ? data - (BYTE *)store : 0; + memcpy(data, info->rgProvParam[i].pbData, info->rgProvParam[i].cbData); + data += info->rgProvParam[i].cbData; + } + + *ret = store; + return size; +} + static BOOL CRYPT_SerializeStoreElement(const void *context, const BYTE *encodedContext, DWORD cbEncodedContext, DWORD contextPropID, const WINE_CONTEXT_INTERFACE *contextInterface, DWORD dwFlags, BOOL omitHashes, @@ -63,7 +143,16 @@ static BOOL CRYPT_SerializeStoreElement(const void *context, ret = contextInterface->getProp(context, prop, NULL, &propSize); if (ret) + { + if (prop == CERT_KEY_PROV_INFO_PROP_ID) + { + BYTE *info = CryptMemAlloc(propSize); + contextInterface->getProp(context, prop, info, &propSize); + propSize = serialize_KeyProvInfoProperty((const CRYPT_KEY_PROV_INFO *)info, NULL); + CryptMemFree(info); + } bytesNeeded += sizeof(WINE_CERT_PROP_HEADER) + propSize; + } } } while (ret && prop != 0); @@ -109,6 +198,14 @@ static BOOL CRYPT_SerializeStoreElement(const void *context, &propSize); if (ret) { + if (prop == CERT_KEY_PROV_INFO_PROP_ID) + { + struct store_CRYPT_KEY_PROV_INFO *store; + propSize = serialize_KeyProvInfoProperty((const CRYPT_KEY_PROV_INFO *)buf, &store); + CryptMemFree(buf); + buf = (BYTE *)store; + } + hdr = (WINE_CERT_PROP_HEADER*)pbElement; hdr->propID = prop; hdr->unknown = 1; @@ -218,6 +315,83 @@ static const WINE_CERT_PROP_HEADER *CRYPT_findPropID(const BYTE *buf, return ret; } +static DWORD read_serialized_KeyProvInfoProperty(const struct store_CRYPT_KEY_PROV_INFO *store, CRYPT_KEY_PROV_INFO **ret) +{ + const struct store_CRYPT_KEY_PROV_PARAM *param; + CRYPT_KEY_PROV_INFO *info; + DWORD size = sizeof(CRYPT_KEY_PROV_INFO), i; + const BYTE *base; + BYTE *data; + + base = (const BYTE *)store; + param = (const struct store_CRYPT_KEY_PROV_PARAM *)(base + store->rgProvParam); + + if (store->pwszContainerName) + size += (lstrlenW((LPCWSTR)(base + store->pwszContainerName)) + 1) * sizeof(WCHAR); + if (store->pwszProvName) + size += (lstrlenW((LPCWSTR)(base + store->pwszProvName)) + 1) * sizeof(WCHAR); + + for (i = 0; i < store->cProvParam; i++) + size += sizeof(CRYPT_KEY_PROV_PARAM) + param[i].cbData; + + info = HeapAlloc(GetProcessHeap(), 0, size); + if (!info) + { + SetLastError(ERROR_OUTOFMEMORY); + return 0; + } + + data = (BYTE *)(info + 1) + sizeof(CRYPT_KEY_PROV_PARAM) * store->cProvParam; + + if (store->pwszContainerName) + { + info->pwszContainerName = (LPWSTR)data; + lstrcpyW(info->pwszContainerName, (LPCWSTR)((const BYTE *)store + store->pwszContainerName)); + data += (lstrlenW(info->pwszContainerName) + 1) * sizeof(WCHAR); + } + else + info->pwszContainerName = NULL; + + if (store->pwszProvName) + { + info->pwszProvName = (LPWSTR)data; + lstrcpyW(info->pwszProvName, (LPCWSTR)((const BYTE *)store + store->pwszProvName)); + data += (lstrlenW(info->pwszProvName) + 1) * sizeof(WCHAR); + } + else + info->pwszProvName = NULL; + + info->dwProvType = store->dwProvType; + info->dwFlags = store->dwFlags; + info->dwKeySpec = store->dwKeySpec; + info->cProvParam = store->cProvParam; + + if (info->cProvParam) + { + DWORD i; + + info->rgProvParam = (CRYPT_KEY_PROV_PARAM *)(info + 1); + + for (i = 0; i < info->cProvParam; i++) + { + info->rgProvParam[i].dwParam = param[i].dwParam; + info->rgProvParam[i].dwFlags = param[i].dwFlags; + info->rgProvParam[i].cbData = param[i].cbData; + info->rgProvParam[i].pbData = param[i].cbData ? data : NULL; + memcpy(info->rgProvParam[i].pbData, base + param[i].pbData, param[i].cbData); + data += param[i].cbData; + } + } + else + info->rgProvParam = NULL; + + TRACE("%s,%s,%u,%08x,%u,%p,%u\n", debugstr_w(info->pwszContainerName), debugstr_w(info->pwszProvName), + info->dwProvType, info->dwFlags, info->cProvParam, info->rgProvParam, info->dwKeySpec); + + *ret = info; + return size; +} + static BOOL CRYPT_ReadContextProp( const WINE_CONTEXT_INTERFACE *contextInterface, const void *context, const WINE_CERT_PROP_HEADER *hdr, const BYTE *pbElement, DWORD cbElement) @@ -272,12 +446,15 @@ static BOOL CRYPT_ReadContextProp( break; case CERT_KEY_PROV_INFO_PROP_ID: { - PCRYPT_KEY_PROV_INFO info = - (PCRYPT_KEY_PROV_INFO)pbElement; + CRYPT_KEY_PROV_INFO *info; - CRYPT_FixKeyProvInfoPointers(info); - ret = contextInterface->setProp(context, - hdr->propID, 0, pbElement); + if (read_serialized_KeyProvInfoProperty((const struct store_CRYPT_KEY_PROV_INFO *)pbElement, &info)) + { + ret = contextInterface->setProp(context, hdr->propID, 0, info); + CryptMemFree(info); + } + else + ret = FALSE; break; } case CERT_KEY_CONTEXT_PROP_ID: diff --git a/dlls/crypt32/tests/cert.c b/dlls/crypt32/tests/cert.c index 7d6d07fe02..6300d89f36 100644 --- a/dlls/crypt32/tests/cert.c +++ b/dlls/crypt32/tests/cert.c @@ -4140,6 +4140,101 @@ static void testGetPublicKeyLength(void) "Expected length 56, got %d\n", ret); } +static void testKeyProvInfo(void) +{ + static WCHAR containerW[] = L"Wine Test Container"; + static WCHAR providerW[] = L"Hello World CSP"; + static CRYPT_KEY_PROV_PARAM param[2] = { { 0x4444, (BYTE *)"param", 6, 0x5555 }, { 0x7777, (BYTE *)"param2", 7, 0x8888 } }; + HCERTSTORE store; + const CERT_CONTEXT *cert; + CERT_NAME_BLOB name; + CRYPT_KEY_PROV_INFO *info, info2; + BOOL ret; + DWORD size; + + store = CertOpenStore(CERT_STORE_PROV_SYSTEM_A, 0, 0, + CERT_SYSTEM_STORE_CURRENT_USER, "My"); + ok(store != NULL, "CertOpenStore error %u\n", GetLastError()); + + cert = CertCreateCertificateContext(X509_ASN_ENCODING, selfSignedCert, sizeof(selfSignedCert)); + ok(cert != NULL, "CertCreateCertificateContext error %#x\n", GetLastError()); + + info2.pwszContainerName = containerW; + info2.pwszProvName = providerW; + info2.dwProvType = 0x12345678; + info2.dwFlags = 0x87654321; + info2.cProvParam = ARRAY_SIZE(param); + info2.rgProvParam = param; + info2.dwKeySpec = 0x11223344; + ret = CertSetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID, 0, &info2); + ok(ret, "CertSetCertificateContextProperty error %#x\n", GetLastError()); + + ret = CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID, NULL, &size); + ok(ret, "CertGetCertificateContextProperty error %#x\n", GetLastError()); + info = HeapAlloc(GetProcessHeap(), 0, size); + ret = CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID, info, &size); + ok(ret, "CertGetCertificateContextProperty error %#x\n", GetLastError()); + ok(!lstrcmpW(info->pwszContainerName, containerW), "got %s\n", wine_dbgstr_w(info->pwszContainerName)); + ok(!lstrcmpW(info->pwszProvName, providerW), "got %s\n", wine_dbgstr_w(info->pwszProvName)); + ok(info->dwProvType == 0x12345678, "got %#x\n", info->dwProvType); + ok(info->dwFlags == 0x87654321, "got %#x\n", info->dwFlags); + ok(info->dwKeySpec == 0x11223344, "got %#x\n", info->dwKeySpec); + ok(info->cProvParam == 2, "got %#x\n", info->cProvParam); + ok(info->rgProvParam != NULL, "got %p\n", info->rgProvParam); + ok(info->rgProvParam[0].dwParam == param[0].dwParam, "got %#x\n", info->rgProvParam[0].dwParam); + ok(info->rgProvParam[0].cbData == param[0].cbData, "got %#x\n", info->rgProvParam[0].cbData); + ok(!memcmp(info->rgProvParam[0].pbData, param[0].pbData, param[0].cbData), "param1 mismatch\n"); + ok(info->rgProvParam[0].dwFlags == param[0].dwFlags, "got %#x\n", info->rgProvParam[1].dwFlags); + ok(info->rgProvParam[1].dwParam == param[1].dwParam, "got %#x\n", info->rgProvParam[1].dwParam); + ok(info->rgProvParam[1].cbData == param[1].cbData, "got %#x\n", info->rgProvParam[1].cbData); + ok(!memcmp(info->rgProvParam[1].pbData, param[1].pbData, param[1].cbData), "param2 mismatch\n"); + ok(info->rgProvParam[1].dwFlags == param[1].dwFlags, "got %#x\n", info->rgProvParam[1].dwFlags); + HeapFree(GetProcessHeap(), 0, info); + + ret = CertAddCertificateContextToStore(store, cert, CERT_STORE_ADD_NEW, NULL); + ok(ret, "CertAddCertificateContextToStore error %#x\n", GetLastError()); + + CertFreeCertificateContext(cert); + CertCloseStore(store, 0); + + store = CertOpenStore(CERT_STORE_PROV_SYSTEM_A, 0, 0, + CERT_SYSTEM_STORE_CURRENT_USER | CERT_STORE_OPEN_EXISTING_FLAG, "My"); + ok(store != NULL, "CertOpenStore error %u\n", GetLastError()); + + name.pbData = subjectName; + name.cbData = sizeof(subjectName); + cert = CertFindCertificateInStore(store, X509_ASN_ENCODING, 0, CERT_FIND_SUBJECT_NAME, &name, NULL); + ok(cert != NULL, "certificate should exist in My store\n"); + + ret = CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID, NULL, &size); + ok(ret, "CertGetCertificateContextProperty error %#x\n", GetLastError()); + info = HeapAlloc(GetProcessHeap(), 0, size); + ret = CertGetCertificateContextProperty(cert, CERT_KEY_PROV_INFO_PROP_ID, info, &size); + ok(ret, "CertGetCertificateContextProperty error %#x\n", GetLastError()); + ok(!lstrcmpW(info->pwszContainerName, containerW), "got %s\n", wine_dbgstr_w(info->pwszContainerName)); + ok(!lstrcmpW(info->pwszProvName, providerW), "got %s\n", wine_dbgstr_w(info->pwszProvName)); + ok(info->dwProvType == 0x12345678, "got %#x\n", info->dwProvType); + ok(info->dwFlags == 0x87654321, "got %#x\n", info->dwFlags); + ok(info->dwKeySpec == 0x11223344, "got %#x\n", info->dwKeySpec); + ok(info->cProvParam == 2, "got %#x\n", info->cProvParam); + ok(info->rgProvParam != NULL, "got %p\n", info->rgProvParam); + ok(info->rgProvParam[0].dwParam == param[0].dwParam, "got %#x\n", info->rgProvParam[0].dwParam); + ok(info->rgProvParam[0].cbData == param[0].cbData, "got %#x\n", info->rgProvParam[0].cbData); + ok(!memcmp(info->rgProvParam[0].pbData, param[0].pbData, param[0].cbData), "param1 mismatch\n"); + ok(info->rgProvParam[0].dwFlags == param[0].dwFlags, "got %#x\n", info->rgProvParam[1].dwFlags); + ok(info->rgProvParam[1].dwParam == param[1].dwParam, "got %#x\n", info->rgProvParam[1].dwParam); + ok(info->rgProvParam[1].cbData == param[1].cbData, "got %#x\n", info->rgProvParam[1].cbData); + ok(!memcmp(info->rgProvParam[1].pbData, param[1].pbData, param[1].cbData), "param2 mismatch\n"); + ok(info->rgProvParam[1].dwFlags == param[1].dwFlags, "got %#x\n", info->rgProvParam[1].dwFlags); + HeapFree(GetProcessHeap(), 0, info); + + ret = CertDeleteCertificateFromStore(cert); + ok(ret, "CertDeleteCertificateFromStore error %#x\n", GetLastError()); + + CertFreeCertificateContext(cert); + CertCloseStore(store, 0); +} + START_TEST(cert) { init_function_pointers(); @@ -4152,6 +4247,7 @@ START_TEST(cert) testGetSubjectCert(); testGetIssuerCert(); testLinkCert(); + testKeyProvInfo(); testCryptHashCert(); testCryptHashCert2(); -- 2.29.2

3 7

[PATCH] qcap: Use wide-char string literals.
by Michael Stefaniuc Dec. 2, 2020

Dec. 2, 2020

Signed-off-by: Michael Stefaniuc <mstefani(a)winehq.org> --- dlls/qcap/capturegraph.c | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/dlls/qcap/capturegraph.c b/dlls/qcap/capturegraph.c index b1569bbc3a3..e3f047b9957 100644 --- a/dlls/qcap/capturegraph.c +++ b/dlls/qcap/capturegraph.c @@ -371,9 +371,6 @@ static HRESULT match_smart_tee_pin(CaptureGraphImpl *This, IUnknown *pSource, IPin **source_out) { - static const WCHAR inputW[] = {'I','n','p','u','t',0}; - static const WCHAR captureW[] = {'C','a','p','t','u','r','e',0}; - static const WCHAR previewW[] = {'P','r','e','v','i','e','w',0}; IPin *capture = NULL; IPin *preview = NULL; IPin *peer = NULL; @@ -439,7 +436,7 @@ static HRESULT match_smart_tee_pin(CaptureGraphImpl *This, hr = IGraphBuilder_AddFilter(This->mygraph, smartTee, NULL); if (SUCCEEDED(hr)) { IPin *smartTeeInput = NULL; - hr = IBaseFilter_FindPin(smartTee, inputW, &smartTeeInput); + hr = IBaseFilter_FindPin(smartTee, L"Input", &smartTeeInput); if (SUCCEEDED(hr)) { hr = IGraphBuilder_ConnectDirect(This->mygraph, capture, smartTeeInput, NULL); IPin_Release(smartTeeInput); @@ -456,9 +453,9 @@ static HRESULT match_smart_tee_pin(CaptureGraphImpl *This, goto end; } if (IsEqualIID(pCategory, &PIN_CATEGORY_CAPTURE)) - hr = IBaseFilter_FindPin(smartTee, captureW, source_out); + hr = IBaseFilter_FindPin(smartTee, L"Capture", source_out); else { - hr = IBaseFilter_FindPin(smartTee, previewW, source_out); + hr = IBaseFilter_FindPin(smartTee, L"Preview", source_out); if (SUCCEEDED(hr)) hr = VFW_S_NOPREVIEWPIN; } -- 2.26.2

2 1