March 2021 - Wine-Devel - list.winehq.org

[PATCH 1/2] qedit/tests: Check the Sample Grabber's buffer during and after flushing.
by Gabriel Ivăncescu Oct. 4, 2022

Oct. 4, 2022

Signed-off-by: Gabriel Ivăncescu <gabrielopcode(a)gmail.com> --- dlls/qedit/tests/samplegrabber.c | 234 +++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/dlls/qedit/tests/samplegrabber.c b/dlls/qedit/tests/samplegrabber.c index 8e68e3e..e66180f 100644 --- a/dlls/qedit/tests/samplegrabber.c +++ b/dlls/qedit/tests/samplegrabber.c @@ -1036,6 +1036,239 @@ static void test_connect_pin(void) ok(!ref, "Got outstanding refcount %d.\n", ref); } +struct frame_thread_params +{ + IMemInputPin *sink; + IMediaSample *sample; + DWORD delay; +}; + +static DWORD WINAPI frame_thread(void *arg) +{ + struct frame_thread_params *params = arg; + HRESULT hr; + + if (params->delay) + { + if (winetest_debug > 1) trace("%04x: Sleeping %u ms.\n", GetCurrentThreadId(), params->delay); + Sleep(params->delay); + } + if (winetest_debug > 1) trace("%04x: Sending frame.\n", GetCurrentThreadId()); + hr = IMemInputPin_Receive(params->sink, params->sample); + if (winetest_debug > 1) trace("%04x: Returned %#x.\n", GetCurrentThreadId(), hr); + IMediaSample_Release(params->sample); + free(params); + return hr; +} + +static HANDLE send_frame_time(IMemInputPin *sink, REFERENCE_TIME start_time, unsigned char color, DWORD delay) +{ + struct frame_thread_params *params = malloc(sizeof(*params)); + IMemAllocator *allocator; + REFERENCE_TIME end_time; + IMediaSample *sample; + HANDLE thread; + HRESULT hr; + BYTE *data; + + hr = IMemInputPin_GetAllocator(sink, &allocator); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + if (hr == VFW_E_NOT_COMMITTED) + { + IMemAllocator_Commit(allocator); + hr = IMemAllocator_GetBuffer(allocator, &sample, NULL, NULL, 0); + } + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaSample_GetPointer(sample, &data); + ok(hr == S_OK, "Got hr %#x.\n", hr); + memset(data, 0x55, 32 * 16 * 2); + + hr = IMediaSample_SetActualDataLength(sample, 32 * 16 * 2); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + start_time *= 10000000; + end_time = start_time + 10000000; + hr = IMediaSample_SetTime(sample, &start_time, &end_time); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + params->sink = sink; + params->sample = sample; + params->delay = delay; + thread = CreateThread(NULL, 0, frame_thread, params, 0, NULL); + + IMemAllocator_Release(allocator); + return thread; +} + +static HANDLE send_frame(IMemInputPin *sink, DWORD delay) +{ + return send_frame_time(sink, 0, 0x55, delay); /* purple */ +} + +static HRESULT join_thread_(int line, HANDLE thread) +{ + DWORD ret; + ok_(__FILE__, line)(!WaitForSingleObject(thread, 1000), "Wait failed.\n"); + GetExitCodeThread(thread, &ret); + CloseHandle(thread); + return ret; +} +#define join_thread(a) join_thread_(__LINE__, a) + +static void test_buffer_flush(void) +{ + AM_MEDIA_TYPE req_mt = + { + .majortype = MEDIATYPE_Video, + .subtype = MEDIASUBTYPE_RGB565, + .formattype = FORMAT_VideoInfo, + .bTemporalCompression = TRUE, + }; + LONG buf[(32 * 16 * 2) / sizeof(LONG)], size = sizeof(buf); + IPin *sink, *source, *renderer_pin; + struct testfilter testsource; + ISampleGrabber *grabber; + IMediaControl *control; + IFilterGraph2 *graph; + IMemInputPin *input; + IBaseFilter *filter; + OAFilterState state; + IMediaFilter *mf; + HANDLE thread; + DWORD ticks; + unsigned i; + HRESULT hr; + ULONG ref; + + testfilter_init(&testsource); + CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, + &IID_IFilterGraph2, (void **)&graph); + CoCreateInstance(&CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, + &IID_IBaseFilter, (void **)&filter); + IFilterGraph2_AddFilter(graph, filter, L"sink"); + IBaseFilter_FindPin(filter, L"In", &renderer_pin); + IBaseFilter_Release(filter); + + filter = create_sample_grabber(); + IFilterGraph2_AddFilter(graph, &testsource.filter.IBaseFilter_iface, L"source"); + IFilterGraph2_AddFilter(graph, filter, L"sample grabber"); + IBaseFilter_FindPin(filter, L"In", &sink); + IBaseFilter_FindPin(filter, L"Out", &source); + IBaseFilter_QueryInterface(filter, &IID_ISampleGrabber, (void **)&grabber); + IFilterGraph2_QueryInterface(graph, &IID_IMediaControl, (void **)&control); + IPin_QueryInterface(sink, &IID_IMemInputPin, (void **)&input); + + ISampleGrabber_SetMediaType(grabber, &req_mt); + ISampleGrabber_SetBufferSamples(grabber, TRUE); + + testsource.sink_mt = &req_mt; + hr = IFilterGraph2_ConnectDirect(graph, &testsource.source.pin.IPin_iface, sink, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IFilterGraph2_ConnectDirect(graph, source, renderer_pin, &req_mt); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_Release(renderer_pin); + + IFilterGraph2_QueryInterface(graph, &IID_IMediaFilter, (void **)&mf); + IMediaFilter_SetSyncSource(mf, NULL); + IMediaFilter_Release(mf); + + hr = IMemInputPin_ReceiveCanBlock(input); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == VFW_E_WRONG_STATE, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(state == State_Stopped, "Got state %d.\n", state); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + + hr = IMediaControl_Pause(control); + ok(hr == S_FALSE, "Got hr %#x.\n", hr); + hr = IMediaControl_GetState(control, 0, &state); + ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + thread = send_frame(input, 0); + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(WaitForSingleObject(thread, 100) == WAIT_TIMEOUT, "Thread should block in Receive().\n"); + + for (i = 0; i < 3; i++) + { + ticks = GetTickCount(); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + } + + IPin_BeginFlush(sink); + hr = join_thread(thread); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ok(hr == S_OK, "Got hr %#x.\n", hr); + IPin_EndFlush(sink); + + hr = IMediaControl_GetState(control, 0, &state); + todo_wine ok(hr == VFW_S_STATE_INTERMEDIATE, "Got hr %#x.\n", hr); + + ticks = GetTickCount(); + thread = send_frame(input, 150); + hr = ISampleGrabber_GetCurrentBuffer(grabber, &size, buf); + ticks = GetTickCount() - ticks; + ok(hr == S_OK, "Got hr %#x.\n", hr); + ok(ticks < 100, "Got %u ticks.\n", ticks); + ok(size == sizeof(buf), "Got size %d.\n", size); + + hr = IMediaControl_GetState(control, 1000, &state); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = IMediaControl_Stop(control); + ok(hr == S_OK, "Got hr %#x.\n", hr); + hr = join_thread(thread); + todo_wine ok(hr == S_OK, "Got hr %#x.\n", hr); + + IPin_Release(sink); + IPin_Release(source); + IMemInputPin_Release(input); + IMediaControl_Release(control); + ref = IFilterGraph2_Release(graph); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ISampleGrabber_Release(grabber); + ref = IBaseFilter_Release(filter); + ok(!ref, "Got outstanding refcount %d.\n", ref); + ref = IBaseFilter_Release(&testsource.filter.IBaseFilter_iface); + ok(!ref, "Got outstanding refcount %d.\n", ref); +} + START_TEST(samplegrabber) { IBaseFilter *filter; @@ -1059,6 +1292,7 @@ START_TEST(samplegrabber) test_aggregation(); test_media_types(); test_connect_pin(); + test_buffer_flush(); CoUninitialize(); } -- 2.21.0

