wine-commits May 2019

wine-commits@winehq.org

2 participants
1019 discussions

Józef Kucia : vkd3d: Implement d3d12_command_queue_Wait().
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 124e6aad4817e9fb4f78c0fd33788fe5d27abe92 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=124e6aad4817e9fb4f78c0f… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:41 2019 +0200 vkd3d: Implement d3d12_command_queue_Wait(). Waiting before the signal is not supported yet. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- 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 2febca6..c8e23e1 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 f934d0b..349591d 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 */

1 0

Józef Kucia : vkd3d: Introduce queue sequence numbers to track unused Vulkan semaphores.
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 205a41aaaae05c03ea44a80d1bcfc2048410dada URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=205a41aaaae05c03ea44a80… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:40 2019 +0200 vkd3d: Introduce queue sequence numbers to track unused Vulkan semaphores. 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> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- 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 ddd36d4..2febca6 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 41f7ea1..cb2934a 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 09ac4e0..f934d0b 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 */

1 0

Józef Kucia : vkd3d: Use list to store Vulkan semaphores.
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 134f4d0081ce5b65ec7cdc534d29be0877c7fc64 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=134f4d0081ce5b65ec7cdc5… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:39 2019 +0200 vkd3d: Use list to store Vulkan semaphores. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- 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 c609270..ddd36d4 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 0335822..09ac4e0 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];

1 0

Józef Kucia : vkd3d: Forbid D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS for buffers.
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 6801c153309bfd709e2fb529680736ce11df6945 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=6801c153309bfd709e2fb52… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:38 2019 +0200 vkd3d: Forbid D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS for buffers. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- 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 ac2ff38..5bb76bf 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 dd13ddf..cb05b5e 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()))

1 0

Józef Kucia : vkd3d: Translate D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS to VK_SHARING_MODE_CONCURRENT.
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 756931f8494ab195f7832b70a23e9cf7e0817310 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=756931f8494ab195f7832b7… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:37 2019 +0200 vkd3d: Translate D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS to VK_SHARING_MODE_CONCURRENT. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- 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 9e6216a..ac2ff38 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;

1 0

Józef Kucia : vkd3d: Allow simultaneous buffer access from multiple queues.
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 2126614a03b7862a71b0999ef8f1c64e23262f15 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=2126614a03b7862a71b0999… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:36 2019 +0200 vkd3d: Allow simultaneous buffer access from multiple queues. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- 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 052d4f6..41f7ea1 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 8485585..9e6216a 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 b333182..0335822 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;

1 0

Józef Kucia : readme: Update build requirements.
by Alexandre Julliard 03 May '19

03 May '19

Module: vkd3d Branch: master Commit: 9e2ecaf7f4625e56ae388fb27587341636047172 URL: https://source.winehq.org/git/vkd3d.git/?a=commit;h=9e2ecaf7f4625e56ae388fb… Author: Józef Kucia <jkucia(a)codeweavers.com> Date: Thu May 2 16:02:35 2019 +0200 readme: Update build requirements. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- README | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README b/README index bec91a9..be329e1 100644 --- a/README +++ b/README @@ -9,14 +9,14 @@ similar, but not identical, to Direct3D 12. Building vkd3d ============== -Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.1.88). +Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.1.101). 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 you are building from git, then they will be generated at build-time using widl. By default, vkd3d will use the widl found in `PATH'. If widl is not -available or is not recent (>= 3.0 or so), then you can build Wine with -`make tools/widl' to avoid building all of Wine. You can then point vkd3d's +available or is not recent (>= 3.20), then you can build Wine with `make +tools/widl' to avoid building all of Wine. You can then point vkd3d's configure at that widl binary with `WIDL="/path/to/widl"'. ===========

1 0

Nikolay Sivov : mfplat/tests: Add some tests for calling scheme handler directly.
by Alexandre Julliard 02 May '19

02 May '19

