1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
/*
* This file is part of libplacebo.
*
* libplacebo 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.
*
* libplacebo 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 libplacebo. If not, see <http://www.gnu.org/licenses/>.
*/
#include "utils.h"
VkExternalMemoryHandleTypeFlagBitsKHR
vk_mem_handle_type(enum pl_handle_type handle_type)
{
if (!handle_type)
return 0;
switch (handle_type) {
case PL_HANDLE_FD:
return VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
case PL_HANDLE_WIN32:
return VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR;
case PL_HANDLE_WIN32_KMT:
return VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR;
case PL_HANDLE_DMA_BUF:
return VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
case PL_HANDLE_HOST_PTR:
return VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
case PL_HANDLE_MTL_TEX:
case PL_HANDLE_IOSURFACE:
return 0;
}
pl_unreachable();
}
VkExternalSemaphoreHandleTypeFlagBitsKHR
vk_sync_handle_type(enum pl_handle_type handle_type)
{
if (!handle_type)
return 0;
switch (handle_type) {
case PL_HANDLE_FD:
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
case PL_HANDLE_WIN32:
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR;
case PL_HANDLE_WIN32_KMT:
return VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR;
case PL_HANDLE_DMA_BUF:
case PL_HANDLE_HOST_PTR:
case PL_HANDLE_MTL_TEX:
case PL_HANDLE_IOSURFACE:
return 0;
}
pl_unreachable();
}
bool vk_external_mem_check(struct vk_ctx *vk,
const VkExternalMemoryPropertiesKHR *props,
enum pl_handle_type handle_type,
bool import)
{
VkExternalMemoryFeatureFlagsKHR flags = props->externalMemoryFeatures;
VkExternalMemoryHandleTypeFlagBitsKHR vk_handle = vk_mem_handle_type(handle_type);
if (import) {
if (!(flags & VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)) {
PL_DEBUG(vk, "Handle type %s (0x%x) is not importable",
vk_handle_name(vk_handle), (unsigned int) handle_type);
return false;
}
} else {
if (!(flags & VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR)) {
PL_DEBUG(vk, "Handle type %s (0x%x) is not exportable",
vk_handle_name(vk_handle), (unsigned int) handle_type);
return false;
}
}
return true;
}
const enum pl_handle_type vk_mem_handle_list[] = {
PL_HANDLE_HOST_PTR,
#ifdef PL_HAVE_UNIX
PL_HANDLE_FD,
PL_HANDLE_DMA_BUF,
#endif
#ifdef PL_HAVE_WIN32
PL_HANDLE_WIN32,
PL_HANDLE_WIN32_KMT,
#endif
0
};
const enum pl_handle_type vk_sync_handle_list[] = {
#ifdef PL_HAVE_UNIX
PL_HANDLE_FD,
#endif
#ifdef PL_HAVE_WIN32
PL_HANDLE_WIN32,
PL_HANDLE_WIN32_KMT,
#endif
0
};
const void *vk_find_struct(const void *chain, VkStructureType stype)
{
const VkBaseInStructure *in = chain;
while (in) {
if (in->sType == stype)
return in;
in = in->pNext;
}
return NULL;
}
void vk_link_struct(void *chain, const void *in)
{
if (!in)
return;
VkBaseOutStructure *out = chain;
while (out->pNext)
out = out->pNext;
out->pNext = (void *) in;
}
void *vk_struct_memdup(void *alloc, const void *pin)
{
if (!pin)
return NULL;
const VkBaseInStructure *in = pin;
size_t size = vk_struct_size(in->sType);
pl_assert(size);
VkBaseOutStructure *out = pl_memdup(alloc, in, size);
out->pNext = NULL;
return out;
}
void *vk_chain_memdup(void *alloc, const void *pin)
{
if (!pin)
return NULL;
const VkBaseInStructure *in = pin;
VkBaseOutStructure *out = vk_struct_memdup(alloc, in);
pl_assert(out);
out->pNext = vk_chain_memdup(alloc, in->pNext);
return out;
}
void *vk_chain_alloc(void *alloc, void *chain, VkStructureType stype)
{
for (VkBaseOutStructure *out = chain;; out = out->pNext) {
if (out->sType == stype)
return out;
if (!out->pNext) {
VkBaseOutStructure *s = pl_zalloc(alloc, vk_struct_size(stype));
s->sType = stype;
out->pNext = s;
return s;
}
}
}
|