5 7

[PATCH] 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 1/4] dinput8/tests: Make input helper function more versatile.
by Arkadiusz Hiler May 26, 2021

May 26, 2021

test_device_input() now takes properly sized appdata expected value and can be used to send any keyboard event. It also drains device's queue so it can be called multiple times on a single device instance. Signed-off-by: Arkadiusz Hiler <ahiler(a)codeweavers.com> --- dlls/dinput8/tests/device.c | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/dlls/dinput8/tests/device.c b/dlls/dinput8/tests/device.c index 2fc04358cc1..02574961ec1 100644 --- a/dlls/dinput8/tests/device.c +++ b/dlls/dinput8/tests/device.c @@ -80,7 +80,7 @@ static void flush_events(void) } } -static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWORD event, DWORD expected) +static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWORD event, UINT_PTR expected) { HRESULT hr; DIDEVICEOBJECTDATA obj_data; @@ -91,7 +91,7 @@ static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWO ok (SUCCEEDED(hr), "Failed to acquire device hr=%08x\n", hr); if (event_type == INPUT_KEYBOARD) - keybd_event( event, DIK_SPACE, 0, 0); + keybd_event(event, MapVirtualKeyA(event, MAPVK_VK_TO_VSC), 0, 0); if (event_type == INPUT_MOUSE) mouse_event( event, 0, 0, 0, 0); @@ -107,7 +107,7 @@ static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWO return; } - ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%d\n", obj_data.uAppData, expected); + ok (obj_data.uAppData == expected, "Retrieval of action failed uAppData=%lu expected=%lu\n", obj_data.uAppData, expected); /* Check for buffer overflow */ for (i = 0; i < 17; i++) @@ -132,6 +132,14 @@ static void test_device_input(IDirectInputDevice8A *lpdid, DWORD event_type, DWO hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); ok(hr == DI_OK && data_size == 1, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size); + /* drain device's queue */ + while (data_size == 1) + { + hr = IDirectInputDevice8_GetDeviceData(lpdid, sizeof(obj_data), &obj_data, &data_size, 0); + ok(hr == DI_OK, "GetDeviceData() failed: %08x cnt:%d\n", hr, data_size); + if (hr != DI_OK) break; + } + IDirectInputDevice_Unacquire(lpdid); } -- 2.30.1

