July 2019 - Wine-devel - list.winehq.org

[PATCH 2/2] winmm: Build with msvcrt.
by Jacek Caban 05 Jul '19

05 Jul '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winmm/Makefile.in | 2 + dlls/winmm/driver.c | 6 +-- dlls/winmm/joystick.c | 8 ---- dlls/winmm/lolvldrv.c | 2 - dlls/winmm/mci.c | 105 ++++++++++++++++++++--------------------- 5 files changed, 54 insertions(+), 69 deletions(-)

3 3

[PATCH 1/2] winmm: Use condition variable to sleep in timer thread.
by Jacek Caban 05 Jul '19

05 Jul '19

We have fast condition variable implementation now, so performance should not be a problem. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/winmm/time.c | 81 ++++++++--------------------------------------- 1 file changed, 14 insertions(+), 67 deletions(-)

3 2

[PATCH] appwiz.cpl: Use use GetFileAttributes in install_from_unix_file.
by Jacek Caban 05 Jul '19

05 Jul '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/appwiz.cpl/addons.c | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-)

1 0

[v2 PATCH] winegstreamer: Add stub Video Processor MFT.
by Nikolay Sivov 05 Jul '19

05 Jul '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- v2: skip tests on failure dlls/mf/tests/mf.c | 30 ++- dlls/winegstreamer/Makefile.in | 7 +- dlls/winegstreamer/gst_private.h | 3 + dlls/winegstreamer/main.c | 14 +- dlls/winegstreamer/mfplat.c | 444 +++++++++++++++++++++++++++++++ dlls/winegstreamer/mfplat.idl | 26 ++ 6 files changed, 516 insertions(+), 8 deletions(-) create mode 100644 dlls/winegstreamer/mfplat.c create mode 100644 dlls/winegstreamer/mfplat.idl diff --git a/dlls/mf/tests/mf.c b/dlls/mf/tests/mf.c index 15aa58620a..0d66da1392 100644 --- a/dlls/mf/tests/mf.c +++ b/dlls/mf/tests/mf.c @@ -2079,11 +2079,11 @@ static void test_video_processor(void) hr = CoCreateInstance(&CLSID_VideoProcessorMFT, NULL, CLSCTX_INPROC_SERVER, &IID_IMFTransform, (void **)&transform); -todo_wine - ok(hr == S_OK || broken(hr == REGDB_E_CLASSNOTREG), "Failed to create video processor transform, hr %#x.\n", hr); - if (FAILED(hr)) + { + skip("Failed to create Video Processor instance, skipping tests.\n"); goto failed; + } hr = IMFTransform_QueryInterface(transform, &IID_IMFMediaEventGenerator, (void **)&unk); ok(hr == E_NOINTERFACE, "Unexpected hr %#x.\n", hr); @@ -2120,12 +2120,14 @@ todo_wine ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetInputStatus(transform, 0, &flags); +todo_wine ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetInputStreamAttributes(transform, 0, &attributes); ok(hr == E_NOTIMPL, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetOutputStatus(transform, &flags); +todo_wine ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetOutputStreamAttributes(transform, 0, &attributes); @@ -2137,30 +2139,38 @@ todo_wine IMFAttributes_Release(attributes2); hr = IMFTransform_GetOutputAvailableType(transform, 0, 0, &media_type); +todo_wine ok(hr == MF_E_NO_MORE_TYPES, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetInputCurrentType(transform, 0, &media_type); +todo_wine ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetInputCurrentType(transform, 1, &media_type); +todo_wine ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetOutputCurrentType(transform, 0, &media_type); +todo_wine ok(hr == MF_E_TRANSFORM_TYPE_NOT_SET, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetOutputCurrentType(transform, 1, &media_type); +todo_wine ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr); hr = IMFTransform_GetInputStreamInfo(transform, 1, &input_info); +todo_wine ok(hr == MF_E_INVALIDSTREAMNUMBER, "Unexpected hr %#x.\n", hr); + memset(&input_info, 0xcc, sizeof(input_info)); hr = IMFTransform_GetInputStreamInfo(transform, 0, &input_info); +todo_wine { ok(hr == S_OK, "Failed to get stream info, hr %#x.\n", hr); ok(input_info.dwFlags == 0, "Unexpected flag %#x.\n", input_info.dwFlags); ok(input_info.cbSize == 0, "Unexpected size %u.\n", input_info.cbSize); ok(input_info.cbMaxLookahead == 0, "Unexpected lookahead length %u.\n", input_info.cbMaxLookahead); ok(input_info.cbAlignment == 0, "Unexpected alignment %u.\n", input_info.cbAlignment); - +} hr = MFCreateMediaEvent(MEUnknown, &GUID_NULL, S_OK, NULL, &event); ok(hr == S_OK, "Failed to create event object, hr %#x.\n", hr); hr = IMFTransform_ProcessEvent(transform, 0, event); @@ -2174,6 +2184,7 @@ todo_wine { if (FAILED(hr = IMFTransform_GetInputAvailableType(transform, 0, i, &media_type))) { + todo_wine ok(hr == MF_E_NO_MORE_TYPES, "Unexpected hr %#x.\n", hr); break; } @@ -2254,17 +2265,22 @@ todo_wine ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); hr = IMFTransform_SetInputType(transform, 0, media_type, 0); +todo_wine ok(hr == S_OK, "Failed to set input type, hr %#x.\n", hr); hr = IMFMediaType_SetGUID(media_type, &MF_MT_SUBTYPE, &MFVideoFormat_RGB32); ok(hr == S_OK, "Failed to set attribute, hr %#x.\n", hr); hr = IMFTransform_SetOutputType(transform, 0, media_type, 0); +todo_wine ok(hr == S_OK, "Failed to set output type, hr %#x.\n", hr); + memset(&output_info, 0, sizeof(output_info)); hr = IMFTransform_GetOutputStreamInfo(transform, 0, &output_info); +todo_wine ok(hr == S_OK, "Failed to get stream info, hr %#x.\n", hr); ok(output_info.dwFlags == 0, "Unexpected flags %#x.\n", output_info.dwFlags); +todo_wine ok(output_info.cbSize > 0, "Unexpected size %u.\n", output_info.cbSize); ok(output_info.cbAlignment == 0, "Unexpected alignment %u.\n", output_info.cbAlignment); @@ -2278,20 +2294,24 @@ todo_wine output_buffer.pSample = sample; flags = 0; hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); +todo_wine ok(hr == MF_E_TRANSFORM_NEED_MORE_INPUT, "Unexpected hr %#x.\n", hr); ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); ok(flags == 0, "Unexpected status %#x.\n", flags); hr = IMFTransform_ProcessInput(transform, 0, sample2, 0); +todo_wine ok(hr == S_OK, "Failed to push a sample, hr %#x.\n", hr); hr = IMFTransform_ProcessInput(transform, 0, sample2, 0); +todo_wine ok(hr == MF_E_NOTACCEPTING, "Unexpected hr %#x.\n", hr); memset(&output_buffer, 0, sizeof(output_buffer)); output_buffer.pSample = sample; flags = 0; hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); +todo_wine ok(hr == MF_E_NO_SAMPLE_TIMESTAMP, "Unexpected hr %#x.\n", hr); ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); ok(flags == 0, "Unexpected status %#x.\n", flags); @@ -2302,6 +2322,7 @@ todo_wine output_buffer.pSample = sample; flags = 0; hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); +todo_wine ok(hr == E_INVALIDARG, "Unexpected hr %#x.\n", hr); ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); ok(flags == 0, "Unexpected status %#x.\n", flags); @@ -2319,6 +2340,7 @@ todo_wine output_buffer.pSample = sample; flags = 0; hr = IMFTransform_ProcessOutput(transform, 0, 1, &output_buffer, &flags); +todo_wine ok(hr == S_OK || broken(FAILED(hr)) /* Win8 */, "Failed to get output buffer, hr %#x.\n", hr); ok(output_buffer.dwStatus == 0, "Unexpected buffer status, %#x.\n", output_buffer.dwStatus); ok(flags == 0, "Unexpected status %#x.\n", flags); diff --git a/dlls/winegstreamer/Makefile.in b/dlls/winegstreamer/Makefile.in index fecabe8ba2..437915f6da 100644 --- a/dlls/winegstreamer/Makefile.in +++ b/dlls/winegstreamer/Makefile.in @@ -1,5 +1,5 @@ MODULE = winegstreamer.dll -IMPORTS = strmbase strmiids uuid winmm msacm32 msvfw32 ole32 oleaut32 user32 gdi32 advapi32 +IMPORTS = strmbase strmiids uuid winmm msacm32 msvfw32 ole32 oleaut32 user32 gdi32 advapi32 mfplat mfuuid EXTRAINCL = $(GSTREAMER_CFLAGS) EXTRALIBS = $(GSTREAMER_LIBS) $(PTHREAD_LIBS) @@ -7,7 +7,10 @@ C_SRCS = \ gst_cbs.c \ gstdemux.c \ gsttffilter.c \ - main.c + main.c \ + mfplat.c + +IDL_SRCS = mfplat.idl RC_SRCS = \ rsrc.rc diff --git a/dlls/winegstreamer/gst_private.h b/dlls/winegstreamer/gst_private.h index 85659c4bd9..06236e2636 100644 --- a/dlls/winegstreamer/gst_private.h +++ b/dlls/winegstreamer/gst_private.h @@ -53,4 +53,7 @@ void start_dispatch_thread(void) DECLSPEC_HIDDEN; extern const char *media_quark_string DECLSPEC_HIDDEN; +extern HRESULT mfplat_get_class_object(REFCLSID rclsid, REFIID riid, void **obj) DECLSPEC_HIDDEN; +extern HRESULT mfplat_can_unload_now(void) DECLSPEC_HIDDEN; + #endif /* __GST_PRIVATE_INCLUDED__ */ diff --git a/dlls/winegstreamer/main.c b/dlls/winegstreamer/main.c index f11e59a914..4419a6fde5 100644 --- a/dlls/winegstreamer/main.c +++ b/dlls/winegstreamer/main.c @@ -232,7 +232,12 @@ BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) */ HRESULT WINAPI DllCanUnloadNow(void) { - return STRMBASE_DllCanUnloadNow(); + HRESULT hr = STRMBASE_DllCanUnloadNow(); + + if (hr == S_OK) + hr = mfplat_can_unload_now(); + + return hr; } /*********************************************************************** @@ -240,7 +245,12 @@ HRESULT WINAPI DllCanUnloadNow(void) */ HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) { - return STRMBASE_DllGetClassObject( rclsid, riid, ppv ); + HRESULT hr; + + if (FAILED(hr = mfplat_get_class_object(rclsid, riid, ppv))) + hr = STRMBASE_DllGetClassObject( rclsid, riid, ppv ); + + return hr; } /* GStreamer common functions */ diff --git a/dlls/winegstreamer/mfplat.c b/dlls/winegstreamer/mfplat.c new file mode 100644 index 0000000000..2233bbe159 --- /dev/null +++ b/dlls/winegstreamer/mfplat.c @@ -0,0 +1,444 @@ +/* + * Copyright 2019 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <stdarg.h> + +#define COBJMACROS +#define NONAMELESSUNION + +#include "mfapi.h" +#include "mfidl.h" + +#include "wine/debug.h" +#include "wine/heap.h" + +WINE_DEFAULT_DEBUG_CHANNEL(mfplat); + +static LONG object_locks; + +struct video_processor +{ + IMFTransform IMFTransform_iface; + LONG refcount; + IMFAttributes *attributes; + IMFAttributes *output_attributes; +}; + +static struct video_processor *impl_video_processor_from_IMFTransform(IMFTransform *iface) +{ + return CONTAINING_RECORD(iface, struct video_processor, IMFTransform_iface); +} + +static HRESULT WINAPI video_processor_QueryInterface(IMFTransform *iface, REFIID riid, void **obj) +{ + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualIID(riid, &IID_IMFTransform) || + IsEqualIID(riid, &IID_IUnknown)) + { + *obj = iface; + IMFTransform_AddRef(iface); + return S_OK; + } + + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI video_processor_AddRef(IMFTransform *iface) +{ + struct video_processor *transform = impl_video_processor_from_IMFTransform(iface); + ULONG refcount = InterlockedIncrement(&transform->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI video_processor_Release(IMFTransform *iface) +{ + struct video_processor *transform = impl_video_processor_from_IMFTransform(iface); + ULONG refcount = InterlockedDecrement(&transform->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + if (transform->attributes) + IMFAttributes_Release(transform->attributes); + if (transform->output_attributes) + IMFAttributes_Release(transform->output_attributes); + heap_free(transform); + } + + return refcount; +} + +static HRESULT WINAPI video_processor_GetStreamLimits(IMFTransform *iface, DWORD *input_minimum, DWORD *input_maximum, + DWORD *output_minimum, DWORD *output_maximum) +{ + TRACE("%p, %p, %p, %p, %p.\n", iface, input_minimum, input_maximum, output_minimum, output_maximum); + + *input_minimum = *input_maximum = *output_minimum = *output_maximum = 1; + + return S_OK; +} + +static HRESULT WINAPI video_processor_GetStreamCount(IMFTransform *iface, DWORD *inputs, DWORD *outputs) +{ + TRACE("%p, %p, %p.\n", iface, inputs, outputs); + + *inputs = *outputs = 1; + + return S_OK; +} + +static HRESULT WINAPI video_processor_GetStreamIDs(IMFTransform *iface, DWORD input_size, DWORD *inputs, + DWORD output_size, DWORD *outputs) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetInputStreamInfo(IMFTransform *iface, DWORD id, MFT_INPUT_STREAM_INFO *info) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetOutputStreamInfo(IMFTransform *iface, DWORD id, MFT_OUTPUT_STREAM_INFO *info) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetAttributes(IMFTransform *iface, IMFAttributes **attributes) +{ + struct video_processor *transform = impl_video_processor_from_IMFTransform(iface); + + TRACE("%p, %p.\n", iface, attributes); + + *attributes = transform->attributes; + IMFAttributes_AddRef(*attributes); + + return S_OK; +} + +static HRESULT WINAPI video_processor_GetInputStreamAttributes(IMFTransform *iface, DWORD id, + IMFAttributes **attributes) +{ + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetOutputStreamAttributes(IMFTransform *iface, DWORD id, + IMFAttributes **attributes) +{ + struct video_processor *transform = impl_video_processor_from_IMFTransform(iface); + + TRACE("%p, %u, %p.\n", iface, id, attributes); + + *attributes = transform->output_attributes; + IMFAttributes_AddRef(*attributes); + + return S_OK; +} + +static HRESULT WINAPI video_processor_DeleteInputStream(IMFTransform *iface, DWORD id) +{ + TRACE("%p, %u.\n", iface, id); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_AddInputStreams(IMFTransform *iface, DWORD streams, DWORD *ids) +{ + TRACE("%p, %u, %p.\n", iface, streams, ids); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetInputAvailableType(IMFTransform *iface, DWORD id, DWORD index, + IMFMediaType **type) +{ + FIXME("%p, %u, %u, %p.\n", iface, id, index, type); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetOutputAvailableType(IMFTransform *iface, DWORD id, DWORD index, + IMFMediaType **type) +{ + FIXME("%p, %u, %u, %p.\n", iface, id, index, type); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_SetInputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags) +{ + FIXME("%p, %u, %p, %#x.\n", iface, id, type, flags); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_SetOutputType(IMFTransform *iface, DWORD id, IMFMediaType *type, DWORD flags) +{ + FIXME("%p, %u, %p, %#x.\n", iface, id, type, flags); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetInputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type) +{ + FIXME("%p, %u, %p.\n", iface, id, type); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetOutputCurrentType(IMFTransform *iface, DWORD id, IMFMediaType **type) +{ + FIXME("%p, %u, %p.\n", iface, id, type); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetInputStatus(IMFTransform *iface, DWORD id, DWORD *flags) +{ + FIXME("%p, %u, %p.\n", iface, id, flags); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_GetOutputStatus(IMFTransform *iface, DWORD *flags) +{ + FIXME("%p, %p.\n", iface, flags); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_SetOutputBounds(IMFTransform *iface, LONGLONG lower, LONGLONG upper) +{ + FIXME("%p, %s, %s.\n", iface, wine_dbgstr_longlong(lower), wine_dbgstr_longlong(upper)); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_ProcessEvent(IMFTransform *iface, DWORD id, IMFMediaEvent *event) +{ + TRACE("%p, %u, %p.\n", iface, id, event); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_ProcessMessage(IMFTransform *iface, MFT_MESSAGE_TYPE message, ULONG_PTR param) +{ + FIXME("%p, %u.\n", iface, message); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_ProcessInput(IMFTransform *iface, DWORD id, IMFSample *sample, DWORD flags) +{ + FIXME("%p, %u, %p, %#x.\n", iface, id, sample, flags); + + return E_NOTIMPL; +} + +static HRESULT WINAPI video_processor_ProcessOutput(IMFTransform *iface, DWORD flags, DWORD count, + MFT_OUTPUT_DATA_BUFFER *samples, DWORD *status) +{ + FIXME("%p, %#x, %u, %p, %p.\n", iface, flags, count, samples, status); + + return E_NOTIMPL; +} + +static const IMFTransformVtbl video_processor_vtbl = +{ + video_processor_QueryInterface, + video_processor_AddRef, + video_processor_Release, + video_processor_GetStreamLimits, + video_processor_GetStreamCount, + video_processor_GetStreamIDs, + video_processor_GetInputStreamInfo, + video_processor_GetOutputStreamInfo, + video_processor_GetAttributes, + video_processor_GetInputStreamAttributes, + video_processor_GetOutputStreamAttributes, + video_processor_DeleteInputStream, + video_processor_AddInputStreams, + video_processor_GetInputAvailableType, + video_processor_GetOutputAvailableType, + video_processor_SetInputType, + video_processor_SetOutputType, + video_processor_GetInputCurrentType, + video_processor_GetOutputCurrentType, + video_processor_GetInputStatus, + video_processor_GetOutputStatus, + video_processor_SetOutputBounds, + video_processor_ProcessEvent, + video_processor_ProcessMessage, + video_processor_ProcessInput, + video_processor_ProcessOutput, +}; + +struct class_factory +{ + IClassFactory IClassFactory_iface; + LONG refcount; + HRESULT (*create_instance)(REFIID riid, void **obj); +}; + +static struct class_factory *impl_from_IClassFactory(IClassFactory *iface) +{ + return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface); +} + +static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID riid, void **obj) +{ + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualGUID(riid, &IID_IClassFactory) || + IsEqualGUID(riid, &IID_IUnknown)) + { + *obj = iface; + IClassFactory_AddRef(iface); + return S_OK; + } + + WARN("%s is not supported.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI class_factory_AddRef(IClassFactory *iface) +{ + struct class_factory *factory = impl_from_IClassFactory(iface); + return InterlockedIncrement(&factory->refcount); +} + +static ULONG WINAPI class_factory_Release(IClassFactory *iface) +{ + struct class_factory *factory = impl_from_IClassFactory(iface); + ULONG refcount = InterlockedDecrement(&factory->refcount); + + if (!refcount) + heap_free(factory); + + return refcount; +} + +static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **obj) +{ + struct class_factory *factory = impl_from_IClassFactory(iface); + + TRACE("%p, %p, %s, %p.\n", iface, outer, debugstr_guid(riid), obj); + + if (outer) + { + *obj = NULL; + return CLASS_E_NOAGGREGATION; + } + + return factory->create_instance(riid, obj); +} + +static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL dolock) +{ + TRACE("%p, %d.\n", iface, dolock); + + if (dolock) + InterlockedIncrement(&object_locks); + else + InterlockedDecrement(&object_locks); + + return S_OK; +} + +static const IClassFactoryVtbl class_factory_vtbl = +{ + class_factory_QueryInterface, + class_factory_AddRef, + class_factory_Release, + class_factory_CreateInstance, + class_factory_LockServer, +}; + +static HRESULT video_processor_create(REFIID riid, void **ret) +{ + struct video_processor *object; + HRESULT hr; + + if (!(object = heap_alloc_zero(sizeof(*object)))) + return E_OUTOFMEMORY; + + object->IMFTransform_iface.lpVtbl = &video_processor_vtbl; + object->refcount = 1; + + if (FAILED(hr = MFCreateAttributes(&object->attributes, 0))) + goto failed; + + if (FAILED(hr = MFCreateAttributes(&object->output_attributes, 0))) + goto failed; + + *ret = &object->IMFTransform_iface; + return S_OK; + +failed: + + IMFTransform_Release(&object->IMFTransform_iface); + return hr; +} + +static const struct class_object +{ + const GUID *clsid; + HRESULT (*create_instance)(REFIID riid, void **obj); +} +class_objects[] = +{ + { &CLSID_VideoProcessorMFT, &video_processor_create }, +}; + +HRESULT mfplat_get_class_object(REFCLSID rclsid, REFIID riid, void **obj) +{ + struct class_factory *factory; + unsigned int i; + HRESULT hr; + + for (i = 0; i < ARRAY_SIZE(class_objects); ++i) + { + if (IsEqualGUID(class_objects[i].clsid, rclsid)) + { + if (!(factory = heap_alloc(sizeof(*factory)))) + return E_OUTOFMEMORY; + + factory->IClassFactory_iface.lpVtbl = &class_factory_vtbl; + factory->refcount = 1; + factory->create_instance = class_objects[i].create_instance; + + hr = IClassFactory_QueryInterface(&factory->IClassFactory_iface, riid, obj); + IClassFactory_Release(&factory->IClassFactory_iface); + return hr; + } + } + + return CLASS_E_CLASSNOTAVAILABLE; +} + +HRESULT mfplat_can_unload_now(void) +{ + return !object_locks ? S_OK : S_FALSE; +} diff --git a/dlls/winegstreamer/mfplat.idl b/dlls/winegstreamer/mfplat.idl new file mode 100644 index 0000000000..05a75bdb8e --- /dev/null +++ b/dlls/winegstreamer/mfplat.idl @@ -0,0 +1,26 @@ +/* + * Copyright 2019 Nikolay Sivov for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#pragma makedep register + +[ + threading(both), + uuid(88753b26-5b24-49bd-b2e7-0c445c78c982) + +] +coclass VideoProcessorMFT { } -- 2.20.1

