1 /*
2 * Copyright 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 // WARNING: This file is generated. See ../README.md for instructions.
18
19 #include <string.h>
20
21 #include <algorithm>
22
23 #include <log/log.h>
24
25 #include "driver.h"
26
27 namespace vulkan {
28 namespace driver {
29
30 namespace {
31
32 // clang-format off
33
checkedCreateSwapchainKHR(VkDevice device,const VkSwapchainCreateInfoKHR * pCreateInfo,const VkAllocationCallbacks * pAllocator,VkSwapchainKHR * pSwapchain)34 VKAPI_ATTR VkResult checkedCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
35 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
36 return CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
37 } else {
38 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkCreateSwapchainKHR not executed.");
39 return VK_SUCCESS;
40 }
41 }
42
checkedDestroySwapchainKHR(VkDevice device,VkSwapchainKHR swapchain,const VkAllocationCallbacks * pAllocator)43 VKAPI_ATTR void checkedDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) {
44 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
45 DestroySwapchainKHR(device, swapchain, pAllocator);
46 } else {
47 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkDestroySwapchainKHR not executed.");
48 }
49 }
50
checkedGetSwapchainImagesKHR(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pSwapchainImageCount,VkImage * pSwapchainImages)51 VKAPI_ATTR VkResult checkedGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
52 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
53 return GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
54 } else {
55 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkGetSwapchainImagesKHR not executed.");
56 return VK_SUCCESS;
57 }
58 }
59
checkedAcquireNextImageKHR(VkDevice device,VkSwapchainKHR swapchain,uint64_t timeout,VkSemaphore semaphore,VkFence fence,uint32_t * pImageIndex)60 VKAPI_ATTR VkResult checkedAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) {
61 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
62 return AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
63 } else {
64 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkAcquireNextImageKHR not executed.");
65 return VK_SUCCESS;
66 }
67 }
68
checkedQueuePresentKHR(VkQueue queue,const VkPresentInfoKHR * pPresentInfo)69 VKAPI_ATTR VkResult checkedQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
70 if (GetData(queue).hook_extensions[ProcHook::KHR_swapchain]) {
71 return QueuePresentKHR(queue, pPresentInfo);
72 } else {
73 Logger(queue).Err(queue, "VK_KHR_swapchain not enabled. vkQueuePresentKHR not executed.");
74 return VK_SUCCESS;
75 }
76 }
77
checkedGetDeviceGroupPresentCapabilitiesKHR(VkDevice device,VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities)78 VKAPI_ATTR VkResult checkedGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
79 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
80 return GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
81 } else {
82 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkGetDeviceGroupPresentCapabilitiesKHR not executed.");
83 return VK_SUCCESS;
84 }
85 }
86
checkedGetDeviceGroupSurfacePresentModesKHR(VkDevice device,VkSurfaceKHR surface,VkDeviceGroupPresentModeFlagsKHR * pModes)87 VKAPI_ATTR VkResult checkedGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
88 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
89 return GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
90 } else {
91 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkGetDeviceGroupSurfacePresentModesKHR not executed.");
92 return VK_SUCCESS;
93 }
94 }
95
checkedAcquireNextImage2KHR(VkDevice device,const VkAcquireNextImageInfoKHR * pAcquireInfo,uint32_t * pImageIndex)96 VKAPI_ATTR VkResult checkedAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) {
97 if (GetData(device).hook_extensions[ProcHook::KHR_swapchain]) {
98 return AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
99 } else {
100 Logger(device).Err(device, "VK_KHR_swapchain not enabled. vkAcquireNextImage2KHR not executed.");
101 return VK_SUCCESS;
102 }
103 }
104
checkedGetRefreshCycleDurationGOOGLE(VkDevice device,VkSwapchainKHR swapchain,VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties)105 VKAPI_ATTR VkResult checkedGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
106 if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) {
107 return GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
108 } else {
109 Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetRefreshCycleDurationGOOGLE not executed.");
110 return VK_SUCCESS;
111 }
112 }
113
checkedGetPastPresentationTimingGOOGLE(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pPresentationTimingCount,VkPastPresentationTimingGOOGLE * pPresentationTimings)114 VKAPI_ATTR VkResult checkedGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {
115 if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) {
116 return GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
117 } else {
118 Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetPastPresentationTimingGOOGLE not executed.");
119 return VK_SUCCESS;
120 }
121 }
122
checkedSetHdrMetadataEXT(VkDevice device,uint32_t swapchainCount,const VkSwapchainKHR * pSwapchains,const VkHdrMetadataEXT * pMetadata)123 VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
124 if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) {
125 SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
126 } else {
127 Logger(device).Err(device, "VK_EXT_hdr_metadata not enabled. vkSetHdrMetadataEXT not executed.");
128 }
129 }
130
checkedGetSwapchainStatusKHR(VkDevice device,VkSwapchainKHR swapchain)131 VKAPI_ATTR VkResult checkedGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
132 if (GetData(device).hook_extensions[ProcHook::KHR_shared_presentable_image]) {
133 return GetSwapchainStatusKHR(device, swapchain);
134 } else {
135 Logger(device).Err(device, "VK_KHR_shared_presentable_image not enabled. vkGetSwapchainStatusKHR not executed.");
136 return VK_SUCCESS;
137 }
138 }
139
checkedBindImageMemory2KHR(VkDevice device,uint32_t bindInfoCount,const VkBindImageMemoryInfoKHR * pBindInfos)140 VKAPI_ATTR VkResult checkedBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) {
141 if (GetData(device).hook_extensions[ProcHook::KHR_bind_memory2]) {
142 return BindImageMemory2KHR(device, bindInfoCount, pBindInfos);
143 } else {
144 Logger(device).Err(device, "VK_KHR_bind_memory2 not enabled. vkBindImageMemory2KHR not executed.");
145 return VK_SUCCESS;
146 }
147 }
148
149 // clang-format on
150
151 const ProcHook g_proc_hooks[] = {
152 // clang-format off
153 {
154 "vkAcquireImageANDROID",
155 ProcHook::DEVICE,
156 ProcHook::ANDROID_native_buffer,
157 nullptr,
158 nullptr,
159 },
160 {
161 "vkAcquireNextImage2KHR",
162 ProcHook::DEVICE,
163 ProcHook::KHR_swapchain,
164 reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImage2KHR),
165 reinterpret_cast<PFN_vkVoidFunction>(checkedAcquireNextImage2KHR),
166 },
167 {
168 "vkAcquireNextImageKHR",
169 ProcHook::DEVICE,
170 ProcHook::KHR_swapchain,
171 reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR),
172 reinterpret_cast<PFN_vkVoidFunction>(checkedAcquireNextImageKHR),
173 },
174 {
175 "vkAllocateCommandBuffers",
176 ProcHook::DEVICE,
177 ProcHook::EXTENSION_CORE,
178 reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers),
179 nullptr,
180 },
181 {
182 "vkBindImageMemory2",
183 ProcHook::DEVICE,
184 ProcHook::EXTENSION_CORE,
185 reinterpret_cast<PFN_vkVoidFunction>(BindImageMemory2),
186 nullptr,
187 },
188 {
189 "vkBindImageMemory2KHR",
190 ProcHook::DEVICE,
191 ProcHook::KHR_bind_memory2,
192 reinterpret_cast<PFN_vkVoidFunction>(BindImageMemory2KHR),
193 reinterpret_cast<PFN_vkVoidFunction>(checkedBindImageMemory2KHR),
194 },
195 {
196 "vkCreateAndroidSurfaceKHR",
197 ProcHook::INSTANCE,
198 ProcHook::KHR_android_surface,
199 reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR),
200 nullptr,
201 },
202 {
203 "vkCreateDebugReportCallbackEXT",
204 ProcHook::INSTANCE,
205 ProcHook::EXT_debug_report,
206 reinterpret_cast<PFN_vkVoidFunction>(CreateDebugReportCallbackEXT),
207 nullptr,
208 },
209 {
210 "vkCreateDevice",
211 ProcHook::INSTANCE,
212 ProcHook::EXTENSION_CORE,
213 reinterpret_cast<PFN_vkVoidFunction>(CreateDevice),
214 nullptr,
215 },
216 {
217 "vkCreateInstance",
218 ProcHook::GLOBAL,
219 ProcHook::EXTENSION_CORE,
220 reinterpret_cast<PFN_vkVoidFunction>(CreateInstance),
221 nullptr,
222 },
223 {
224 "vkCreateSwapchainKHR",
225 ProcHook::DEVICE,
226 ProcHook::KHR_swapchain,
227 reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR),
228 reinterpret_cast<PFN_vkVoidFunction>(checkedCreateSwapchainKHR),
229 },
230 {
231 "vkDebugReportMessageEXT",
232 ProcHook::INSTANCE,
233 ProcHook::EXT_debug_report,
234 reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT),
235 nullptr,
236 },
237 {
238 "vkDestroyDebugReportCallbackEXT",
239 ProcHook::INSTANCE,
240 ProcHook::EXT_debug_report,
241 reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT),
242 nullptr,
243 },
244 {
245 "vkDestroyDevice",
246 ProcHook::DEVICE,
247 ProcHook::EXTENSION_CORE,
248 reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice),
249 nullptr,
250 },
251 {
252 "vkDestroyInstance",
253 ProcHook::INSTANCE,
254 ProcHook::EXTENSION_CORE,
255 reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance),
256 nullptr,
257 },
258 {
259 "vkDestroySurfaceKHR",
260 ProcHook::INSTANCE,
261 ProcHook::KHR_surface,
262 reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR),
263 nullptr,
264 },
265 {
266 "vkDestroySwapchainKHR",
267 ProcHook::DEVICE,
268 ProcHook::KHR_swapchain,
269 reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR),
270 reinterpret_cast<PFN_vkVoidFunction>(checkedDestroySwapchainKHR),
271 },
272 {
273 "vkEnumerateDeviceExtensionProperties",
274 ProcHook::INSTANCE,
275 ProcHook::EXTENSION_CORE,
276 reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties),
277 nullptr,
278 },
279 {
280 "vkEnumerateInstanceExtensionProperties",
281 ProcHook::GLOBAL,
282 ProcHook::EXTENSION_CORE,
283 reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties),
284 nullptr,
285 },
286 {
287 "vkEnumeratePhysicalDeviceGroups",
288 ProcHook::INSTANCE,
289 ProcHook::EXTENSION_CORE,
290 reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDeviceGroups),
291 nullptr,
292 },
293 {
294 "vkEnumeratePhysicalDevices",
295 ProcHook::INSTANCE,
296 ProcHook::EXTENSION_CORE,
297 reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices),
298 nullptr,
299 },
300 {
301 "vkGetDeviceGroupPresentCapabilitiesKHR",
302 ProcHook::DEVICE,
303 ProcHook::KHR_swapchain,
304 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceGroupPresentCapabilitiesKHR),
305 reinterpret_cast<PFN_vkVoidFunction>(checkedGetDeviceGroupPresentCapabilitiesKHR),
306 },
307 {
308 "vkGetDeviceGroupSurfacePresentModesKHR",
309 ProcHook::DEVICE,
310 ProcHook::KHR_swapchain,
311 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceGroupSurfacePresentModesKHR),
312 reinterpret_cast<PFN_vkVoidFunction>(checkedGetDeviceGroupSurfacePresentModesKHR),
313 },
314 {
315 "vkGetDeviceProcAddr",
316 ProcHook::DEVICE,
317 ProcHook::EXTENSION_CORE,
318 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr),
319 nullptr,
320 },
321 {
322 "vkGetDeviceQueue",
323 ProcHook::DEVICE,
324 ProcHook::EXTENSION_CORE,
325 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue),
326 nullptr,
327 },
328 {
329 "vkGetDeviceQueue2",
330 ProcHook::DEVICE,
331 ProcHook::EXTENSION_CORE,
332 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue2),
333 nullptr,
334 },
335 {
336 "vkGetInstanceProcAddr",
337 ProcHook::INSTANCE,
338 ProcHook::EXTENSION_CORE,
339 reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr),
340 nullptr,
341 },
342 {
343 "vkGetPastPresentationTimingGOOGLE",
344 ProcHook::DEVICE,
345 ProcHook::GOOGLE_display_timing,
346 reinterpret_cast<PFN_vkVoidFunction>(GetPastPresentationTimingGOOGLE),
347 reinterpret_cast<PFN_vkVoidFunction>(checkedGetPastPresentationTimingGOOGLE),
348 },
349 {
350 "vkGetPhysicalDevicePresentRectanglesKHR",
351 ProcHook::INSTANCE,
352 ProcHook::KHR_swapchain,
353 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDevicePresentRectanglesKHR),
354 nullptr,
355 },
356 {
357 "vkGetPhysicalDeviceSurfaceCapabilities2KHR",
358 ProcHook::INSTANCE,
359 ProcHook::KHR_get_surface_capabilities2,
360 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilities2KHR),
361 nullptr,
362 },
363 {
364 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
365 ProcHook::INSTANCE,
366 ProcHook::KHR_surface,
367 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR),
368 nullptr,
369 },
370 {
371 "vkGetPhysicalDeviceSurfaceFormats2KHR",
372 ProcHook::INSTANCE,
373 ProcHook::KHR_get_surface_capabilities2,
374 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormats2KHR),
375 nullptr,
376 },
377 {
378 "vkGetPhysicalDeviceSurfaceFormatsKHR",
379 ProcHook::INSTANCE,
380 ProcHook::KHR_surface,
381 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR),
382 nullptr,
383 },
384 {
385 "vkGetPhysicalDeviceSurfacePresentModesKHR",
386 ProcHook::INSTANCE,
387 ProcHook::KHR_surface,
388 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR),
389 nullptr,
390 },
391 {
392 "vkGetPhysicalDeviceSurfaceSupportKHR",
393 ProcHook::INSTANCE,
394 ProcHook::KHR_surface,
395 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR),
396 nullptr,
397 },
398 {
399 "vkGetRefreshCycleDurationGOOGLE",
400 ProcHook::DEVICE,
401 ProcHook::GOOGLE_display_timing,
402 reinterpret_cast<PFN_vkVoidFunction>(GetRefreshCycleDurationGOOGLE),
403 reinterpret_cast<PFN_vkVoidFunction>(checkedGetRefreshCycleDurationGOOGLE),
404 },
405 {
406 "vkGetSwapchainGrallocUsage2ANDROID",
407 ProcHook::DEVICE,
408 ProcHook::ANDROID_native_buffer,
409 nullptr,
410 nullptr,
411 },
412 {
413 "vkGetSwapchainGrallocUsageANDROID",
414 ProcHook::DEVICE,
415 ProcHook::ANDROID_native_buffer,
416 nullptr,
417 nullptr,
418 },
419 {
420 "vkGetSwapchainImagesKHR",
421 ProcHook::DEVICE,
422 ProcHook::KHR_swapchain,
423 reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR),
424 reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainImagesKHR),
425 },
426 {
427 "vkGetSwapchainStatusKHR",
428 ProcHook::DEVICE,
429 ProcHook::KHR_shared_presentable_image,
430 reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainStatusKHR),
431 reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainStatusKHR),
432 },
433 {
434 "vkQueuePresentKHR",
435 ProcHook::DEVICE,
436 ProcHook::KHR_swapchain,
437 reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR),
438 reinterpret_cast<PFN_vkVoidFunction>(checkedQueuePresentKHR),
439 },
440 {
441 "vkQueueSignalReleaseImageANDROID",
442 ProcHook::DEVICE,
443 ProcHook::ANDROID_native_buffer,
444 nullptr,
445 nullptr,
446 },
447 {
448 "vkSetHdrMetadataEXT",
449 ProcHook::DEVICE,
450 ProcHook::EXT_hdr_metadata,
451 reinterpret_cast<PFN_vkVoidFunction>(SetHdrMetadataEXT),
452 reinterpret_cast<PFN_vkVoidFunction>(checkedSetHdrMetadataEXT),
453 },
454 // clang-format on
455 };
456
457 } // namespace
458
GetProcHook(const char * name)459 const ProcHook* GetProcHook(const char* name) {
460 const auto& begin = g_proc_hooks;
461 const auto& end =
462 g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]);
463 const auto hook = std::lower_bound(
464 begin, end, name,
465 [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; });
466 return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr;
467 }
468
GetProcHookExtension(const char * name)469 ProcHook::Extension GetProcHookExtension(const char* name) {
470 // clang-format off
471 if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer;
472 if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report;
473 if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata;
474 if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace;
475 if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing;
476 if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface;
477 if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present;
478 if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image;
479 if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface;
480 if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain;
481 if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2;
482 if (strcmp(name, "VK_KHR_get_physical_device_properties2") == 0) return ProcHook::KHR_get_physical_device_properties2;
483 if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer;
484 if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2;
485 // clang-format on
486 return ProcHook::EXTENSION_UNKNOWN;
487 }
488
489 #define UNLIKELY(expr) __builtin_expect((expr), 0)
490
491 #define INIT_PROC(required, obj, proc) \
492 do { \
493 data.driver.proc = \
494 reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \
495 if (UNLIKELY(required && !data.driver.proc)) { \
496 ALOGE("missing " #obj " proc: vk" #proc); \
497 success = false; \
498 } \
499 } while (0)
500
501 #define INIT_PROC_EXT(ext, required, obj, proc) \
502 do { \
503 if (extensions[ProcHook::ext]) \
504 INIT_PROC(required, obj, proc); \
505 } while (0)
506
InitDriverTable(VkInstance instance,PFN_vkGetInstanceProcAddr get_proc,const std::bitset<ProcHook::EXTENSION_COUNT> & extensions)507 bool InitDriverTable(VkInstance instance,
508 PFN_vkGetInstanceProcAddr get_proc,
509 const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
510 auto& data = GetData(instance);
511 bool success = true;
512
513 // clang-format off
514 INIT_PROC(true, instance, DestroyInstance);
515 INIT_PROC(true, instance, EnumeratePhysicalDevices);
516 INIT_PROC(true, instance, GetInstanceProcAddr);
517 INIT_PROC(true, instance, GetPhysicalDeviceProperties);
518 INIT_PROC(true, instance, CreateDevice);
519 INIT_PROC(true, instance, EnumerateDeviceExtensionProperties);
520 INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups);
521 INIT_PROC(false, instance, GetPhysicalDeviceProperties2);
522 INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT);
523 INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT);
524 INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT);
525 INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceProperties2KHR);
526 // clang-format on
527
528 return success;
529 }
530
InitDriverTable(VkDevice dev,PFN_vkGetDeviceProcAddr get_proc,const std::bitset<ProcHook::EXTENSION_COUNT> & extensions)531 bool InitDriverTable(VkDevice dev,
532 PFN_vkGetDeviceProcAddr get_proc,
533 const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
534 auto& data = GetData(dev);
535 bool success = true;
536
537 // clang-format off
538 INIT_PROC(true, dev, GetDeviceProcAddr);
539 INIT_PROC(true, dev, DestroyDevice);
540 INIT_PROC(true, dev, GetDeviceQueue);
541 INIT_PROC(true, dev, CreateImage);
542 INIT_PROC(true, dev, DestroyImage);
543 INIT_PROC(true, dev, AllocateCommandBuffers);
544 INIT_PROC(false, dev, BindImageMemory2);
545 INIT_PROC(false, dev, GetDeviceQueue2);
546 INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsageANDROID);
547 INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID);
548 INIT_PROC_EXT(ANDROID_native_buffer, true, dev, AcquireImageANDROID);
549 INIT_PROC_EXT(ANDROID_native_buffer, true, dev, QueueSignalReleaseImageANDROID);
550 INIT_PROC_EXT(KHR_bind_memory2, true, dev, BindImageMemory2KHR);
551 // clang-format on
552
553 return success;
554 }
555
556 } // namespace driver
557 } // namespace vulkan
558
559 // clang-format on
560