3 7

[PATCH] winex11: Allow user to set WM_CLASS
by Nicholas Little May 26, 2021

May 26, 2021

This commit allows the user to optionally set the WM_CLASS by setting an environment variable WINEWMCLASS with the aim of allowing him to ensure desktop environments can correctly identify wine windows, unfortunately the executable filename isn't always sufficient as some programs share a common executable name. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=50095 --- dlls/winex11.drv/window.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index 457173964eb..6b87166c830 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -837,6 +837,7 @@ static void set_initial_wm_hints( Display *display, Window window ) Atom protocols[3]; Atom dndVersion = WINE_XDND_VERSION; XClassHint *class_hints; + char *wine_wm_class; /* wm protocols */ i = 0; @@ -849,8 +850,9 @@ static void set_initial_wm_hints( Display *display, Window window ) /* class hints */ if ((class_hints = XAllocClassHint())) { + wine_wm_class = getenv( "WINEWMCLASS" ); class_hints->res_name = process_name; - class_hints->res_class = process_name; + class_hints->res_class = wine_wm_class ? wine_wm_class : process_name; XSetClassHint( display, window, class_hints ); XFree( class_hints ); } -- 2.26.2

2 2

[PATCH] winnt.h: Fix MSVC variants of InterlockedIncrement16 and InterlockedDecrement16.
by Jacek Caban May 7, 2021

May 7, 2021

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- FWIW, depending on distro, building in this mode may be as easy as adding CROSSCC=clang to configure. include/winnt.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)

2 11

[PATCH 1/2] mfreadwrite/tests: Test setting a non-native bit depth on the reader.
by Giovanni Mascellani May 7, 2021

May 7, 2021