Module: wine Branch: master Commit: 0ece679210897774b3b43e483658fe6511a84676 URL: https://source.winehq.org/git/wine.git/?a=commit;h=0ece679210897774b3b43e48… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Thu May 2 17:09:10 2019 +0300 mfplat/tests: Add some tests for calling scheme handler directly. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/mfplat/tests/mfplat.c | 71 ++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 68 insertions(+), 3 deletions(-) diff --git a/dlls/mfplat/tests/mfplat.c b/dlls/mfplat/tests/mfplat.c index 10c2fd1..0a378b5 100644 --- a/dlls/mfplat/tests/mfplat.c +++ b/dlls/mfplat/tests/mfplat.c @@ -36,6 +36,7 @@ DEFINE_GUID(DUMMY_CLSID, 0x12345678,0x1234,0x1234,0x12,0x13,0x14,0x15,0x16,0x17, DEFINE_GUID(DUMMY_GUID1, 0x12345678,0x1234,0x1234,0x21,0x21,0x21,0x21,0x21,0x21,0x21,0x21); DEFINE_GUID(DUMMY_GUID2, 0x12345678,0x1234,0x1234,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22); DEFINE_GUID(DUMMY_GUID3, 0x12345678,0x1234,0x1234,0x23,0x23,0x23,0x23,0x23,0x23,0x23,0x23); +DEFINE_GUID(CLSID_FileSchemeHandler, 0x477ec299, 0x1421, 0x4bdd, 0x97, 0x1f, 0x7c, 0xcb, 0x93, 0x3f, 0x21, 0xad); #undef INITGUID #include <guiddef.h> @@ -288,15 +289,52 @@ static const IMFAsyncCallbackVtbl test_create_from_url_callback_vtbl = test_create_from_url_callback_Invoke, }; +static HRESULT WINAPI test_create_from_file_handler_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result) +{ + struct test_callback *callback = impl_from_IMFAsyncCallback(iface); + IMFSchemeHandler *handler; + IUnknown *object, *object2; + MF_OBJECT_TYPE obj_type; + HRESULT hr; + + ok(!!result, "Unexpected result object.\n"); + + handler = (IMFSchemeHandler *)IMFAsyncResult_GetStateNoAddRef(result); + + hr = IMFSchemeHandler_EndCreateObject(handler, result, &obj_type, &object); + ok(hr == S_OK, "Failed to create an object, hr %#x.\n", hr); + + hr = IMFAsyncResult_GetObject(result, &object2); + ok(hr == E_POINTER, "Unexpected hr %#x.\n", hr); + + IUnknown_Release(object); + + SetEvent(callback->event); + + return S_OK; +} + +static const IMFAsyncCallbackVtbl test_create_from_file_handler_callback_vtbl = +{ + testcallback_QueryInterface, + testcallback_AddRef, + testcallback_Release, + testcallback_GetParameters, + test_create_from_file_handler_callback_Invoke, +}; + static void test_source_resolver(void) { static const WCHAR file_type[] = {'v','i','d','e','o','/','m','p','4',0}; struct test_callback callback = { { &test_create_from_url_callback_vtbl } }; + struct test_callback callback2 = { { &test_create_from_file_handler_callback_vtbl } }; IMFSourceResolver *resolver, *resolver2; + IMFSchemeHandler *scheme_handler; IMFAttributes *attributes; IMFMediaSource *mediasource; IMFPresentationDescriptor *descriptor; IMFMediaTypeHandler *handler; + BOOL selected, do_uninit; MF_OBJECT_TYPE obj_type; IMFStreamDescriptor *sd; IUnknown *cancel_cookie; @@ -304,7 +342,6 @@ static void test_source_resolver(void) WCHAR pathW[MAX_PATH]; HRESULT hr; WCHAR *filename; - BOOL selected; GUID guid; if (!pMFCreateSourceResolver) @@ -417,8 +454,6 @@ todo_wine { if (SUCCEEDED(hr)) WaitForSingleObject(callback.event, INFINITE); - CloseHandle(callback.event); - /* With explicit scheme. */ lstrcpyW(pathW, fileschemeW); lstrcatW(pathW, filename); @@ -432,10 +467,40 @@ todo_wine IMFSourceResolver_Release(resolver); + /* Create directly through scheme handler. */ + hr = CoInitialize(NULL); + ok(SUCCEEDED(hr), "Failed to initialize, hr %#x.\n", hr); + do_uninit = hr == S_OK; + + hr = CoCreateInstance(&CLSID_FileSchemeHandler, NULL, CLSCTX_INPROC_SERVER, &IID_IMFSchemeHandler, + (void **)&scheme_handler); + ok(hr == S_OK, "Failed to create handler object, hr %#x.\n", hr); + + callback2.event = callback.event; + 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); + + if (SUCCEEDED(hr)) + WaitForSingleObject(callback2.event, INFINITE); + + IMFSchemeHandler_Release(scheme_handler); + + if (do_uninit) + CoUninitialize(); + hr = MFShutdown(); ok(hr == S_OK, "Failed to shut down, hr %#x.\n", hr); DeleteFileW(filename); + + CloseHandle(callback.event); } static void init_functions(void)

