wine-devel May 2019

wine-devel@winehq.org

96 participants
789 discussions

[PATCH] wmvcore: Return success from OpenStream().
by Nikolay Sivov 03 May '19

03 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/wmvcore/reader.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/wmvcore/reader.c b/dlls/wmvcore/reader.c index d35f29d66e..6041c567e9 100644 --- a/dlls/wmvcore/reader.c +++ b/dlls/wmvcore/reader.c @@ -2222,7 +2222,7 @@ static HRESULT WINAPI WMSyncReader_OpenStream(IWMSyncReader *iface, IStream *str { WMSyncReader *This = impl_from_IWMSyncReader(iface); FIXME("(%p)->(%p): stub!\n", This, stream); - return E_NOTIMPL; + return S_OK; } static HRESULT WINAPI WMSyncReader_SetOutputProps(IWMSyncReader *iface, DWORD output_num, IWMOutputMediaProps *output) -- 2.20.1

1 0

[PATCH] mf: Implement file scheme handler.
by Nikolay Sivov 03 May '19

03 May '19

Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> --- dlls/mf/Makefile.in | 2 +- dlls/mf/main.c | 381 ++++++++++++++++++++++++++++++++++++- dlls/mfplat/tests/mfplat.c | 27 +-- 3 files changed, 385 insertions(+), 25 deletions(-) diff --git a/dlls/mf/Makefile.in b/dlls/mf/Makefile.in index 3499a4a61a..221ef42ec9 100644 --- a/dlls/mf/Makefile.in +++ b/dlls/mf/Makefile.in @@ -1,6 +1,6 @@ MODULE = mf.dll IMPORTLIB = mf -IMPORTS = mfplat +IMPORTS = mfplat mfuuid C_SRCS = \ main.c \ diff --git a/dlls/mf/main.c b/dlls/mf/main.c index 8500cd9cef..77081e2a57 100644 --- a/dlls/mf/main.c +++ b/dlls/mf/main.c @@ -30,8 +30,15 @@ #include "initguid.h" #include "mf.h" +#undef INITGUID +#include <guiddef.h> +#include "mfapi.h" +#include "mferror.h" + #include "wine/debug.h" #include "wine/heap.h" +#include "wine/unicode.h" +#include "wine/list.h" WINE_DEFAULT_DEBUG_CHANNEL(mfplat); @@ -106,10 +113,22 @@ static const IClassFactoryVtbl class_factory_vtbl = class_factory_LockServer, }; +struct file_scheme_handler_result +{ + struct list entry; + IMFAsyncResult *result; + MF_OBJECT_TYPE obj_type; + IUnknown *object; +}; + struct file_scheme_handler { IMFSchemeHandler IMFSchemeHandler_iface; + IMFAsyncCallback IMFAsyncCallback_iface; LONG refcount; + IMFSourceResolver *resolver; + struct list results; + CRITICAL_SECTION cs; }; static struct file_scheme_handler *impl_from_IMFSchemeHandler(IMFSchemeHandler *iface) @@ -117,6 +136,11 @@ static struct file_scheme_handler *impl_from_IMFSchemeHandler(IMFSchemeHandler * return CONTAINING_RECORD(iface, struct file_scheme_handler, IMFSchemeHandler_iface); } +static struct file_scheme_handler *impl_from_IMFAsyncCallback(IMFAsyncCallback *iface) +{ + return CONTAINING_RECORD(iface, struct file_scheme_handler, IMFAsyncCallback_iface); +} + static HRESULT WINAPI file_scheme_handler_QueryInterface(IMFSchemeHandler *iface, REFIID riid, void **obj) { TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); @@ -148,36 +172,237 @@ static ULONG WINAPI file_scheme_handler_Release(IMFSchemeHandler *iface) { struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface); ULONG refcount = InterlockedDecrement(&handler->refcount); + struct file_scheme_handler_result *result, *next; TRACE("%p, refcount %u.\n", iface, refcount); if (!refcount) + { + LIST_FOR_EACH_ENTRY_SAFE(result, next, &handler->results, struct file_scheme_handler_result, entry) + { + list_remove(&result->entry); + IMFAsyncResult_Release(result->result); + if (result->object) + IUnknown_Release(result->object); + heap_free(result); + } + DeleteCriticalSection(&handler->cs); + if (handler->resolver) + IMFSourceResolver_Release(handler->resolver); heap_free(handler); + } + + return refcount; +} + +struct create_object_context +{ + IUnknown IUnknown_iface; + LONG refcount; + + IPropertyStore *props; + WCHAR *url; + DWORD flags; +}; + +static struct create_object_context *impl_from_IUnknown(IUnknown *iface) +{ + return CONTAINING_RECORD(iface, struct create_object_context, IUnknown_iface); +} + +static HRESULT WINAPI create_object_context_QueryInterface(IUnknown *iface, REFIID riid, void **obj) +{ + TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj); + + if (IsEqualIID(riid, &IID_IUnknown)) + { + *obj = iface; + IUnknown_AddRef(iface); + return S_OK; + } + + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI create_object_context_AddRef(IUnknown *iface) +{ + struct create_object_context *context = impl_from_IUnknown(iface); + ULONG refcount = InterlockedIncrement(&context->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + return refcount; +} + +static ULONG WINAPI create_object_context_Release(IUnknown *iface) +{ + struct create_object_context *context = impl_from_IUnknown(iface); + ULONG refcount = InterlockedDecrement(&context->refcount); + + TRACE("%p, refcount %u.\n", iface, refcount); + + if (!refcount) + { + if (context->props) + IPropertyStore_Release(context->props); + heap_free(context->url); + heap_free(context); + } return refcount; } +static const IUnknownVtbl create_object_context_vtbl = +{ + create_object_context_QueryInterface, + create_object_context_AddRef, + create_object_context_Release, +}; + +static WCHAR *heap_strdupW(const WCHAR *str) +{ + WCHAR *ret = NULL; + + if (str) + { + unsigned int size; + + size = (strlenW(str) + 1) * sizeof(WCHAR); + ret = heap_alloc(size); + if (ret) + memcpy(ret, str, size); + } + + return ret; +} + static HRESULT WINAPI file_scheme_handler_BeginCreateObject(IMFSchemeHandler *iface, const WCHAR *url, DWORD flags, IPropertyStore *props, IUnknown **cancel_cookie, IMFAsyncCallback *callback, IUnknown *state) { - FIXME("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state); + struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface); + struct create_object_context *context; + IMFAsyncResult *caller, *item; + HRESULT hr; - return E_NOTIMPL; + TRACE("%p, %s, %#x, %p, %p, %p, %p.\n", iface, debugstr_w(url), flags, props, cancel_cookie, callback, state); + + if (cancel_cookie) + *cancel_cookie = NULL; + + if (FAILED(hr = MFCreateAsyncResult(NULL, callback, state, &caller))) + return hr; + + context = heap_alloc(sizeof(*context)); + if (!context) + { + IMFAsyncResult_Release(caller); + return E_OUTOFMEMORY; + } + + context->IUnknown_iface.lpVtbl = &create_object_context_vtbl; + context->refcount = 1; + context->props = props; + if (context->props) + IPropertyStore_AddRef(context->props); + context->flags = flags; + context->url = heap_strdupW(url); + if (!context->url) + { + IMFAsyncResult_Release(caller); + IUnknown_Release(&context->IUnknown_iface); + return E_OUTOFMEMORY; + } + + hr = MFCreateAsyncResult(&context->IUnknown_iface, &handler->IMFAsyncCallback_iface, (IUnknown *)caller, &item); + IUnknown_Release(&context->IUnknown_iface); + IMFAsyncResult_Release(caller); + if (SUCCEEDED(hr)) + { + if (SUCCEEDED(hr = MFPutWorkItemEx(MFASYNC_CALLBACK_QUEUE_IO, item))) + { + if (cancel_cookie) + IMFAsyncResult_GetState(item, cancel_cookie); + } + + IMFAsyncResult_Release(item); + } + + return hr; } static HRESULT WINAPI file_scheme_handler_EndCreateObject(IMFSchemeHandler *iface, IMFAsyncResult *result, MF_OBJECT_TYPE *obj_type, IUnknown **object) { - FIXME("%p, %p, %p, %p.\n", iface, result, obj_type, object); + struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface); + struct file_scheme_handler_result *found = NULL, *cur; + HRESULT hr; - return E_NOTIMPL; + TRACE("%p, %p, %p, %p.\n", iface, result, obj_type, object); + + EnterCriticalSection(&handler->cs); + + LIST_FOR_EACH_ENTRY(cur, &handler->results, struct file_scheme_handler_result, entry) + { + if (result == cur->result) + { + list_remove(&cur->entry); + found = cur; + break; + } + } + + LeaveCriticalSection(&handler->cs); + + if (found) + { + *obj_type = found->obj_type; + *object = found->object; + hr = IMFAsyncResult_GetStatus(found->result); + IMFAsyncResult_Release(found->result); + heap_free(found); + } + else + { + *obj_type = MF_OBJECT_INVALID; + *object = NULL; + hr = MF_E_UNEXPECTED; + } + + return hr; } static HRESULT WINAPI file_scheme_handler_CancelObjectCreation(IMFSchemeHandler *iface, IUnknown *cancel_cookie) { - FIXME("%p, %p.\n", iface, cancel_cookie); + struct file_scheme_handler *handler = impl_from_IMFSchemeHandler(iface); + struct file_scheme_handler_result *found = NULL, *cur; - return E_NOTIMPL; + TRACE("%p, %p.\n", iface, cancel_cookie); + + EnterCriticalSection(&handler->cs); + + LIST_FOR_EACH_ENTRY(cur, &handler->results, struct file_scheme_handler_result, entry) + { + if (cancel_cookie == (IUnknown *)cur->result) + { + list_remove(&cur->entry); + found = cur; + break; + } + } + + LeaveCriticalSection(&handler->cs); + + if (found) + { + IMFAsyncResult_Release(found->result); + if (found->object) + IUnknown_Release(found->object); + heap_free(found); + } + + return found ? S_OK : MF_E_UNEXPECTED; } static const IMFSchemeHandlerVtbl file_scheme_handler_vtbl = @@ -190,6 +415,145 @@ static const IMFSchemeHandlerVtbl file_scheme_handler_vtbl = file_scheme_handler_CancelObjectCreation, }; +static HRESULT WINAPI file_scheme_handler_callback_QueryInterface(IMFAsyncCallback *iface, REFIID riid, void **obj) +{ + if (IsEqualIID(riid, &IID_IMFAsyncCallback) || + IsEqualIID(riid, &IID_IUnknown)) + { + *obj = iface; + IMFAsyncCallback_AddRef(iface); + return S_OK; + } + + WARN("Unsupported %s.\n", debugstr_guid(riid)); + *obj = NULL; + return E_NOINTERFACE; +} + +static ULONG WINAPI file_scheme_handler_callback_AddRef(IMFAsyncCallback *iface) +{ + struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface); + return IMFSchemeHandler_AddRef(&handler->IMFSchemeHandler_iface); +} + +static ULONG WINAPI file_scheme_handler_callback_Release(IMFAsyncCallback *iface) +{ + struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface); + return IMFSchemeHandler_Release(&handler->IMFSchemeHandler_iface); +} + +static HRESULT WINAPI file_scheme_handler_callback_GetParameters(IMFAsyncCallback *iface, DWORD *flags, DWORD *queue) +{ + return E_NOTIMPL; +} + +static HRESULT file_scheme_handler_get_resolver(struct file_scheme_handler *handler, IMFSourceResolver **resolver) +{ + HRESULT hr; + + if (!handler->resolver) + { + IMFSourceResolver *resolver; + + if (FAILED(hr = MFCreateSourceResolver(&resolver))) + return hr; + + if (InterlockedCompareExchangePointer((void **)&handler->resolver, resolver, NULL)) + IMFSourceResolver_Release(resolver); + } + + *resolver = handler->resolver; + IMFSourceResolver_AddRef(*resolver); + + return S_OK; +} + +static HRESULT WINAPI file_scheme_handler_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result) +{ + static const WCHAR schemeW[] = {'f','i','l','e',':','/','/'}; + struct file_scheme_handler *handler = impl_from_IMFAsyncCallback(iface); + struct file_scheme_handler_result *handler_result; + MF_OBJECT_TYPE obj_type = MF_OBJECT_INVALID; + IUnknown *object = NULL, *context_object; + struct create_object_context *context; + IMFSourceResolver *resolver; + IMFAsyncResult *caller; + IMFByteStream *stream; + const WCHAR *url; + HRESULT hr; + + caller = (IMFAsyncResult *)IMFAsyncResult_GetStateNoAddRef(result); + + if (FAILED(hr = IMFAsyncResult_GetObject(result, &context_object))) + { + WARN("Expected context set for callee result.\n"); + return hr; + } + + context = impl_from_IUnknown(context_object); + + /* Strip from scheme, MFCreateFile() won't be expecting it. */ + url = context->url; + if (!strncmpiW(context->url, schemeW, ARRAY_SIZE(schemeW))) + url += ARRAY_SIZE(schemeW); + + hr = MFCreateFile(context->flags & MF_RESOLUTION_WRITE ? MF_ACCESSMODE_READWRITE : MF_ACCESSMODE_READ, + MF_OPENMODE_FAIL_IF_NOT_EXIST, MF_FILEFLAGS_NONE, url, &stream); + if (SUCCEEDED(hr)) + { + if (context->flags & MF_RESOLUTION_MEDIASOURCE) + { + if (SUCCEEDED(hr = file_scheme_handler_get_resolver(handler, &resolver))) + { + hr = IMFSourceResolver_CreateObjectFromByteStream(resolver, stream, context->url, context->flags, + context->props, &obj_type, &object); + IMFSourceResolver_Release(resolver); + IMFByteStream_Release(stream); + } + } + else + { + object = (IUnknown *)stream; + obj_type = MF_OBJECT_BYTESTREAM; + } + } + + handler_result = heap_alloc(sizeof(*handler_result)); + if (handler_result) + { + handler_result->result = caller; + IMFAsyncResult_AddRef(handler_result->result); + handler_result->obj_type = obj_type; + handler_result->object = object; + + EnterCriticalSection(&handler->cs); + list_add_tail(&handler->results, &handler_result->entry); + LeaveCriticalSection(&handler->cs); + } + else + { + if (object) + IUnknown_Release(object); + hr = E_OUTOFMEMORY; + } + + IUnknown_Release(&context->IUnknown_iface); + + IMFAsyncResult_SetStatus(caller, hr); + MFInvokeCallback(caller); + + return S_OK; +} + +static const IMFAsyncCallbackVtbl file_scheme_handler_callback_vtbl = +{ + file_scheme_handler_callback_QueryInterface, + file_scheme_handler_callback_AddRef, + file_scheme_handler_callback_Release, + file_scheme_handler_callback_GetParameters, + file_scheme_handler_callback_Invoke, +}; + static HRESULT file_scheme_handler_construct(REFIID riid, void **obj) { struct file_scheme_handler *handler; @@ -197,12 +561,15 @@ static HRESULT file_scheme_handler_construct(REFIID riid, void **obj) TRACE("%s, %p.\n", debugstr_guid(riid), obj); - handler = heap_alloc(sizeof(*handler)); + handler = heap_alloc_zero(sizeof(*handler)); if (!handler) return E_OUTOFMEMORY; handler->IMFSchemeHandler_iface.lpVtbl = &file_scheme_handler_vtbl; + handler->IMFAsyncCallback_iface.lpVtbl = &file_scheme_handler_callback_vtbl; handler->refcount = 1; + list_init(&handler->results); + InitializeCriticalSection(&handler->cs); hr = IMFSchemeHandler_QueryInterface(&handler->IMFSchemeHandler_iface, riid, obj); IMFSchemeHandler_Release(&handler->IMFSchemeHandler_iface); diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index 0a378b55b4..6eab13e917 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -265,14 +265,18 @@ static HRESULT WINAPI test_create_from_url_callback_Invoke(IMFAsyncCallback *ifa resolver = (IMFSourceResolver *)IMFAsyncResult_GetStateNoAddRef(result); + object = NULL; hr = IMFSourceResolver_EndCreateObjectFromURL(resolver, result, &obj_type, &object); +todo_wine ok(hr == S_OK, "Failed to create an object, hr %#x.\n", hr); hr = IMFAsyncResult_GetObject(result, &object2); ok(hr == S_OK, "Failed to get result object, hr %#x.\n", hr); +todo_wine ok(object2 == object, "Unexpected object.\n"); - IUnknown_Release(object); + if (object) + IUnknown_Release(object); IUnknown_Release(object2); SetEvent(callback->event); @@ -437,19 +441,14 @@ todo_wine hr = IMFSourceResolver_CreateObjectFromURL(resolver, filename, MF_RESOLUTION_BYTESTREAM, NULL, &obj_type, (IUnknown **)&stream); -todo_wine ok(hr == S_OK, "Failed to resolve url, hr %#x.\n", hr); - if (SUCCEEDED(hr)) - IMFByteStream_Release(stream); + IMFByteStream_Release(stream); hr = IMFSourceResolver_BeginCreateObjectFromURL(resolver, filename, MF_RESOLUTION_BYTESTREAM, NULL, &cancel_cookie, &callback.IMFAsyncCallback_iface, (IUnknown *)resolver); -todo_wine { ok(hr == S_OK, "Create request failed, hr %#x.\n", hr); ok(cancel_cookie != NULL, "Unexpected cancel object.\n"); -} - if (cancel_cookie) - IUnknown_Release(cancel_cookie); + IUnknown_Release(cancel_cookie); if (SUCCEEDED(hr)) WaitForSingleObject(callback.event, INFINITE); @@ -460,10 +459,8 @@ todo_wine { hr = IMFSourceResolver_CreateObjectFromURL(resolver, pathW, MF_RESOLUTION_BYTESTREAM, NULL, &obj_type, (IUnknown **)&stream); -todo_wine ok(hr == S_OK, "Failed to resolve url, hr %#x.\n", hr); - if (SUCCEEDED(hr)) - IMFByteStream_Release(stream); + IMFByteStream_Release(stream); IMFSourceResolver_Release(resolver); @@ -480,15 +477,11 @@ todo_wine cancel_cookie = NULL; hr = IMFSchemeHandler_BeginCreateObject(scheme_handler, pathW, MF_RESOLUTION_MEDIASOURCE, NULL, &cancel_cookie, &callback2.IMFAsyncCallback_iface, (IUnknown *)scheme_handler); -todo_wine { ok(hr == S_OK, "Create request failed, hr %#x.\n", hr); ok(!!cancel_cookie, "Unexpected cancel object.\n"); -} - if (cancel_cookie) - IUnknown_Release(cancel_cookie); + IUnknown_Release(cancel_cookie); - if (SUCCEEDED(hr)) - WaitForSingleObject(callback2.event, INFINITE); + WaitForSingleObject(callback2.event, INFINITE); IMFSchemeHandler_Release(scheme_handler); -- 2.20.1

1 0

[PATCH vkd3d 8/8] tests: Add simple test for graphics and compute queue synchronization.
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 225 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 225 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index cb05b5e0d65d..bc3695de41c0 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -28611,6 +28611,230 @@ skip_tests: destroy_test_context(&context); } +static void test_graphics_compute_queue_synchronization(void) +{ + ID3D12GraphicsCommandList *graphics_lists[2], *compute_lists[2]; + D3D12_ROOT_SIGNATURE_DESC root_signature_desc; + ID3D12PipelineState *compute_pipeline_state; + D3D12_UNORDERED_ACCESS_VIEW_DESC uav_desc; + ID3D12CommandQueue *queue, *compute_queue; + ID3D12DescriptorHeap *cpu_heap, *gpu_heap; + ID3D12GraphicsCommandList *command_list; + D3D12_ROOT_PARAMETER root_parameters[2]; + ID3D12CommandAllocator *allocators[3]; + struct test_context_desc desc; + struct resource_readback rb; + struct test_context context; + ID3D12Fence *fence, *fence2; + ID3D12Resource *buffer; + ID3D12Device *device; + uint32_t value; + unsigned int i; + HRESULT hr; + + unsigned int clear_value[4] = {0}; + static const DWORD cs_code[] = + { +#if 0 + uint expected_value; + RWByteAddressBuffer u : register(u1); + + [numthreads(64, 1, 1)] + void main(void) + { + u.InterlockedCompareStore(0, expected_value, expected_value + 10); + } +#endif + 0x43425844, 0x7909aab0, 0xf8576455, 0x58f9dd61, 0x3e7e64f0, 0x00000001, 0x000000e0, 0x00000003, + 0x0000002c, 0x0000003c, 0x0000004c, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x00000008, 0x00000000, 0x00000008, 0x58454853, 0x0000008c, 0x00050050, 0x00000023, 0x0100086a, + 0x04000059, 0x00208e46, 0x00000000, 0x00000001, 0x0300009d, 0x0011e000, 0x00000001, 0x02000068, + 0x00000001, 0x0400009b, 0x00000040, 0x00000001, 0x00000001, 0x0800001e, 0x00100012, 0x00000000, + 0x0020800a, 0x00000000, 0x00000000, 0x00004001, 0x0000000a, 0x0a0000ac, 0x0011e000, 0x00000001, + 0x00004001, 0x00000000, 0x0020800a, 0x00000000, 0x00000000, 0x0010000a, 0x00000000, 0x0100003e, + }; + static const DWORD ps_code[] = + { +#if 0 + uint expected_value; + RWByteAddressBuffer u; + + float4 main(void) : SV_Target + { + u.InterlockedCompareStore(0, expected_value, expected_value + 2); + return float4(0, 1, 0, 1); + } +#endif + 0x43425844, 0x82fbce04, 0xa014204c, 0xc4d46d91, 0x1081c7a7, 0x00000001, 0x00000120, 0x00000003, + 0x0000002c, 0x0000003c, 0x00000070, 0x4e475349, 0x00000008, 0x00000000, 0x00000008, 0x4e47534f, + 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, 0x00000000, + 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x58454853, 0x000000a8, 0x00000050, 0x0000002a, + 0x0100086a, 0x04000059, 0x00208e46, 0x00000000, 0x00000001, 0x0300009d, 0x0011e000, 0x00000001, + 0x03000065, 0x001020f2, 0x00000000, 0x02000068, 0x00000001, 0x0800001e, 0x00100012, 0x00000000, + 0x0020800a, 0x00000000, 0x00000000, 0x00004001, 0x00000002, 0x0a0000ac, 0x0011e000, 0x00000001, + 0x00004001, 0x00000000, 0x0020800a, 0x00000000, 0x00000000, 0x0010000a, 0x00000000, 0x08000036, + 0x001020f2, 0x00000000, 0x00004002, 0x00000000, 0x3f800000, 0x00000000, 0x3f800000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps = {ps_code, sizeof(ps_code)}; + + memset(&desc, 0, sizeof(desc)); + desc.no_root_signature = true; + if (!init_test_context(&context, &desc)) + return; + device = context.device; + queue = context.queue; + + root_parameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_UAV; + root_parameters[0].Descriptor.ShaderRegister = 1; + root_parameters[0].Descriptor.RegisterSpace = 0; + root_parameters[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; + root_parameters[1].ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS; + root_parameters[1].Constants.ShaderRegister = 0; + root_parameters[1].Constants.RegisterSpace = 0; + root_parameters[1].Constants.Num32BitValues = 1; + root_parameters[1].ShaderVisibility = D3D12_SHADER_VISIBILITY_ALL; + root_signature_desc.NumParameters = ARRAY_SIZE(root_parameters); + root_signature_desc.pParameters = root_parameters; + root_signature_desc.NumStaticSamplers = 0; + root_signature_desc.pStaticSamplers = NULL; + root_signature_desc.Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE; + hr = create_root_signature(device, &root_signature_desc, &context.root_signature); + ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr); + + compute_pipeline_state = create_compute_pipeline_state(device, context.root_signature, + shader_bytecode(cs_code, sizeof(cs_code))); + context.pipeline_state = create_pipeline_state(context.device, + context.root_signature, context.render_target_desc.Format, NULL, &ps, NULL); + + compute_queue = create_command_queue(device, D3D12_COMMAND_LIST_TYPE_COMPUTE, D3D12_COMMAND_QUEUE_PRIORITY_NORMAL); + hr = ID3D12Device_CreateFence(device, 0, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, (void **)&fence); + ok(hr == S_OK, "Failed to create fence, hr %#x.\n", hr); + hr = ID3D12Device_CreateFence(device, 0, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, (void **)&fence2); + ok(hr == S_OK, "Failed to create fence, hr %#x.\n", hr); + + buffer = create_default_buffer(device, 1024, + D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_UNORDERED_ACCESS); + + hr = ID3D12Device_CreateCommandAllocator(device, D3D12_COMMAND_LIST_TYPE_DIRECT, + &IID_ID3D12CommandAllocator, (void **)&allocators[0]); + ok(hr == S_OK, "Failed to create command allocator, hr %#x.\n", hr); + hr = ID3D12Device_CreateCommandList(device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, + allocators[0], NULL, &IID_ID3D12GraphicsCommandList, (void **)&graphics_lists[0]); + ok(hr == S_OK, "Failed to create command list, hr %#x.\n", hr); + + graphics_lists[1] = context.list; + ID3D12GraphicsCommandList_AddRef(graphics_lists[1]); + + for (i = 0; i < ARRAY_SIZE(compute_lists); ++i) + { + hr = ID3D12Device_CreateCommandAllocator(device, D3D12_COMMAND_LIST_TYPE_COMPUTE, + &IID_ID3D12CommandAllocator, (void **)&allocators[i + 1]); + ok(hr == S_OK, "Failed to create command allocator, hr %#x.\n", hr); + hr = ID3D12Device_CreateCommandList(device, 0, D3D12_COMMAND_LIST_TYPE_COMPUTE, + allocators[i + 1], NULL, &IID_ID3D12GraphicsCommandList, (void **)&compute_lists[i]); + ok(hr == S_OK, "Failed to create command list, hr %#x.\n", hr); + } + + cpu_heap = create_cpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1); + gpu_heap = create_gpu_descriptor_heap(device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1); + + memset(&uav_desc, 0, sizeof(uav_desc)); + uav_desc.Format = DXGI_FORMAT_R32_UINT; + uav_desc.ViewDimension = D3D12_UAV_DIMENSION_BUFFER; + uav_desc.Buffer.NumElements = 1024 / sizeof(uint32_t); + ID3D12Device_CreateUnorderedAccessView(device, buffer, NULL, &uav_desc, + get_cpu_descriptor_handle(&context, cpu_heap, 0)); + ID3D12Device_CreateUnorderedAccessView(device, buffer, NULL, &uav_desc, + get_cpu_descriptor_handle(&context, gpu_heap, 0)); + + ID3D12GraphicsCommandList_ClearUnorderedAccessViewUint(compute_lists[0], + get_gpu_descriptor_handle(&context, gpu_heap, 0), + get_cpu_descriptor_handle(&context, cpu_heap, 0), + buffer, clear_value, 0, NULL); + uav_barrier(compute_lists[0], buffer); + + value = 0; + for (i = 0; i < ARRAY_SIZE(compute_lists); ++i) + { + command_list = compute_lists[i]; + + ID3D12GraphicsCommandList_SetComputeRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, compute_pipeline_state); + ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(command_list, + 0, ID3D12Resource_GetGPUVirtualAddress(buffer)); + ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(command_list, 1, 1, &value, 0); + ID3D12GraphicsCommandList_Dispatch(command_list, 1, 1, 1); + hr = ID3D12GraphicsCommandList_Close(command_list); + ok(hr == S_OK, "Failed to close command list, hr %#x.\n", hr); + + value += 10; + + command_list = graphics_lists[i]; + + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state); + ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport); + ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect); + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootUnorderedAccessView(command_list, + 0, ID3D12Resource_GetGPUVirtualAddress(buffer)); + ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(command_list, 1, 1, &value, 0); + ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); + hr = ID3D12GraphicsCommandList_Close(command_list); + ok(hr == S_OK, "Failed to close command list, hr %#x.\n", hr); + + value += 2; + } + + exec_command_list(compute_queue, compute_lists[0]); + hr = ID3D12CommandQueue_Signal(compute_queue, fence, 1); + ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + + hr = ID3D12CommandQueue_Wait(queue, fence, 1); + ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + exec_command_list(queue, graphics_lists[0]); + hr = ID3D12CommandQueue_Signal(queue, fence2, 1); + ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + + hr = ID3D12CommandQueue_Wait(compute_queue, fence2, 1); + ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + exec_command_list(compute_queue, compute_lists[1]); + hr = ID3D12CommandQueue_Signal(compute_queue, fence, 2); + ok(hr == S_OK, "Failed to signal fence, hr %#x.\n", hr); + + hr = ID3D12CommandQueue_Wait(queue, fence, 2); + ok(hr == S_OK, "Failed to submit wait operation to queue, hr %#x.\n", hr); + exec_command_list(queue, graphics_lists[1]); + + hr = wait_for_fence(fence2, 1); + ok(hr == S_OK, "Failed to wait for fence, hr %#x.\n", hr); + reset_command_list(graphics_lists[0], allocators[0]); + command_list = graphics_lists[0]; + + transition_resource_state(command_list, buffer, + D3D12_RESOURCE_STATE_UNORDERED_ACCESS, D3D12_RESOURCE_STATE_COPY_SOURCE); + get_buffer_readback_with_command_list(buffer, DXGI_FORMAT_R32_UINT, &rb, queue, command_list); + value = get_readback_uint(&rb, 0, 0, 0); + ok(value == 24, "Got unexpected value %u.\n", value); + release_resource_readback(&rb); + + ID3D12DescriptorHeap_Release(cpu_heap); + ID3D12DescriptorHeap_Release(gpu_heap); + for (i = 0; i < ARRAY_SIZE(graphics_lists); ++i) + ID3D12GraphicsCommandList_Release(graphics_lists[i]); + for (i = 0; i < ARRAY_SIZE(compute_lists); ++i) + ID3D12GraphicsCommandList_Release(compute_lists[i]); + for (i = 0; i < ARRAY_SIZE(allocators); ++i) + ID3D12CommandAllocator_Release(allocators[i]); + ID3D12Fence_Release(fence); + ID3D12Fence_Release(fence2); + ID3D12Resource_Release(buffer); + ID3D12CommandQueue_Release(compute_queue); + ID3D12PipelineState_Release(compute_pipeline_state); + destroy_test_context(&context); +} + START_TEST(d3d12) { parse_args(argc, argv); @@ -28761,4 +28985,5 @@ START_TEST(d3d12) run_test(test_vertex_shader_stream_output); run_test(test_read_write_subresource); run_test(test_queue_wait); + run_test(test_graphics_compute_queue_synchronization); } -- 2.21.0

2 1

[PATCH vkd3d 5/8] vkd3d: Use list to store Vulkan semaphores.
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 81 ++++++++++++++++---------------------- libs/vkd3d/vkd3d_private.h | 18 +++++---- 2 files changed, 45 insertions(+), 54 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index c609270114df..ddd36d407c8b 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -446,45 +446,35 @@ static void d3d12_fence_garbage_collect_vk_semaphores_locked(struct d3d12_fence { struct d3d12_device *device = fence->device; const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - VkSemaphore vk_semaphore; - size_t semaphore_count; - unsigned int i, j; + struct vkd3d_signaled_semaphore *current, *p; + unsigned int semaphore_count; semaphore_count = fence->semaphore_count; if (!destroy_all && semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE) return; - for (i = 0, j = 0; i < fence->semaphore_count; ++i) + LIST_FOR_EACH_ENTRY_SAFE(current, p, &fence->semaphores, struct vkd3d_signaled_semaphore, entry) { - if (!destroy_all && semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE) + if (!destroy_all && fence->semaphore_count < VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE) break; /* The semaphore doesn't have a pending signal operation if the fence * was signaled. */ - if (!fence->semaphores[i].vk_fence || destroy_all) - { - vk_semaphore = fence->semaphores[i].vk_semaphore; - if (fence->semaphores[i].vk_fence) - WARN("Destroying potentially pending semaphore.\n"); - VK_CALL(vkDestroySemaphore(device->vk_device, vk_semaphore, NULL)); - --semaphore_count; - } - else - { - if (i != j) - fence->semaphores[j] = fence->semaphores[i]; - ++j; - } - } - for (; i < fence->semaphore_count; ++i) - { - fence->semaphores[j++] = fence->semaphores[i]; - } + if (current->vk_fence && !destroy_all) + continue; - if (j != fence->semaphore_count) - TRACE("Destroyed %zu Vulkan semaphores.\n", fence->semaphore_count - j); + if (current->vk_fence) + WARN("Destroying potentially pending semaphore.\n"); + + VK_CALL(vkDestroySemaphore(device->vk_device, current->vk_semaphore, NULL)); + list_remove(&current->entry); + vkd3d_free(current); + + --fence->semaphore_count; + } - fence->semaphore_count = j; + if (semaphore_count != fence->semaphore_count) + TRACE("Destroyed %u Vulkan semaphores.\n", semaphore_count - fence->semaphore_count); } static void d3d12_fence_destroy_vk_objects(struct d3d12_fence *fence) @@ -517,32 +507,33 @@ static void d3d12_fence_destroy_vk_objects(struct d3d12_fence *fence) static HRESULT d3d12_fence_add_vk_semaphore(struct d3d12_fence *fence, VkSemaphore vk_semaphore, VkFence vk_fence, uint64_t value) { + struct vkd3d_signaled_semaphore *semaphore; HRESULT hr = S_OK; int rc; TRACE("fence %p, value %#"PRIx64".\n", fence, value); + if (!(semaphore = vkd3d_malloc(sizeof(*semaphore)))) + { + ERR("Failed to add semaphore.\n"); + return E_OUTOFMEMORY; + } + if ((rc = pthread_mutex_lock(&fence->mutex))) { ERR("Failed to lock mutex, error %d.\n", rc); + vkd3d_free(semaphore); return E_FAIL; } d3d12_fence_garbage_collect_vk_semaphores_locked(fence, false); - if (vkd3d_array_reserve((void **)&fence->semaphores, &fence->semaphores_size, - fence->semaphore_count + 1, sizeof(*fence->semaphores))) - { - fence->semaphores[fence->semaphore_count].value = value; - fence->semaphores[fence->semaphore_count].vk_semaphore = vk_semaphore; - fence->semaphores[fence->semaphore_count].vk_fence = vk_fence; - ++fence->semaphore_count; - } - else - { - ERR("Failed to add semaphore.\n"); - hr = E_OUTOFMEMORY; - } + semaphore->value = value; + semaphore->vk_semaphore = vk_semaphore; + semaphore->vk_fence = vk_fence; + + list_add_tail(&fence->semaphores, &semaphore->entry); + ++fence->semaphore_count; pthread_mutex_unlock(&fence->mutex); @@ -552,6 +543,7 @@ static HRESULT d3d12_fence_add_vk_semaphore(struct d3d12_fence *fence, static HRESULT d3d12_fence_signal(struct d3d12_fence *fence, uint64_t value, VkFence vk_fence) { struct d3d12_device *device = fence->device; + struct vkd3d_signaled_semaphore *current; unsigned int i, j; int rc; @@ -584,10 +576,8 @@ static HRESULT d3d12_fence_signal(struct d3d12_fence *fence, uint64_t value, VkF { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; - for (i = 0; i < fence->semaphore_count; ++i) + LIST_FOR_EACH_ENTRY(current, &fence->semaphores, struct vkd3d_signaled_semaphore, entry) { - struct vkd3d_signaled_semaphore *current = &fence->semaphores[i]; - if (current->vk_fence == vk_fence) current->vk_fence = VK_NULL_HANDLE; } @@ -661,7 +651,6 @@ static ULONG STDMETHODCALLTYPE d3d12_fence_Release(ID3D12Fence *iface) d3d12_fence_destroy_vk_objects(fence); - vkd3d_free(fence->semaphores); vkd3d_free(fence->events); if ((rc = pthread_mutex_destroy(&fence->mutex))) ERR("Failed to destroy mutex, error %d.\n", rc); @@ -851,8 +840,8 @@ static HRESULT d3d12_fence_init(struct d3d12_fence *fence, struct d3d12_device * fence->events = NULL; fence->events_size = 0; fence->event_count = 0; - fence->semaphores = NULL; - fence->semaphores_size = 0; + + list_init(&fence->semaphores); fence->semaphore_count = 0; memset(fence->old_vk_fences, 0, sizeof(fence->old_vk_fences)); diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 033582261bf5..09ac4e01b7c7 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -279,6 +279,14 @@ HRESULT vkd3d_set_private_data(struct vkd3d_private_store *store, HRESULT vkd3d_set_private_data_interface(struct vkd3d_private_store *store, const GUID *tag, const IUnknown *object) DECLSPEC_HIDDEN; +struct vkd3d_signaled_semaphore +{ + struct list entry; + uint64_t value; + VkSemaphore vk_semaphore; + VkFence vk_fence; +}; + /* ID3D12Fence */ struct d3d12_fence { @@ -296,14 +304,8 @@ struct d3d12_fence size_t events_size; size_t event_count; - struct vkd3d_signaled_semaphore - { - uint64_t value; - VkSemaphore vk_semaphore; - VkFence vk_fence; - } *semaphores; - size_t semaphores_size; - size_t semaphore_count; + struct list semaphores; + unsigned int semaphore_count; VkFence old_vk_fences[VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE]; -- 2.21.0

2 1

[PATCH vkd3d 7/8] vkd3d: Implement d3d12_command_queue_Wait().
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Waiting before the signal is not supported yet. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- The emulation of ID3D12Fence with a Vulkan semaphore per fence value isn't very pretty, but the wait before signal emulation is expected to be even worse... --- libs/vkd3d/command.c | 164 ++++++++++++++++++++++++++++++++++++- libs/vkd3d/vkd3d_private.h | 1 + 2 files changed, 162 insertions(+), 3 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 2febca67e1ce..c8e23e1fd2ab 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -524,11 +524,12 @@ static void d3d12_fence_garbage_collect_vk_semaphores_locked(struct d3d12_fence /* The semaphore doesn't have a pending signal operation if the fence * was signaled. */ - if (current->vk_fence && !destroy_all) + if ((current->vk_fence || current->is_acquired) && !destroy_all) continue; if (current->vk_fence) WARN("Destroying potentially pending semaphore.\n"); + assert(!current->is_acquired); VK_CALL(vkDestroySemaphore(device->vk_device, current->vk_semaphore, NULL)); list_remove(&current->entry); @@ -568,6 +569,83 @@ static void d3d12_fence_destroy_vk_objects(struct d3d12_fence *fence) pthread_mutex_unlock(&fence->mutex); } +static struct vkd3d_signaled_semaphore *d3d12_fence_acquire_vk_semaphore(struct d3d12_fence *fence, + uint64_t value, uint64_t *completed_value) +{ + struct vkd3d_signaled_semaphore *semaphore; + struct vkd3d_signaled_semaphore *current; + uint64_t semaphore_value; + int rc; + + TRACE("fence %p, value %#"PRIx64".\n", fence, value); + + if ((rc = pthread_mutex_lock(&fence->mutex))) + { + ERR("Failed to lock mutex, error %d.\n", rc); + return VK_NULL_HANDLE; + } + + semaphore = NULL; + semaphore_value = ~(uint64_t)0; + + LIST_FOR_EACH_ENTRY(current, &fence->semaphores, struct vkd3d_signaled_semaphore, entry) + { + /* Prefer a semaphore with the smallest value. */ + if (!current->is_acquired && current->value >= value && semaphore_value >= current->value) + { + semaphore = current; + semaphore_value = current->value; + } + if (semaphore_value == value) + break; + } + + if (semaphore) + semaphore->is_acquired = true; + + *completed_value = fence->value; + + pthread_mutex_unlock(&fence->mutex); + + return semaphore; +} + +static void d3d12_fence_remove_vk_semaphore(struct d3d12_fence *fence, struct vkd3d_signaled_semaphore *semaphore) +{ + int rc; + + if ((rc = pthread_mutex_lock(&fence->mutex))) + { + ERR("Failed to lock mutex, error %d.\n", rc); + return; + } + + assert(semaphore->is_acquired); + + list_remove(&semaphore->entry); + vkd3d_free(semaphore); + + --fence->semaphore_count; + + pthread_mutex_unlock(&fence->mutex); +} + +static void d3d12_fence_release_vk_semaphore(struct d3d12_fence *fence, struct vkd3d_signaled_semaphore *semaphore) +{ + int rc; + + if ((rc = pthread_mutex_lock(&fence->mutex))) + { + ERR("Failed to lock mutex, error %d.\n", rc); + return; + } + + assert(semaphore->is_acquired); + semaphore->is_acquired = false; + + pthread_mutex_unlock(&fence->mutex); +} + static HRESULT d3d12_fence_add_vk_semaphore(struct d3d12_fence *fence, VkSemaphore vk_semaphore, VkFence vk_fence, uint64_t value) { @@ -595,6 +673,7 @@ static HRESULT d3d12_fence_add_vk_semaphore(struct d3d12_fence *fence, semaphore->value = value; semaphore->vk_semaphore = vk_semaphore; semaphore->vk_fence = vk_fence; + semaphore->is_acquired = false; list_add_tail(&fence->semaphores, &semaphore->entry); ++fence->semaphore_count; @@ -5271,11 +5350,90 @@ fail: } static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Wait(ID3D12CommandQueue *iface, - ID3D12Fence *fence, UINT64 value) + ID3D12Fence *fence_iface, UINT64 value) { - FIXME("iface %p, fence %p, value %#"PRIx64" stub!\n", iface, fence, value); + static const VkPipelineStageFlagBits wait_stage_mask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + struct d3d12_command_queue *command_queue = impl_from_ID3D12CommandQueue(iface); + const struct vkd3d_vk_device_procs *vk_procs; + struct vkd3d_signaled_semaphore *semaphore; + VkQueue vk_queue = VK_NULL_HANDLE; + uint64_t completed_value = 0; + struct vkd3d_queue *queue; + struct d3d12_fence *fence; + VkSubmitInfo submit_info; + VkResult vr; + HRESULT hr; + + TRACE("iface %p, fence %p, value %#"PRIx64".\n", iface, fence_iface, value); + + vk_procs = &command_queue->device->vk_procs; + queue = command_queue->vkd3d_queue; + + fence = unsafe_impl_from_ID3D12Fence(fence_iface); + + if (!(semaphore = d3d12_fence_acquire_vk_semaphore(fence, value, &completed_value))) + { + if (completed_value >= value) + { + TRACE("Already signaled %p, value %#"PRIx64".\n", fence, completed_value); + } + else + { + FIXME("Failed to acquire Vulkan semaphore for fence %p, value %#"PRIx64", completed value %#"PRIx64".\n", + fence, value, completed_value); + } + + return S_OK; + } + + submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.pNext = NULL; + submit_info.waitSemaphoreCount = 1; + submit_info.pWaitSemaphores = &semaphore->vk_semaphore; + submit_info.pWaitDstStageMask = &wait_stage_mask; + submit_info.commandBufferCount = 0; + submit_info.pCommandBuffers = NULL; + submit_info.signalSemaphoreCount = 0; + submit_info.pSignalSemaphores = NULL; + + if (!(vk_queue = vkd3d_queue_acquire(queue))) + { + ERR("Failed to acquire queue %p.\n", queue); + hr = E_FAIL; + goto fail; + } + + if (!vkd3d_array_reserve((void **)&queue->semaphores, &queue->semaphores_size, + queue->semaphore_count + 1, sizeof(*queue->semaphores))) + { + ERR("Failed to allocate memory for semaphore.\n"); + vkd3d_queue_release(queue); + hr = E_OUTOFMEMORY; + goto fail; + } + if ((vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, VK_NULL_HANDLE))) >= 0) + { + queue->semaphores[queue->semaphore_count].vk_semaphore = semaphore->vk_semaphore; + queue->semaphores[queue->semaphore_count].sequence_number = queue->submitted_sequence_number + 1; + ++queue->semaphore_count; + } + + vkd3d_queue_release(queue); + + if (vr < 0) + { + WARN("Failed to submit wait operation, vr %d.\n", vr); + hr = hresult_from_vk_result(vr); + goto fail; + } + + d3d12_fence_remove_vk_semaphore(fence, semaphore); return S_OK; + +fail: + d3d12_fence_release_vk_semaphore(fence, semaphore); + return hr; } static HRESULT STDMETHODCALLTYPE d3d12_command_queue_GetTimestampFrequency(ID3D12CommandQueue *iface, diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index f934d0ba9154..349591ddfe04 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -287,6 +287,7 @@ struct vkd3d_signaled_semaphore uint64_t value; VkSemaphore vk_semaphore; VkFence vk_fence; + bool is_acquired; }; /* ID3D12Fence */ -- 2.21.0

2 1

[PATCH vkd3d 6/8] vkd3d: Introduce queue sequence numbers to track unused Vulkan semaphores.
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> In preparation for the following commmit. Sequence numbers allows us to more easily track progress on queues in comparison to tracking each VkFence individually. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- Even, if the queue submit count is on the order of hundreds per frame, it shouldn't overrun 64-bit sequence number. --- libs/vkd3d/command.c | 92 ++++++++++++++++++++++++++++++++++---- libs/vkd3d/device.c | 6 +-- libs/vkd3d/vkd3d_private.h | 19 +++++++- 3 files changed, 103 insertions(+), 14 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index ddd36d407c8b..2febca67e1ce 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -38,10 +38,17 @@ HRESULT vkd3d_queue_create(struct d3d12_device *device, return hresult_from_errno(rc); } + object->completed_sequence_number = 0; + object->submitted_sequence_number = 0; + object->vk_family_index = family_index; object->vk_queue_flags = properties->queueFlags; object->timestamp_bits = properties->timestampValidBits; + object->semaphores = NULL; + object->semaphores_size = 0; + object->semaphore_count = 0; + VK_CALL(vkGetDeviceQueue(device->vk_device, family_index, 0, &object->vk_queue)); TRACE("Created queue %p for queue family index %u.\n", object, family_index); @@ -51,8 +58,23 @@ HRESULT vkd3d_queue_create(struct d3d12_device *device, return S_OK; } -void vkd3d_queue_destroy(struct vkd3d_queue *queue) +void vkd3d_queue_destroy(struct vkd3d_queue *queue, struct d3d12_device *device) { + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + unsigned int i; + int rc; + + if ((rc = pthread_mutex_lock(&queue->mutex))) + ERR("Failed to lock mutex, error %d.\n", rc); + + for (i = 0; i < queue->semaphore_count; ++i) + VK_CALL(vkDestroySemaphore(device->vk_device, queue->semaphores[i].vk_semaphore, NULL)); + + vkd3d_free(queue->semaphores); + + if (!rc) + pthread_mutex_unlock(&queue->mutex); + pthread_mutex_destroy(&queue->mutex); vkd3d_free(queue); } @@ -103,9 +125,46 @@ static VkResult vkd3d_queue_wait_idle(struct vkd3d_queue *queue, return vr; } +static void vkd3d_queue_update_sequence_number(struct vkd3d_queue *queue, + uint64_t sequence_number, struct d3d12_device *device) +{ + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + uint64_t completed_sequence_number; + unsigned int i; + int rc; + + if ((rc = pthread_mutex_lock(&queue->mutex))) + { + ERR("Failed to lock mutex, error %d.\n", rc); + return; + } + + completed_sequence_number = queue->completed_sequence_number; + queue->completed_sequence_number = max(sequence_number, queue->completed_sequence_number); + + TRACE("Sequence number %"PRIu64" -> %"PRIu64".\n", completed_sequence_number, queue->completed_sequence_number); + + for (i = 0; i < queue->semaphore_count; ++i) + { + if (queue->semaphores[i].sequence_number > queue->completed_sequence_number) + break; + + VK_CALL(vkDestroySemaphore(device->vk_device, queue->semaphores[i].vk_semaphore, NULL)); + } + if (i > 0) + { + TRACE("Destroyed %u Vulkan semaphores.\n", i); + queue->semaphore_count -= i; + memmove(queue->semaphores, &queue->semaphores[i], queue->semaphore_count * sizeof(*queue->semaphores)); + } + + pthread_mutex_unlock(&queue->mutex); +} + /* Fence worker thread */ static HRESULT vkd3d_enqueue_gpu_fence(struct vkd3d_fence_worker *worker, - VkFence vk_fence, struct d3d12_fence *fence, uint64_t value) + VkFence vk_fence, struct d3d12_fence *fence, uint64_t value, + struct vkd3d_queue *queue, uint64_t queue_sequence_number) { int rc; @@ -135,6 +194,8 @@ static HRESULT vkd3d_enqueue_gpu_fence(struct vkd3d_fence_worker *worker, worker->vk_fences[worker->fence_count] = vk_fence; worker->fences[worker->fence_count].fence = fence; worker->fences[worker->fence_count].value = value; + worker->fences[worker->fence_count].queue = queue; + worker->fences[worker->fence_count].queue_sequence_number = queue_sequence_number; ++worker->fence_count; pthread_cond_signal(&worker->cond); @@ -204,9 +265,12 @@ static void vkd3d_wait_for_gpu_fences(struct vkd3d_fence_worker *worker) if (!(vr = VK_CALL(vkGetFenceStatus(device->vk_device, vk_fence)))) { struct vkd3d_waiting_fence *current = &worker->fences[i]; + TRACE("Signaling fence %p value %#"PRIx64".\n", current->fence, current->value); if (FAILED(hr = d3d12_fence_signal(current->fence, current->value, vk_fence))) ERR("Failed to signal D3D12 fence, hr %#x.\n", hr); + + vkd3d_queue_update_sequence_number(current->queue, current->queue_sequence_number, device); continue; } @@ -5103,9 +5167,11 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * VkSemaphore vk_semaphore = VK_NULL_HANDLE; VkSemaphoreCreateInfo semaphore_info; VkFence vk_fence = VK_NULL_HANDLE; + struct vkd3d_queue *vkd3d_queue; struct d3d12_device *device; struct d3d12_fence *fence; VkSubmitInfo submit_info; + uint64_t sequence_number; VkQueue vk_queue; VkResult vr; HRESULT hr; @@ -5114,6 +5180,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * device = command_queue->device; vk_procs = &device->vk_procs; + vkd3d_queue = command_queue->vkd3d_queue; fence = unsafe_impl_from_ID3D12Fence(fence_iface); @@ -5144,17 +5211,23 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * submit_info.signalSemaphoreCount = 1; submit_info.pSignalSemaphores = &vk_semaphore; - if (!(vk_queue = vkd3d_queue_acquire(command_queue->vkd3d_queue))) + if (!(vk_queue = vkd3d_queue_acquire(vkd3d_queue))) { - ERR("Failed to acquire queue %p.\n", command_queue->vkd3d_queue); + ERR("Failed to acquire queue %p.\n", vkd3d_queue); hr = E_FAIL; goto fail; } - vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, vk_fence)); - vkd3d_queue_release(command_queue->vkd3d_queue); + + if ((vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, vk_fence))) >= 0) + sequence_number = ++vkd3d_queue->submitted_sequence_number; + + vkd3d_queue_release(vkd3d_queue); + + assert(sequence_number != ~(uint64_t)0); + if (vr < 0) { - WARN("Failed to submit, vr %d.\n", vr); + WARN("Failed to submit signal operation, vr %d.\n", vr); goto fail_vkresult; } @@ -5164,7 +5237,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * vr = VK_CALL(vkGetFenceStatus(device->vk_device, vk_fence)); if (vr == VK_NOT_READY) { - if (SUCCEEDED(hr = vkd3d_enqueue_gpu_fence(&device->fence_worker, vk_fence, fence, value))) + if (SUCCEEDED(hr = vkd3d_enqueue_gpu_fence(&device->fence_worker, vk_fence, fence, value, vkd3d_queue, sequence_number))) vk_fence = VK_NULL_HANDLE; } else if (vr == VK_SUCCESS) @@ -5172,6 +5245,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * TRACE("Already signaled %p, value %#"PRIx64".\n", fence, value); hr = d3d12_fence_signal(fence, value, vk_fence); vk_fence = VK_NULL_HANDLE; + vkd3d_queue_update_sequence_number(vkd3d_queue, sequence_number, device); } else { @@ -5182,7 +5256,7 @@ static HRESULT STDMETHODCALLTYPE d3d12_command_queue_Signal(ID3D12CommandQueue * if (vk_fence || vk_semaphore) { /* In case of an unexpected failure, try to safely destroy Vulkan objects. */ - vkd3d_queue_wait_idle(command_queue->vkd3d_queue, vk_procs); + vkd3d_queue_wait_idle(vkd3d_queue, vk_procs); goto fail; } diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 41f7ea18d688..cb2934a23afb 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -1425,12 +1425,12 @@ struct vkd3d_device_queue_info static void d3d12_device_destroy_vkd3d_queues(struct d3d12_device *device) { if (device->direct_queue) - vkd3d_queue_destroy(device->direct_queue); + vkd3d_queue_destroy(device->direct_queue, device); if (device->compute_queue && device->compute_queue != device->direct_queue) - vkd3d_queue_destroy(device->compute_queue); + vkd3d_queue_destroy(device->compute_queue, device); if (device->copy_queue && device->copy_queue != device->direct_queue && device->copy_queue != device->compute_queue) - vkd3d_queue_destroy(device->copy_queue); + vkd3d_queue_destroy(device->copy_queue, device); device->direct_queue = NULL; device->compute_queue = NULL; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 09ac4e01b7c7..f934d0ba9154 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -157,7 +157,9 @@ struct vkd3d_fence_worker struct vkd3d_waiting_fence { struct d3d12_fence *fence; - UINT64 value; + uint64_t value; + struct vkd3d_queue *queue; + uint64_t queue_sequence_number; } *fences; size_t fences_size; @@ -882,17 +884,30 @@ struct vkd3d_queue { /* Access to VkQueue must be externally synchronized. */ pthread_mutex_t mutex; + VkQueue vk_queue; + + uint64_t completed_sequence_number; + uint64_t submitted_sequence_number; + uint32_t vk_family_index; VkQueueFlags vk_queue_flags; uint32_t timestamp_bits; + + struct + { + VkSemaphore vk_semaphore; + uint64_t sequence_number; + } *semaphores; + size_t semaphores_size; + size_t semaphore_count; }; VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; 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) 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; /* ID3D12CommandQueue */ -- 2.21.0

2 1

[PATCH vkd3d 2/8] vkd3d: Allow simultaneous buffer access from multiple queues.
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 15 ++++++++++++--- libs/vkd3d/resource.c | 8 ++++---- libs/vkd3d/vkd3d_private.h | 7 +++++-- 3 files changed, 21 insertions(+), 9 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 052d4f6f8fdd..41f7ea18d688 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -1449,22 +1449,31 @@ static HRESULT d3d12_device_create_vkd3d_queues(struct d3d12_device *device, device->compute_queue = NULL; device->copy_queue = NULL; - if (FAILED((hr = vkd3d_queue_create(device, direct_family_index, + device->queue_family_count = 0; + memset(device->queue_family_indices, 0, sizeof(device->queue_family_indices)); + + if (SUCCEEDED((hr = vkd3d_queue_create(device, direct_family_index, &queue_info->vk_properties[VKD3D_QUEUE_FAMILY_DIRECT], &device->direct_queue)))) + device->queue_family_indices[device->queue_family_count++] = direct_family_index; + else goto out_destroy_queues; if (compute_family_index == direct_family_index) device->compute_queue = device->direct_queue; - else if (FAILED(hr = vkd3d_queue_create(device, compute_family_index, + else if (SUCCEEDED(hr = vkd3d_queue_create(device, compute_family_index, &queue_info->vk_properties[VKD3D_QUEUE_FAMILY_COMPUTE], &device->compute_queue))) + device->queue_family_indices[device->queue_family_count++] = compute_family_index; + else goto out_destroy_queues; if (transfer_family_index == direct_family_index) device->copy_queue = device->direct_queue; else if (transfer_family_index == compute_family_index) device->copy_queue = device->compute_queue; - else if (FAILED(hr = vkd3d_queue_create(device, transfer_family_index, + else if (SUCCEEDED(hr = vkd3d_queue_create(device, transfer_family_index, &queue_info->vk_properties[VKD3D_QUEUE_FAMILY_TRANSFER], &device->copy_queue))) + device->queue_family_indices[device->queue_family_count++] = transfer_family_index; + else goto out_destroy_queues; return S_OK; diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 84855853fe4b..9e6216a0251f 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -529,10 +529,10 @@ HRESULT vkd3d_create_buffer(struct d3d12_device *device, if (!(desc->Flags & D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE)) buffer_info.usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; - /* FIXME: Buffers always can be accessed from multiple queues. */ - buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; - buffer_info.queueFamilyIndexCount = 0; - buffer_info.pQueueFamilyIndices = 0; + /* Buffers always have properties of D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS. */ + buffer_info.sharingMode = VK_SHARING_MODE_CONCURRENT; + buffer_info.queueFamilyIndexCount = device->queue_family_count; + buffer_info.pQueueFamilyIndices = device->queue_family_indices; if ((vr = VK_CALL(vkCreateBuffer(device->vk_device, &buffer_info, NULL, vk_buffer))) < 0) { diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index b33318264891..033582261bf5 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -48,8 +48,9 @@ #define VKD3D_DESCRIPTOR_MAGIC_DSV 0x00565344u #define VKD3D_DESCRIPTOR_MAGIC_RTV 0x00565452u -#define VKD3D_MAX_SHADER_STAGES 5u -#define VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE 4 +#define VKD3D_MAX_QUEUE_FAMILY_COUNT 3u +#define VKD3D_MAX_SHADER_STAGES 5u +#define VKD3D_MAX_VK_SYNC_OBJECTS_PER_D3D12_FENCE 4u struct d3d12_command_list; struct d3d12_device; @@ -970,6 +971,8 @@ struct d3d12_device struct vkd3d_queue *direct_queue; struct vkd3d_queue *compute_queue; struct vkd3d_queue *copy_queue; + uint32_t queue_family_indices[VKD3D_MAX_QUEUE_FAMILY_COUNT]; + unsigned int queue_family_count; struct vkd3d_instance *vkd3d_instance; -- 2.21.0

2 1

[PATCH vkd3d 4/8] vkd3d: Forbid D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS for buffers.
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 6 ++++++ tests/d3d12.c | 3 +++ 2 files changed, 9 insertions(+) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index ac2ff384cd3d..5bb76bf0c3e0 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -530,6 +530,12 @@ HRESULT vkd3d_create_buffer(struct d3d12_device *device, buffer_info.usage |= VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; /* Buffers always have properties of D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS. */ + if (desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS) + { + WARN("D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS cannot be set for buffers.\n"); + return E_INVALIDARG; + } + buffer_info.sharingMode = VK_SHARING_MODE_CONCURRENT; buffer_info.queueFamilyIndexCount = device->queue_family_count; buffer_info.pQueueFamilyIndices = device->queue_family_indices; diff --git a/tests/d3d12.c b/tests/d3d12.c index dd13ddf999b9..cb05b5e0d65d 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -1615,6 +1615,9 @@ static void test_create_committed_resource(void) {D3D12_HEAP_TYPE_READBACK, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET}, {D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS}, {D3D12_HEAP_TYPE_READBACK, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS}, + {D3D12_HEAP_TYPE_DEFAULT, D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS}, + {D3D12_HEAP_TYPE_UPLOAD, D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS}, + {D3D12_HEAP_TYPE_READBACK, D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS}, }; if (!(device = create_device())) -- 2.21.0

2 1

[PATCH vkd3d 3/8] vkd3d: Translate D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS to VK_SHARING_MODE_CONCURRENT.
by Józef Kucia 03 May '19

03 May '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 9e6216a0251f..ac2ff384cd3d 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -621,11 +621,18 @@ static HRESULT vkd3d_create_image(struct d3d12_device *device, image_info.usage |= VK_IMAGE_USAGE_SAMPLED_BIT; if (desc->Flags & D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS) - FIXME("Ignoring D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS.\n"); - - image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; - image_info.queueFamilyIndexCount = 0; - image_info.pQueueFamilyIndices = NULL; + { + TRACE("Creating image with VK_SHARING_MODE_CONCURRENT.\n"); + image_info.sharingMode = VK_SHARING_MODE_CONCURRENT; + image_info.queueFamilyIndexCount = device->queue_family_count; + image_info.pQueueFamilyIndices = device->queue_family_indices; + } + else + { + image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + image_info.queueFamilyIndexCount = 0; + image_info.pQueueFamilyIndices = NULL; + } image_info.initialLayout = is_cpu_accessible_heap(heap_properties) ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED; -- 2.21.0

2 1

[PATCH 6/6] wined3d: Allocate shader backend and fragment pipe context data in device_context_add().
by Henri Verbeet 03 May '19

03 May '19

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context.c | 39 ++++++++------------------------------- dlls/wined3d/device.c | 17 +++++++++++++++++ 2 files changed, 25 insertions(+), 31 deletions(-) diff --git a/dlls/wined3d/context.c b/dlls/wined3d/context.c index 4a73cbbda13..7e7ab09b76c 100644 --- a/dlls/wined3d/context.c +++ b/dlls/wined3d/context.c @@ -1925,19 +1925,6 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d list_init(&context->fbo_list); list_init(&context->fbo_destroy_list); - if (!device->shader_backend->shader_allocate_context_data(context)) - { - ERR("Failed to allocate shader backend context data.\n"); - return FALSE; - } - - if (!device->adapter->fragment_pipe->allocate_context_data(context)) - { - ERR("Failed to allocate fragment pipeline context data.\n"); - device->shader_backend->shader_free_context_data(context); - return FALSE; - } - if (!(context->hdc = GetDCEx(swapchain->win_handle, 0, DCX_USESTYLE | DCX_CACHE))) { WARN("Failed to retrieve device context, trying swapchain backup.\n"); @@ -1945,8 +1932,6 @@ static BOOL wined3d_context_init(struct wined3d_context *context, struct wined3d if (!(context->hdc = swapchain_get_backup_dc(swapchain))) { ERR("Failed to retrieve a device context.\n"); - device->shader_backend->shader_free_context_data(context); - device->adapter->fragment_pipe->free_context_data(context); return FALSE; } context->hdc_is_private = TRUE; @@ -2001,31 +1986,23 @@ struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, heap_free(context_gl); return NULL; } - - if (!device_context_add(device, context)) + if (!(device->adapter->adapter_ops->adapter_create_context(context, target, ds_format))) { - ERR("Failed to add the newly created context to the context list\n"); - goto fail; + wined3d_release_dc(context->win_handle, context->hdc); + heap_free(context_gl); + return NULL; } - if (!(device->adapter->adapter_ops->adapter_create_context(context, target, ds_format))) + if (!device_context_add(device, context)) { - device_context_remove(device, context); - goto fail; + ERR("Failed to add the newly created context to the context list\n"); + wined3d_context_gl_destroy(context_gl); + return NULL; } - device->shader_backend->shader_init_context_state(context); - TRACE("Created context %p.\n", context); return context; - -fail: - wined3d_release_dc(context->win_handle, context->hdc); - device->shader_backend->shader_free_context_data(context); - device->adapter->fragment_pipe->free_context_data(context); - heap_free(context_gl); - return NULL; } BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index df491e1641e..a27251c86e3 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -149,14 +149,31 @@ BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *c TRACE("Adding context %p.\n", context); + if (!device->shader_backend->shader_allocate_context_data(context)) + { + ERR("Failed to allocate shader backend context data.\n"); + return FALSE; + } + device->shader_backend->shader_init_context_state(context); + + if (!device->adapter->fragment_pipe->allocate_context_data(context)) + { + ERR("Failed to allocate fragment pipeline context data.\n"); + device->shader_backend->shader_free_context_data(context); + return FALSE; + } + if (!(new_array = heap_realloc(device->contexts, sizeof(*new_array) * (device->context_count + 1)))) { ERR("Failed to grow the context array.\n"); + device->adapter->fragment_pipe->free_context_data(context); + device->shader_backend->shader_free_context_data(context); return FALSE; } new_array[device->context_count++] = context; device->contexts = new_array; + return TRUE; } -- 2.11.0

1 0

← Newer
1
...
70
71
72
73
74
75
76
...
79
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel May 2019