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
checkedGetRefreshCycleDurationGOOGLE(VkDevice device,VkSwapchainKHR swapchain,VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties)78 VKAPI_ATTR VkResult checkedGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
79 if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) {
80 return GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
81 } else {
82 Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetRefreshCycleDurationGOOGLE not executed.");
83 return VK_SUCCESS;
84 }
85 }
86
checkedGetPastPresentationTimingGOOGLE(VkDevice device,VkSwapchainKHR swapchain,uint32_t * pPresentationTimingCount,VkPastPresentationTimingGOOGLE * pPresentationTimings)87 VKAPI_ATTR VkResult checkedGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) {
88 if (GetData(device).hook_extensions[ProcHook::GOOGLE_display_timing]) {
89 return GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
90 } else {
91 Logger(device).Err(device, "VK_GOOGLE_display_timing not enabled. vkGetPastPresentationTimingGOOGLE not executed.");
92 return VK_SUCCESS;
93 }
94 }
95
checkedSetHdrMetadataEXT(VkDevice device,uint32_t swapchainCount,const VkSwapchainKHR * pSwapchains,const VkHdrMetadataEXT * pMetadata)96 VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
97 if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) {
98 SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
99 } else {
100 Logger(device).Err(device, "VK_EXT_hdr_metadata not enabled. vkSetHdrMetadataEXT not executed.");
101 }
102 }
103
checkedGetSwapchainStatusKHR(VkDevice device,VkSwapchainKHR swapchain)104 VKAPI_ATTR VkResult checkedGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
105 if (GetData(device).hook_extensions[ProcHook::KHR_shared_presentable_image]) {
106 return GetSwapchainStatusKHR(device, swapchain);
107 } else {
108 Logger(device).Err(device, "VK_KHR_shared_presentable_image not enabled. vkGetSwapchainStatusKHR not executed.");
109 return VK_SUCCESS;
110 }
111 }
112
113 // clang-format on
114
115 const ProcHook g_proc_hooks[] = {
116 // clang-format off
117 {
118 "vkAcquireImageANDROID",
119 ProcHook::DEVICE,
120 ProcHook::ANDROID_native_buffer,
121 nullptr,
122 nullptr,
123 },
124 {
125 "vkAcquireNextImageKHR",
126 ProcHook::DEVICE,
127 ProcHook::KHR_swapchain,
128 reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR),
129 reinterpret_cast<PFN_vkVoidFunction>(checkedAcquireNextImageKHR),
130 },
131 {
132 "vkAllocateCommandBuffers",
133 ProcHook::DEVICE,
134 ProcHook::EXTENSION_CORE,
135 reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers),
136 nullptr,
137 },
138 {
139 "vkCreateAndroidSurfaceKHR",
140 ProcHook::INSTANCE,
141 ProcHook::KHR_android_surface,
142 reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR),
143 nullptr,
144 },
145 {
146 "vkCreateDebugReportCallbackEXT",
147 ProcHook::INSTANCE,
148 ProcHook::EXT_debug_report,
149 reinterpret_cast<PFN_vkVoidFunction>(CreateDebugReportCallbackEXT),
150 nullptr,
151 },
152 {
153 "vkCreateDevice",
154 ProcHook::INSTANCE,
155 ProcHook::EXTENSION_CORE,
156 reinterpret_cast<PFN_vkVoidFunction>(CreateDevice),
157 nullptr,
158 },
159 {
160 "vkCreateInstance",
161 ProcHook::GLOBAL,
162 ProcHook::EXTENSION_CORE,
163 reinterpret_cast<PFN_vkVoidFunction>(CreateInstance),
164 nullptr,
165 },
166 {
167 "vkCreateSwapchainKHR",
168 ProcHook::DEVICE,
169 ProcHook::KHR_swapchain,
170 reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR),
171 reinterpret_cast<PFN_vkVoidFunction>(checkedCreateSwapchainKHR),
172 },
173 {
174 "vkDebugReportMessageEXT",
175 ProcHook::INSTANCE,
176 ProcHook::EXT_debug_report,
177 reinterpret_cast<PFN_vkVoidFunction>(DebugReportMessageEXT),
178 nullptr,
179 },
180 {
181 "vkDestroyDebugReportCallbackEXT",
182 ProcHook::INSTANCE,
183 ProcHook::EXT_debug_report,
184 reinterpret_cast<PFN_vkVoidFunction>(DestroyDebugReportCallbackEXT),
185 nullptr,
186 },
187 {
188 "vkDestroyDevice",
189 ProcHook::DEVICE,
190 ProcHook::EXTENSION_CORE,
191 reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice),
192 nullptr,
193 },
194 {
195 "vkDestroyInstance",
196 ProcHook::INSTANCE,
197 ProcHook::EXTENSION_CORE,
198 reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance),
199 nullptr,
200 },
201 {
202 "vkDestroySurfaceKHR",
203 ProcHook::INSTANCE,
204 ProcHook::KHR_surface,
205 reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR),
206 nullptr,
207 },
208 {
209 "vkDestroySwapchainKHR",
210 ProcHook::DEVICE,
211 ProcHook::KHR_swapchain,
212 reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR),
213 reinterpret_cast<PFN_vkVoidFunction>(checkedDestroySwapchainKHR),
214 },
215 {
216 "vkEnumerateDeviceExtensionProperties",
217 ProcHook::INSTANCE,
218 ProcHook::EXTENSION_CORE,
219 reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties),
220 nullptr,
221 },
222 {
223 "vkEnumerateInstanceExtensionProperties",
224 ProcHook::GLOBAL,
225 ProcHook::EXTENSION_CORE,
226 reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties),
227 nullptr,
228 },
229 {
230 "vkEnumeratePhysicalDevices",
231 ProcHook::INSTANCE,
232 ProcHook::EXTENSION_CORE,
233 reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices),
234 nullptr,
235 },
236 {
237 "vkGetDeviceProcAddr",
238 ProcHook::DEVICE,
239 ProcHook::EXTENSION_CORE,
240 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr),
241 nullptr,
242 },
243 {
244 "vkGetDeviceQueue",
245 ProcHook::DEVICE,
246 ProcHook::EXTENSION_CORE,
247 reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue),
248 nullptr,
249 },
250 {
251 "vkGetInstanceProcAddr",
252 ProcHook::INSTANCE,
253 ProcHook::EXTENSION_CORE,
254 reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr),
255 nullptr,
256 },
257 {
258 "vkGetPastPresentationTimingGOOGLE",
259 ProcHook::DEVICE,
260 ProcHook::GOOGLE_display_timing,
261 reinterpret_cast<PFN_vkVoidFunction>(GetPastPresentationTimingGOOGLE),
262 reinterpret_cast<PFN_vkVoidFunction>(checkedGetPastPresentationTimingGOOGLE),
263 },
264 {
265 "vkGetPhysicalDeviceSurfaceCapabilities2KHR",
266 ProcHook::INSTANCE,
267 ProcHook::KHR_get_surface_capabilities2,
268 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilities2KHR),
269 nullptr,
270 },
271 {
272 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
273 ProcHook::INSTANCE,
274 ProcHook::KHR_surface,
275 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR),
276 nullptr,
277 },
278 {
279 "vkGetPhysicalDeviceSurfaceFormats2KHR",
280 ProcHook::INSTANCE,
281 ProcHook::KHR_get_surface_capabilities2,
282 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormats2KHR),
283 nullptr,
284 },
285 {
286 "vkGetPhysicalDeviceSurfaceFormatsKHR",
287 ProcHook::INSTANCE,
288 ProcHook::KHR_surface,
289 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR),
290 nullptr,
291 },
292 {
293 "vkGetPhysicalDeviceSurfacePresentModesKHR",
294 ProcHook::INSTANCE,
295 ProcHook::KHR_surface,
296 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR),
297 nullptr,
298 },
299 {
300 "vkGetPhysicalDeviceSurfaceSupportKHR",
301 ProcHook::INSTANCE,
302 ProcHook::KHR_surface,
303 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR),
304 nullptr,
305 },
306 {
307 "vkGetRefreshCycleDurationGOOGLE",
308 ProcHook::DEVICE,
309 ProcHook::GOOGLE_display_timing,
310 reinterpret_cast<PFN_vkVoidFunction>(GetRefreshCycleDurationGOOGLE),
311 reinterpret_cast<PFN_vkVoidFunction>(checkedGetRefreshCycleDurationGOOGLE),
312 },
313 {
314 "vkGetSwapchainGrallocUsage2ANDROID",
315 ProcHook::DEVICE,
316 ProcHook::ANDROID_native_buffer,
317 nullptr,
318 nullptr,
319 },
320 {
321 "vkGetSwapchainGrallocUsageANDROID",
322 ProcHook::DEVICE,
323 ProcHook::ANDROID_native_buffer,
324 nullptr,
325 nullptr,
326 },
327 {
328 "vkGetSwapchainImagesKHR",
329 ProcHook::DEVICE,
330 ProcHook::KHR_swapchain,
331 reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR),
332 reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainImagesKHR),
333 },
334 {
335 "vkGetSwapchainStatusKHR",
336 ProcHook::DEVICE,
337 ProcHook::KHR_shared_presentable_image,
338 reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainStatusKHR),
339 reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainStatusKHR),
340 },
341 {
342 "vkQueuePresentKHR",
343 ProcHook::DEVICE,
344 ProcHook::KHR_swapchain,
345 reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR),
346 reinterpret_cast<PFN_vkVoidFunction>(checkedQueuePresentKHR),
347 },
348 {
349 "vkQueueSignalReleaseImageANDROID",
350 ProcHook::DEVICE,
351 ProcHook::ANDROID_native_buffer,
352 nullptr,
353 nullptr,
354 },
355 {
356 "vkSetHdrMetadataEXT",
357 ProcHook::DEVICE,
358 ProcHook::EXT_hdr_metadata,
359 reinterpret_cast<PFN_vkVoidFunction>(SetHdrMetadataEXT),
360 reinterpret_cast<PFN_vkVoidFunction>(checkedSetHdrMetadataEXT),
361 },
362 // clang-format on
363 };
364
365 } // namespace
366
GetProcHook(const char * name)367 const ProcHook* GetProcHook(const char* name) {
368 const auto& begin = g_proc_hooks;
369 const auto& end =
370 g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]);
371 const auto hook = std::lower_bound(
372 begin, end, name,
373 [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; });
374 return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr;
375 }
376
GetProcHookExtension(const char * name)377 ProcHook::Extension GetProcHookExtension(const char* name) {
378 // clang-format off
379 if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer;
380 if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report;
381 if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata;
382 if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace;
383 if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing;
384 if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface;
385 if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present;
386 if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image;
387 if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface;
388 if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain;
389 if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2;
390 if (strcmp(name, "VK_KHR_get_physical_device_properties2") == 0) return ProcHook::KHR_get_physical_device_properties2;
391 // clang-format on
392 return ProcHook::EXTENSION_UNKNOWN;
393 }
394
395 #define UNLIKELY(expr) __builtin_expect((expr), 0)
396
397 #define INIT_PROC(required, obj, proc) \
398 do { \
399 data.driver.proc = \
400 reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \
401 if (UNLIKELY(required && !data.driver.proc)) { \
402 ALOGE("missing " #obj " proc: vk" #proc); \
403 success = false; \
404 } \
405 } while (0)
406
407 #define INIT_PROC_EXT(ext, required, obj, proc) \
408 do { \
409 if (extensions[ProcHook::ext]) \
410 INIT_PROC(required, obj, proc); \
411 } while (0)
412
InitDriverTable(VkInstance instance,PFN_vkGetInstanceProcAddr get_proc,const std::bitset<ProcHook::EXTENSION_COUNT> & extensions)413 bool InitDriverTable(VkInstance instance,
414 PFN_vkGetInstanceProcAddr get_proc,
415 const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
416 auto& data = GetData(instance);
417 bool success = true;
418
419 // clang-format off
420 INIT_PROC(true, instance, DestroyInstance);
421 INIT_PROC(true, instance, EnumeratePhysicalDevices);
422 INIT_PROC(true, instance, GetInstanceProcAddr);
423 INIT_PROC(true, instance, GetPhysicalDeviceProperties);
424 INIT_PROC(true, instance, CreateDevice);
425 INIT_PROC(true, instance, EnumerateDeviceExtensionProperties);
426 INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT);
427 INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT);
428 INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT);
429 INIT_PROC_EXT(KHR_get_physical_device_properties2, true, instance, GetPhysicalDeviceProperties2KHR);
430 // clang-format on
431
432 return success;
433 }
434
InitDriverTable(VkDevice dev,PFN_vkGetDeviceProcAddr get_proc,const std::bitset<ProcHook::EXTENSION_COUNT> & extensions)435 bool InitDriverTable(VkDevice dev,
436 PFN_vkGetDeviceProcAddr get_proc,
437 const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
438 auto& data = GetData(dev);
439 bool success = true;
440
441 // clang-format off
442 INIT_PROC(true, dev, GetDeviceProcAddr);
443 INIT_PROC(true, dev, DestroyDevice);
444 INIT_PROC(true, dev, GetDeviceQueue);
445 INIT_PROC(true, dev, CreateImage);
446 INIT_PROC(true, dev, DestroyImage);
447 INIT_PROC(true, dev, AllocateCommandBuffers);
448 INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsageANDROID);
449 INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID);
450 INIT_PROC_EXT(ANDROID_native_buffer, true, dev, AcquireImageANDROID);
451 INIT_PROC_EXT(ANDROID_native_buffer, true, dev, QueueSignalReleaseImageANDROID);
452 // clang-format on
453
454 return success;
455 }
456
457 } // namespace driver
458 } // namespace vulkan
459
460 // clang-format on
461