--- dlls/mfreadwrite/tests/mfplat.c | 52 +++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/dlls/mfreadwrite/tests/mfplat.c b/dlls/mfreadwrite/tests/mfplat.c index 8ea4e5038f6..8381e535d26 100644 --- a/dlls/mfreadwrite/tests/mfplat.c +++ b/dlls/mfreadwrite/tests/mfplat.c @@ -362,6 +362,8 @@ static HRESULT WINAPI test_source_CreatePresentationDescriptor(IMFMediaSource *i ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 32); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); hr = MFCreateStreamDescriptor(i, 1, &media_type, &sds[i]); ok(hr == S_OK, "Failed to create stream descriptor, hr %#x.\n", hr); @@ -897,6 +899,7 @@ static void test_source_reader_from_media_source(void) struct async_callback *callback; IMFSourceReader *reader; IMFMediaSource *source; + IMFMediaType *media_type; HRESULT hr; DWORD actual_index, stream_flags; IMFSample *sample; @@ -1042,6 +1045,55 @@ static void test_source_reader_from_media_source(void) IMFSourceReader_Release(reader); IMFMediaSource_Release(source); + /* Request a non-native bit depth. */ + source = create_test_source(1); + ok(!!source, "Failed to create test source.\n"); + + hr = MFCreateSourceReaderFromMediaSource(source, NULL, &reader); + ok(hr == S_OK, "Failed to create source reader, hr %#x.\n", hr); + + hr = MFCreateMediaType(&media_type); + ok(hr == S_OK, "Failed to create media type, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 16); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFSourceReader_SetCurrentMediaType(reader, 0, NULL, media_type); +todo_wine + ok(hr == MF_E_TOPO_CODEC_NOT_FOUND, "Unexpected success setting current media type, hr %#x.\n", hr); + + IMFMediaType_Release(media_type); + + hr = MFCreateMediaType(&media_type); + ok(hr == S_OK, "Failed to create media type, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_MAJOR_TYPE, &MFMediaType_Audio); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFAudioFormat_PCM); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + hr = IMFMediaType_SetUINT32(media_type, &MF_MT_AUDIO_BITS_PER_SAMPLE, 32); + ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); + + hr = IMFSourceReader_SetCurrentMediaType(reader, 0, NULL, media_type); + ok(hr == S_OK, "Failed to set current media type, hr %#x.\n", hr); + + hr = IMFSourceReader_SetStreamSelection(reader, 0, TRUE); + ok(hr == S_OK, "Failed to select a stream, hr %#x.\n", hr); + + hr = IMFSourceReader_ReadSample(reader, 0, 0, &actual_index, &stream_flags, &timestamp, &sample); + ok(hr == S_OK, "Failed to get a sample, hr %#x.\n", hr); + ok(actual_index == 0, "Unexpected stream index %u\n", actual_index); + ok(!stream_flags, "Unexpected stream flags %#x.\n", stream_flags); + ok(timestamp == 123, "Unexpected timestamp.\n"); + ok(!!sample, "Expected sample object.\n"); + IMFSample_Release(sample); + + IMFMediaType_Release(media_type); + IMFSourceReader_Release(reader); + IMFMediaSource_Release(source); + /* Async mode. */ source = create_test_source(3); ok(!!source, "Failed to create test source.\n"); -- 2.31.0

2 5

[PATCH v2 1/2] ntdll/tests: Add a test for segment register contents in x86_64 exception handlers.
by Zebediah Figura May 1, 2021

May 1, 2021

Signed-off-by: Zebediah Figura <z.figura12(a)gmail.com> --- v2: Test the contents of %es, %fs, %gs as well. dlls/ntdll/tests/exception.c | 40 +++++++++++++++++++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/tests/exception.c b/dlls/ntdll/tests/exception.c index da88ca449fb..7c75606dd32 100644 --- a/dlls/ntdll/tests/exception.c +++ b/dlls/ntdll/tests/exception.c @@ -2812,7 +2812,7 @@ static void test___C_specific_handler(void) /* This is heavily based on the i386 exception tests. */ static const struct exception { - BYTE code[18]; /* asm code */ + BYTE code[40]; /* asm code */ BYTE offset; /* offset of faulting instruction */ BYTE length; /* length of faulting instruction */ NTSTATUS status; /* expected status code */ @@ -2921,6 +2921,34 @@ static const struct exception /* 35 */ { { 0xa3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3 }, /* movl %eax,0xffffffffffffffff; ret */ 0, 9, STATUS_ACCESS_VIOLATION, 2, { 1, 0xffffffffffffffff } }, + + /* test exception with cleared segment registers */ + { { + 0x8c, 0xc0, /* mov %es,%eax */ + 0x50, /* push %rax */ + 0x8c, 0xd8, /* mov %ds,%eax */ + 0x50, /* push %rax */ + 0x8c, 0xe0, /* mov %fs,%eax */ + 0x50, /* push %rax */ + 0x8c, 0xe8, /* mov %gs,%eax */ + 0x50, /* push %rax */ + 0x31, 0xc0, /* xor %eax,%eax */ + 0x8e, 0xc0, /* mov %eax,%es */ + 0x8e, 0xd8, /* mov %eax,%ds */ + 0x8e, 0xe0, /* mov %eax,%fs */ + 0x8e, 0xe8, /* mov %eax,%gs */ + 0xfa, /* cli */ + 0x58, /* pop %rax */ + 0x8e, 0xe8, /* mov %eax,%gs */ + 0x58, /* pop %rax */ + 0x8e, 0xe0, /* mov %eax,%fs */ + 0x58, /* pop %rax */ + 0x8e, 0xd8, /* mov %eax,%ds */ + 0x58, /* pop %rax */ + 0x8e, 0xc0, /* mov %eax,%es */ + 0xc3, /* retq */ + }, 22, 1, STATUS_PRIVILEGED_INSTRUCTION, 0 }, + { { 0xf1, 0x90, 0xc3 }, /* icebp; nop; ret */ 1, 1, STATUS_SINGLE_STEP, 0 }, { { 0xcd, 0x2c, 0xc3 }, @@ -2992,6 +3020,16 @@ static DWORD WINAPI handler( EXCEPTION_RECORD *rec, ULONG64 frame, "%u: Unexpected exception address %p/%p\n", entry, rec->ExceptionAddress, (char*)context->Rip ); + todo_wine ok( context->SegDs == context->SegSs, + "%u: ds %#x does not match ss %#x\n", entry, context->SegDs, context->SegSs ); + todo_wine ok( context->SegEs == context->SegSs, + "%u: es %#x does not match ss %#x\n", entry, context->SegEs, context->SegSs ); + todo_wine ok( context->SegGs == context->SegSs, + "%u: ds %#x does not match ss %#x\n", entry, context->SegGs, context->SegSs ); + + todo_wine ok( context->SegFs && context->SegFs != context->SegSs, + "%u: got fs %#x\n", entry, context->SegFs ); + if (except->status == STATUS_BREAKPOINT && is_wow64) parameter_count = 1; else if (except->alt_status == 0 || rec->ExceptionCode != except->alt_status) -- 2.30.2

4 6

[PATCH 3/3] riched20: Implement TxGetNaturalSize().
by Huw Davies April 29, 2021

April 29, 2021

Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/riched20/tests/txtsrv.c | 6 +++--- dlls/riched20/txtsrv.c | 39 +++++++++++++++++++++++++++++++----- 2 files changed, 37 insertions(+), 8 deletions(-) diff --git a/dlls/riched20/tests/txtsrv.c b/dlls/riched20/tests/txtsrv.c index 7ca6074587d..3cfd5e63753 100644 --- a/dlls/riched20/tests/txtsrv.c +++ b/dlls/riched20/tests/txtsrv.c @@ -705,7 +705,7 @@ static void _check_txgetnaturalsize(HRESULT res, LONG width, LONG height, HDC hd expected_width = expected_rect.right - expected_rect.left; expected_height = expected_rect.bottom - expected_rect.top; ok_(__FILE__,line)(res == S_OK, "ITextServices_TxGetNaturalSize failed: 0x%08x.\n", res); - ok_(__FILE__,line)(width >= expected_width && width <= expected_width + 1, + todo_wine ok_(__FILE__,line)(width >= expected_width && width <= expected_width + 1, "got wrong width: %d, expected: %d {+1}.\n", width, expected_width); ok_(__FILE__,line)(height == expected_height, "got wrong height: %d, expected: %d.\n", height, expected_height); @@ -717,7 +717,7 @@ static void test_TxGetNaturalSize(void) ITextHost *host; HRESULT result; SIZEL extent; - static const WCHAR test_text[] = {'T','e','s','t','S','o','m','e','T','e','x','t',0}; + static const WCHAR test_text[] = L"TestSomeText"; LONG width, height; HDC hdcDraw; HWND hwnd; @@ -752,7 +752,7 @@ static void test_TxGetNaturalSize(void) height = 0; result = ITextServices_TxGetNaturalSize(txtserv, DVASPECT_CONTENT, hdcDraw, NULL, NULL, TXTNS_FITTOCONTENT, &extent, &width, &height); - todo_wine CHECK_TXGETNATURALSIZE(result, width, height, hdcDraw, rect, test_text); + CHECK_TXGETNATURALSIZE(result, width, height, hdcDraw, rect, test_text); ReleaseDC(hwnd, hdcDraw); DestroyWindow(hwnd); diff --git a/dlls/riched20/txtsrv.c b/dlls/riched20/txtsrv.c index 79ade0f6117..5736964c1b1 100644 --- a/dlls/riched20/txtsrv.c +++ b/dlls/riched20/txtsrv.c @@ -366,14 +366,43 @@ DECLSPEC_HIDDEN HRESULT __thiscall fnTextSrv_TxGetBaseLinePos(ITextServices *ifa } DEFINE_THISCALL_WRAPPER(fnTextSrv_TxGetNaturalSize,36) -DECLSPEC_HIDDEN HRESULT __thiscall fnTextSrv_TxGetNaturalSize(ITextServices *iface, DWORD dwAspect, HDC hdcDraw, - HDC hicTargetDev, DVTARGETDEVICE *ptd, DWORD dwMode, - const SIZEL *psizelExtent, LONG *pwidth, LONG *pheight) +DECLSPEC_HIDDEN HRESULT __thiscall fnTextSrv_TxGetNaturalSize( ITextServices *iface, DWORD aspect, HDC draw, + HDC target, DVTARGETDEVICE *td, DWORD mode, + const SIZEL *extent, LONG *width, LONG *height ) { struct text_services *services = impl_from_ITextServices( iface ); + RECT rect; + HDC dc = draw; + BOOL rewrap = FALSE; + HRESULT hr; - FIXME( "%p: STUB\n", services ); - return E_NOTIMPL; + TRACE( "%p: aspect %d, draw %p, target %p, td %p, mode %08x, extent %s, *width %d, *height %d\n", services, + aspect, draw, target, td, mode, wine_dbgstr_point( (POINT *)extent ), *width, *height ); + + if (aspect != DVASPECT_CONTENT || target || td || mode != TXTNS_FITTOCONTENT ) + FIXME( "Many arguments are ignored\n" ); + + SetRect( &rect, 0, 0, *width, *height ); + + hr = update_client_rect( services, &rect ); + if (FAILED( hr )) return hr; + if (hr == S_OK) rewrap = TRUE; + + if (!dc && services->editor->in_place_active) + dc = ITextHost_TxGetDC( services->host ); + if (!dc) return E_FAIL; + + if (rewrap) + { + editor_mark_rewrap_all( services->editor ); + wrap_marked_paras_dc( services->editor, dc, FALSE ); + } + + *width = services->editor->nTotalWidth; + *height = services->editor->nTotalLength; + + if (!draw) ITextHost_TxReleaseDC( services->host, dc ); + return S_OK; } DEFINE_THISCALL_WRAPPER(fnTextSrv_TxGetDropTarget,8) -- 2.23.0

3 2