1 0

[PATCH] server: Rename cpu_type_t to client_cpu_t.
by Jacek Caban 05 Jul '19

05 Jul '19

To avoid conflicts with mac headers. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/kernel32/process.c | 2 +- dlls/ntdll/process.c | 2 +- server/protocol.def | 14 +++++++------- server/trace.c | 14 +++++++------- 4 files changed, 16 insertions(+), 16 deletions(-)

2 1

[PATCH 4/5] kernel32: Use DebugBreakProcess in DebugActiveProcess.
by Jacek Caban 05 Jul '19

05 Jul '19

Fixes attaching to a process with VS remote debugger. It expects the first break exception address to be DbgBreakPoint. Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/kernel32/debugger.c | 6 ++++++ dlls/kernel32/tests/debugger.c | 2 -- server/debugger.c | 1 - 3 files changed, 6 insertions(+), 3 deletions(-)

2 1

[PATCH 3/5] winternl.h: Remove inline DbgBreakPoint version.
by Jacek Caban 05 Jul '19

05 Jul '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- If we really need an inline version, I'd suggest to provide a compatibility version of__debugbreak() instead. dlls/kernel32/tests/debugger.c | 1 - include/winternl.h | 9 ++------- 2 files changed, 2 insertions(+), 8 deletions(-)