1 0

Nikolay Sivov : mfplat: Use file url scheme as a fallback.
by Alexandre Julliard 02 May '19

02 May '19

Module: wine Branch: master Commit: 75def3a11e4f9dd8d0005fc263670a3d8de2c2a2 URL: https://source.winehq.org/git/wine.git/?a=commit;h=75def3a11e4f9dd8d0005fc2… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Thu May 2 17:09:09 2019 +0300 mfplat: Use file url scheme as a fallback. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/mfplat/main.c | 68 +++++++++------ dlls/mfplat/tests/mfplat.c | 211 ++++++++++++++++++++++++++++++--------------- 2 files changed, 186 insertions(+), 93 deletions(-) Diff: https://source.winehq.org/git/wine.git/?a=commitdiff;h=75def3a11e4f9dd8d000…

1 0

Nikolay Sivov : mf: Register file: scheme handler.
by Alexandre Julliard 02 May '19

02 May '19

Module: wine Branch: master Commit: 9e948c47f6c3d474eddbb026b88846bf393bd59e URL: https://source.winehq.org/git/wine.git/?a=commit;h=9e948c47f6c3d474eddbb026… Author: Nikolay Sivov <nsivov(a)codeweavers.com> Date: Thu May 2 17:09:08 2019 +0300 mf: Register file: scheme handler. Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Alexandre Julliard <julliard(a)winehq.org> --- dlls/mf/Makefile.in | 2 ++ dlls/mf/mf.rc | 24 ++++++++++++++++++++++++ dlls/mf/mf.rgs | 19 +++++++++++++++++++ 3 files changed, 45 insertions(+) diff --git a/dlls/mf/Makefile.in b/dlls/mf/Makefile.in index 5e18ab4..3499a4a 100644 --- a/dlls/mf/Makefile.in +++ b/dlls/mf/Makefile.in @@ -8,3 +8,5 @@ C_SRCS = \ topology.c IDL_SRCS = mf.idl + +RC_SRCS = mf.rc diff --git a/dlls/mf/mf.rc b/dlls/mf/mf.rc new file mode 100644 index 0000000..90297b0 --- /dev/null +++ b/dlls/mf/mf.rc @@ -0,0 +1,24 @@ +/* + * 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 "windef.h" + +LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL + +/* @makedep: mf.rgs */ +1 WINE_REGISTRY mf.rgs diff --git a/dlls/mf/mf.rgs b/dlls/mf/mf.rgs new file mode 100644 index 0000000..f127df7 --- /dev/null +++ b/dlls/mf/mf.rgs @@ -0,0 +1,19 @@ +HKLM +{ + NoRemove 'Software' + { + NoRemove 'Microsoft' + { + NoRemove 'Windows Media Foundation' + { + NoRemove 'SchemeHandlers' + { + 'file:' + { + val '{477ec299-1421-4bdd-971f-7ccb933f21ad}' = s 'File Scheme Handler' + } + } + } + } + } +}

1 0

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-commits May 2019