2 1

[PATCH 1/4] d3d9/tests: Test sample and texture dimensions mismatch.
by Paul Gofman 05 Jul '19

05 Jul '19

Signed-off-by: Paul Gofman <gofmanp(a)gmail.com> --- dlls/d3d9/tests/visual.c | 240 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 240 insertions(+) diff --git a/dlls/d3d9/tests/visual.c b/dlls/d3d9/tests/visual.c index f51e334a68..45c6e03dd9 100644 --- a/dlls/d3d9/tests/visual.c +++ b/dlls/d3d9/tests/visual.c @@ -26249,6 +26249,245 @@ static void test_desktop_window(void) IDirect3D9_Release(d3d); } +static void test_mismatched_sample_types_fill_texture(DWORD *bits, unsigned int pitch, D3DCOLOR colour, + unsigned int size) +{ + unsigned int x, y; + + for (y = 0; y < size; ++y) + { + DWORD *ptr = (DWORD *)(((BYTE *)bits) + (y * pitch)); + + for (x = 0; x < size; ++x) + *ptr++ = colour; + } +} + +static void test_mismatched_sample_types(void) +{ + /* MSDN suggests that sampling a texture with fewer dimensions than sampler has + * is allowed while the opposite is not. + * AMD, Intel, WARP return sampled texture values in both cases. The use of W + * coordinate when sampling 3d texture with 2d sampler looks not entirely consistent. + * Nvidia returns zero texture values for both cases while that is different + * from unbound texture result (0, 0, 0, 1): it is (0, 0, 0, 0) for RGBA texture or, + * in a general case, result of a fixup of zero texture color, e. g., (0, 0, 1, 1) + * for D3DFMT_G16R16 texture. */ + + IDirect3DVertexDeclaration9 *vertex_declaration; + static IDirect3DPixelShader9 *ps_2d, *ps_3d; + static IDirect3DVolumeTexture9 *volume; + IDirect3DVertexShader9 *vertex_shader; + static IDirect3DTexture9 *tex_2d; + D3DLOCKED_RECT locked_rect; + D3DLOCKED_BOX locked_box; + IDirect3DDevice9 *device; + IDirect3D9 *d3d; + D3DCOLOR colour; + unsigned int i; + ULONG refcount; + D3DCAPS9 caps; + HWND window; + HRESULT hr; + + static const D3DVERTEXELEMENT9 decl_elements[] = + { + {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, + {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0}, + D3DDECL_END() + }; + static const struct + { + struct vec3 position; + struct vec3 t0; + } + quad[] = + { + {{-1.0f, -1.0f, 0.1f}, {0.0f, 0.0f, 0.0f}}, + {{-1.0f, 1.0f, 0.1f}, {0.0f, 1.0f, 0.5f}}, + {{ 1.0f, -1.0f, 0.1f}, {1.0f, 0.0f, 0.5f}}, + {{ 1.0f, 1.0f, 0.1f}, {1.0f, 1.0f, 1.0f}}, + }; + + static const DWORD vs_code[] = + { + 0xfffe0300, /* vs_3_0 */ + 0x0200001f, 0x80000000, 0x900f0000, /* dcl_position v0 */ + 0x0200001f, 0x80000005, 0x900f0001, /* dcl_texcoord0 v1 */ + 0x0200001f, 0x80000000, 0xe00f0000, /* dcl_position o0 */ + 0x0200001f, 0x80000005, 0xe00f0001, /* dcl_texcoord0 o1 */ + 0x02000001, 0xe00f0000, 0x90e40000, /* mov o0, v0 */ + 0x02000001, 0xe00f0001, 0x90e40001, /* mov o1, v1 */ + 0x0000ffff, /* end */ + }; + + static const DWORD ps_header[] = + { + 0xffff0300, /* ps_3_0 */ + 0x05000051, 0xa00f0000, 0x3f333333, 0x3f4ccccd, 0x3f666666, 0x00000000, + /* def c0, 0.7, 0.8, 0.9, 0.0 */ + }; + static const DWORD ps_footer[] = + { + 0x03000042, 0x800f0001, 0x90e40000, 0xa0e40800, /* texld r1, v0, s0 */ + 0x02020029, 0x80ff0001, 0xa0ff0000, /* if_eq r1.w, c0.w */ + 0x02000001, 0x800f0001, 0xa0e40000, /* mov r1, c0 */ + 0x0000002b, /* endif */ + 0x02000001, 0x800f0800, 0x80e40001, /* mov oC0, r1 */ + 0x0000ffff, /* end */ + }; + + #define TEST_MISMATCHED_SAMPLE_BODY_WORDS 6 + + static const DWORD ps_tex_2d[TEST_MISMATCHED_SAMPLE_BODY_WORDS] = + { + 0x0200001f, 0x80000005, 0x90030000, /* dcl_texcoord0 v0.xy */ + 0x0200001f, 0x90000000, 0xa00f0800, /* dcl_2d s0 */ + }; + static const DWORD ps_tex_3d[TEST_MISMATCHED_SAMPLE_BODY_WORDS] = + { + 0x0200001f, 0x80000005, 0x90070000, /* dcl_texcoord0 v0.xyz */ + 0x0200001f, 0xa0000000, 0xa00f0800, /* dcl_volume s0 */ + }; + + static DWORD ps_code[ARRAY_SIZE(ps_header) + TEST_MISMATCHED_SAMPLE_BODY_WORDS + ARRAY_SIZE(ps_footer)]; + + static const struct + { + const char *name; + IDirect3DBaseTexture9 **texture; + IDirect3DPixelShader9 **pixel_shader; + D3DCOLOR expected_colour; + D3DCOLOR expected_broken; + BOOL todo; + D3DCOLOR expected_broken2; + } + tests[] = + { + {"2d_2d", (IDirect3DBaseTexture9 **)&tex_2d, &ps_2d, 0x00707070}, + {"3d_3d", (IDirect3DBaseTexture9 **)&volume, &ps_3d, 0x00303030}, + {"2d_3d", (IDirect3DBaseTexture9 **)&tex_2d, &ps_3d, 0x00707070, 0x00b2cce5, TRUE}, + {"3d_2d", (IDirect3DBaseTexture9 **)&volume, &ps_2d, 0x00303030, 0x00b2cce5, TRUE, 0x00202020}, + }; + + window = create_window(); + ok(!!window, "Failed to create a window.\n"); + + d3d = Direct3DCreate9(D3D_SDK_VERSION); + ok(!!d3d, "Failed to create a D3D object.\n"); + if (!(device = create_device(d3d, window, window, TRUE))) + { + skip("Failed to create a D3D device, skipping tests.\n"); + IDirect3D9_Release(d3d); + DestroyWindow(window); + return; + } + + hr = IDirect3DDevice9_GetDeviceCaps(device, &caps); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + if (caps.PixelShaderVersion < D3DPS_VERSION(3, 0) || caps.VertexShaderVersion < D3DVS_VERSION(3, 0)) + { + skip("No shader model 3 support, skipping tests.\n"); + goto done; + } + if (!(caps.TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)) + { + skip("No volume texture support, skipping tests.\n"); + goto done; + } + + hr = IDirect3DDevice9_CreateVolumeTexture(device, 2, 2, 2, 1, 0, D3DFMT_A8R8G8B8, + D3DPOOL_MANAGED, &volume, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DVolumeTexture9_LockBox(volume, 0, &locked_box, NULL, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + test_mismatched_sample_types_fill_texture(locked_box.pBits, locked_box.RowPitch, 0x20202020, 2); + test_mismatched_sample_types_fill_texture((DWORD *)((BYTE *)locked_box.pBits + locked_box.SlicePitch), + locked_box.RowPitch, 0x40404040, 2); + hr = IDirect3DVolumeTexture9_UnlockBox(volume, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_CreateTexture(device, 2, 2, 1, 0, D3DFMT_A8R8G8B8, + D3DPOOL_MANAGED, &tex_2d, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DTexture9_LockRect(tex_2d, 0, &locked_rect, NULL, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + test_mismatched_sample_types_fill_texture(locked_rect.pBits, locked_rect.Pitch, 0x70707070, 2); + hr = IDirect3DTexture9_UnlockRect(tex_2d, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_SetRenderState(device, D3DRS_ZENABLE, FALSE); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_CreateVertexDeclaration(device, decl_elements, &vertex_declaration); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_SetVertexDeclaration(device, vertex_declaration); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_CreateVertexShader(device, vs_code, &vertex_shader); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_SetVertexShader(device, vertex_shader); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + memcpy(ps_code, ps_header, sizeof(ps_header)); + memcpy(ps_code + ARRAY_SIZE(ps_header) + TEST_MISMATCHED_SAMPLE_BODY_WORDS, ps_footer, sizeof(ps_footer)); + + memcpy(ps_code + ARRAY_SIZE(ps_header), ps_tex_2d, + sizeof(*ps_code) * TEST_MISMATCHED_SAMPLE_BODY_WORDS); + hr = IDirect3DDevice9_CreatePixelShader(device, ps_code, &ps_2d); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + memcpy(ps_code + ARRAY_SIZE(ps_header), ps_tex_3d, + sizeof(*ps_code) * TEST_MISMATCHED_SAMPLE_BODY_WORDS); + hr = IDirect3DDevice9_CreatePixelShader(device, ps_code, &ps_3d); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_SetSamplerState(device, 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + for (i = 0; i < ARRAY_SIZE(tests); ++i) + { + hr = IDirect3DDevice9_BeginScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_Clear(device, 0, NULL, D3DCLEAR_TARGET, 0x80808080, 0.0f, 0); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_SetTexture(device, 0, *tests[i].texture); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_SetPixelShader(device, *tests[i].pixel_shader); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + hr = IDirect3DDevice9_DrawPrimitiveUP(device, D3DPT_TRIANGLESTRIP, 2, quad, sizeof(*quad)); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + hr = IDirect3DDevice9_EndScene(device); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + colour = getPixelColor(device, 320, 240); + + todo_wine_if(tests[i].todo) ok(color_match(colour, tests[i].expected_colour, 1) + || broken(tests[i].expected_broken && color_match(colour, tests[i].expected_broken, 1)) + || broken(tests[i].expected_broken2 && color_match(colour, tests[i].expected_broken2, 1)), + "test %s, expected 0x%08x, got 0x%08x.\n", + tests[i].name, tests[i].expected_colour, colour); + } + hr = IDirect3DDevice9_Present(device, NULL, NULL, NULL, NULL); + ok(hr == D3D_OK, "Got unexpected hr %#x.\n", hr); + + IDirect3DPixelShader9_Release(ps_2d); + IDirect3DPixelShader9_Release(ps_3d); + + IDirect3DVertexShader9_Release(vertex_shader); + IDirect3DVertexDeclaration9_Release(vertex_declaration); + IDirect3DVolumeTexture9_Release(volume); + IDirect3DTexture9_Release(tex_2d); + +done: + refcount = IDirect3DDevice9_Release(device); + ok(!refcount, "Device has %u references left.\n", refcount); + IDirect3D9_Release(d3d); + DestroyWindow(window); +} + START_TEST(visual) { D3DADAPTER_IDENTIFIER9 identifier; @@ -26393,4 +26632,5 @@ START_TEST(visual) test_sysmem_draw(); test_nrm_instruction(); test_desktop_window(); + test_mismatched_sample_types(); } -- 2.21.0

3 8

[PATCH vkd3d 2/5] tests: Add test for Map() on reserved resources.
by Józef Kucia 05 Jul '19

05 Jul '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index b8eb4ab64b1f..bd055fb5d444 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -2186,6 +2186,7 @@ static void test_create_reserved_resource(void) ID3D12Device *device; ULONG refcount; HRESULT hr; + void *ptr; if (!(device = create_device())) { @@ -2232,6 +2233,10 @@ static void test_create_reserved_resource(void) ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); ok(heap_flags == 0xdeadbeef, "Got unexpected heap flags %#x.\n", heap_flags); + /* Map() is not allowed on reserved resources */ + hr = ID3D12Resource_Map(resource, 0, NULL, &ptr); + ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr); + refcount = ID3D12Resource_Release(resource); ok(!refcount, "ID3D12Resource has %u references left.\n", (unsigned int)refcount); -- 2.21.0

2 1

[PATCH vkd3d 5/5] vkd3d: Add support for VK_EXT_texel_buffer_alignment.
by Józef Kucia 05 Jul '19

05 Jul '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- README | 2 +- configure.ac | 2 +- libs/vkd3d/device.c | 42 ++++++++++++++++++++++++++++++++++---- libs/vkd3d/resource.c | 37 +++++++++++++++++++++++++++------ libs/vkd3d/vkd3d_private.h | 3 +++ 5 files changed, 74 insertions(+), 12 deletions(-) diff --git a/README b/README index 2e42249e28df..2f2f3952c197 100644 --- a/README +++ b/README @@ -9,7 +9,7 @@ similar, but not identical, to Direct3D 12. Building vkd3d ============== -Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.1.101). +Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.1.113). Vkd3d generates some of its headers from IDL files. If you are using the release tarballs, then these headers are pre-generated and are included. If diff --git a/configure.ac b/configure.ac index 02f9028ee6a7..e2d61316ce6d 100644 --- a/configure.ac +++ b/configure.ac @@ -67,7 +67,7 @@ AS_IF([test "x$ac_cv_header_spirv_unified1_GLSL_std_450_h" != "xyes" \ -a "x$ac_cv_header_vulkan_GLSL_std_450_h" != "xyes"], [AC_MSG_ERROR([GLSL.std.450.h not found.])]) -VKD3D_CHECK_VULKAN_HEADER_VERSION([101], [AC_MSG_ERROR([Vulkan headers are too old, 1.1.101 is required.])]) +VKD3D_CHECK_VULKAN_HEADER_VERSION([113], [AC_MSG_ERROR([Vulkan headers are too old, 1.1.113 is required.])]) dnl Check for libraries m4_ifdef([PKG_PROG_PKG_CONFIG], [PKG_PROG_PKG_CONFIG], [m4_fatal([pkg-config autoconf macros not found.])]) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 2fd13f6c138c..b9ac829734f4 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -133,6 +133,7 @@ static const struct vkd3d_optional_extension_info optional_device_extensions[] = {VK_EXT_DEBUG_MARKER_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_debug_marker)}, {VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_depth_clip_enable)}, {VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_descriptor_indexing)}, + {VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_texel_buffer_alignment)}, {VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_transform_feedback)}, {VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, @@ -662,6 +663,7 @@ struct vkd3d_physical_device_info /* properties */ VkPhysicalDeviceDescriptorIndexingPropertiesEXT descriptor_indexing_properties; VkPhysicalDeviceMaintenance3Properties maintenance3_properties; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT texel_buffer_alignment_properties; VkPhysicalDeviceTransformFeedbackPropertiesEXT xfb_properties; VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT vertex_divisor_properties; @@ -671,6 +673,7 @@ struct vkd3d_physical_device_info VkPhysicalDeviceConditionalRenderingFeaturesEXT conditional_rendering_features; VkPhysicalDeviceDepthClipEnableFeaturesEXT depth_clip_features; VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT texel_buffer_alignment_features; VkPhysicalDeviceTransformFeedbackFeaturesEXT xfb_features; VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor_features; @@ -683,8 +686,10 @@ static void vkd3d_physical_device_info_init(struct vkd3d_physical_device_info *i VkPhysicalDeviceConditionalRenderingFeaturesEXT *conditional_rendering_features; VkPhysicalDeviceDescriptorIndexingPropertiesEXT *descriptor_indexing_properties; VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *vertex_divisor_properties; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *buffer_alignment_properties; VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing_features; VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *vertex_divisor_features; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *buffer_alignment_features; VkPhysicalDeviceDepthClipEnableFeaturesEXT *depth_clip_features; VkPhysicalDeviceMaintenance3Properties *maintenance3_properties; VkPhysicalDeviceTransformFeedbackPropertiesEXT *xfb_properties; @@ -698,6 +703,8 @@ static void vkd3d_physical_device_info_init(struct vkd3d_physical_device_info *i descriptor_indexing_features = &info->descriptor_indexing_features; descriptor_indexing_properties = &info->descriptor_indexing_properties; maintenance3_properties = &info->maintenance3_properties; + buffer_alignment_features = &info->texel_buffer_alignment_features; + buffer_alignment_properties = &info->texel_buffer_alignment_properties; vertex_divisor_features = &info->vertex_divisor_features; vertex_divisor_properties = &info->vertex_divisor_properties; xfb_features = &info->xfb_features; @@ -708,8 +715,10 @@ static void vkd3d_physical_device_info_init(struct vkd3d_physical_device_info *i depth_clip_features->pNext = conditional_rendering_features; descriptor_indexing_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT; descriptor_indexing_features->pNext = depth_clip_features; + buffer_alignment_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + buffer_alignment_features->pNext = descriptor_indexing_features; xfb_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; - xfb_features->pNext = descriptor_indexing_features; + xfb_features->pNext = buffer_alignment_features; vertex_divisor_features->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; vertex_divisor_features->pNext = xfb_features; @@ -724,8 +733,10 @@ static void vkd3d_physical_device_info_init(struct vkd3d_physical_device_info *i maintenance3_properties->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; descriptor_indexing_properties->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT; descriptor_indexing_properties->pNext = maintenance3_properties; + buffer_alignment_properties->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT; + buffer_alignment_properties->pNext = descriptor_indexing_properties; xfb_properties->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; - xfb_properties->pNext = descriptor_indexing_properties; + xfb_properties->pNext = buffer_alignment_properties; vertex_divisor_properties->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; vertex_divisor_properties->pNext = xfb_properties; @@ -800,6 +811,7 @@ static void vkd3d_trace_physical_device_limits(const struct vkd3d_physical_devic const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *divisor_properties; const VkPhysicalDeviceLimits *limits = &info->properties2.properties.limits; const VkPhysicalDeviceDescriptorIndexingPropertiesEXT *descriptor_indexing; + const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *buffer_alignment; const VkPhysicalDeviceMaintenance3Properties *maintenance3; const VkPhysicalDeviceTransformFeedbackPropertiesEXT *xfb; @@ -979,6 +991,17 @@ static void vkd3d_trace_physical_device_limits(const struct vkd3d_physical_devic TRACE(" maxPerSetDescriptors: %u.\n", maintenance3->maxPerSetDescriptors); TRACE(" maxMemoryAllocationSize: %#"PRIx64".\n", maintenance3->maxMemoryAllocationSize); + buffer_alignment = &info->texel_buffer_alignment_properties; + TRACE(" VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT:\n"); + TRACE(" storageTexelBufferOffsetAlignmentBytes: %#"PRIx64".\n", + buffer_alignment->storageTexelBufferOffsetAlignmentBytes); + TRACE(" storageTexelBufferOffsetSingleTexelAlignment: %#x.\n", + buffer_alignment->storageTexelBufferOffsetSingleTexelAlignment); + TRACE(" uniformTexelBufferOffsetAlignmentBytes: %#"PRIx64".\n", + buffer_alignment->uniformTexelBufferOffsetAlignmentBytes); + TRACE(" uniformTexelBufferOffsetSingleTexelAlignment: %#x.\n", + buffer_alignment->uniformTexelBufferOffsetSingleTexelAlignment); + xfb = &info->xfb_properties; TRACE(" VkPhysicalDeviceTransformFeedbackPropertiesEXT:\n"); TRACE(" maxTransformFeedbackStreams: %u.\n", xfb->maxTransformFeedbackStreams); @@ -1000,6 +1023,7 @@ static void vkd3d_trace_physical_device_limits(const struct vkd3d_physical_devic static void vkd3d_trace_physical_device_features(const struct vkd3d_physical_device_info *info) { const VkPhysicalDeviceConditionalRenderingFeaturesEXT *conditional_rendering_features; + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *buffer_alignment_features; const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing; const VkPhysicalDeviceDepthClipEnableFeaturesEXT *depth_clip_features; @@ -1118,6 +1142,10 @@ static void vkd3d_trace_physical_device_features(const struct vkd3d_physical_dev TRACE(" VkPhysicalDeviceDepthClipEnableFeaturesEXT:\n"); TRACE(" depthClipEnable: %#x.\n", depth_clip_features->depthClipEnable); + buffer_alignment_features = &info->texel_buffer_alignment_features; + TRACE(" VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT:\n"); + TRACE(" texelBufferAlignment: %#x.\n", buffer_alignment_features->texelBufferAlignment); + xfb = &info->xfb_features; TRACE(" VkPhysicalDeviceTransformFeedbackFeaturesEXT:\n"); TRACE(" transformFeedback: %#x.\n", xfb->transformFeedback); @@ -1342,8 +1370,14 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, *user_extension_supported, vulkan_info, "device", device->vkd3d_instance->config_flags & VKD3D_CONFIG_FLAG_VULKAN_DEBUG); - vulkan_info->EXT_conditional_rendering = physical_device_info->conditional_rendering_features.conditionalRendering; - vulkan_info->EXT_depth_clip_enable = physical_device_info->depth_clip_features.depthClipEnable; + if (!physical_device_info->conditional_rendering_features.conditionalRendering) + vulkan_info->EXT_conditional_rendering = false; + if (!physical_device_info->depth_clip_features.depthClipEnable) + vulkan_info->EXT_depth_clip_enable = false; + if (!physical_device_info->texel_buffer_alignment_features.texelBufferAlignment) + vulkan_info->EXT_texel_buffer_alignment = false; + + vulkan_info->texel_buffer_alignment_properties = physical_device_info->texel_buffer_alignment_properties; if (get_spec_version(vk_extensions, count, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) >= 3) { diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 9d563303a88f..e0e1aadf62ba 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1772,13 +1772,40 @@ void d3d12_desc_copy(struct d3d12_desc *dst, const struct d3d12_desc *src, } } +static VkDeviceSize vkd3d_get_required_texel_buffer_alignment(const struct d3d12_device *device, + const struct vkd3d_format *format) +{ + const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *properties; + const struct vkd3d_vulkan_info *vk_info = &device->vk_info; + VkDeviceSize alignment; + + if (vk_info->EXT_texel_buffer_alignment) + { + properties = &vk_info->texel_buffer_alignment_properties; + + alignment = max(properties->storageTexelBufferOffsetAlignmentBytes, + properties->uniformTexelBufferOffsetAlignmentBytes); + + if (properties->storageTexelBufferOffsetSingleTexelAlignment + && properties->uniformTexelBufferOffsetSingleTexelAlignment) + { + assert(!vkd3d_format_is_compressed(format)); + return min(format->byte_count, alignment); + } + + return alignment; + } + + return vk_info->device_limits.minTexelBufferOffsetAlignment; +} + static bool vkd3d_create_vk_buffer_view(struct d3d12_device *device, VkBuffer vk_buffer, const struct vkd3d_format *format, VkDeviceSize offset, VkDeviceSize range, VkBufferView *vk_view) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - const struct vkd3d_vulkan_info *vk_info = &device->vk_info; struct VkBufferViewCreateInfo view_desc; + VkDeviceSize alignment; VkResult vr; if (vkd3d_format_is_compressed(format)) @@ -1787,11 +1814,9 @@ static bool vkd3d_create_vk_buffer_view(struct d3d12_device *device, return false; } - if (offset % vk_info->device_limits.minTexelBufferOffsetAlignment) - { - FIXME("Offset %#"PRIx64" violates the minimum required alignment %#"PRIx64".\n", - offset, vk_info->device_limits.minTexelBufferOffsetAlignment); - } + alignment = vkd3d_get_required_texel_buffer_alignment(device, format); + if (offset % alignment) + FIXME("Offset %#"PRIx64" violates the required alignment %#"PRIx64".\n", offset, alignment); view_desc.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; view_desc.pNext = NULL; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 0ea501c9c35a..6e2dc2b2bb8e 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -102,6 +102,7 @@ struct vkd3d_vulkan_info bool EXT_debug_marker; bool EXT_depth_clip_enable; bool EXT_descriptor_indexing; + bool EXT_texel_buffer_alignment; bool EXT_transform_feedback; bool EXT_vertex_attribute_divisor; @@ -114,6 +115,8 @@ struct vkd3d_vulkan_info VkPhysicalDeviceLimits device_limits; VkPhysicalDeviceSparseProperties sparse_properties; + VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT texel_buffer_alignment_properties; + D3D_FEATURE_LEVEL max_feature_level; }; -- 2.21.0

3 2