driver_gen.cpp revision d634c483bcbd564acd81dcf5d15fc5fa8ab410f4 
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
27namespace vulkan {
28namespace driver {
29
30namespace {
31
32// clang-format off
33
34VKAPI_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
43VKAPI_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
51VKAPI_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
60VKAPI_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
69VKAPI_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
78VKAPI_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
87VKAPI_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
96VKAPI_ATTR VkResult checkedGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) {
97    if (GetData(device).hook_extensions[ProcHook::KHR_shared_presentable_image]) {
98        return GetSwapchainStatusKHR(device, swapchain);
99    } else {
100        Logger(device).Err(device, "VK_KHR_shared_presentable_image not enabled. vkGetSwapchainStatusKHR not executed.");
101        return VK_SUCCESS;
102    }
103}
104
105VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
106    if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) {
107        SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
108    } else {
109        Logger(device).Err(device, "VK_EXT_hdr_metadata not enabled. vkSetHdrMetadataEXT not executed.");
110    }
111}
112
113// clang-format on
114
115const 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        "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
266        ProcHook::INSTANCE,
267        ProcHook::KHR_surface,
268        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceCapabilitiesKHR),
269        nullptr,
270    },
271    {
272        "vkGetPhysicalDeviceSurfaceFormatsKHR",
273        ProcHook::INSTANCE,
274        ProcHook::KHR_surface,
275        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceFormatsKHR),
276        nullptr,
277    },
278    {
279        "vkGetPhysicalDeviceSurfacePresentModesKHR",
280        ProcHook::INSTANCE,
281        ProcHook::KHR_surface,
282        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfacePresentModesKHR),
283        nullptr,
284    },
285    {
286        "vkGetPhysicalDeviceSurfaceSupportKHR",
287        ProcHook::INSTANCE,
288        ProcHook::KHR_surface,
289        reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR),
290        nullptr,
291    },
292    {
293        "vkGetRefreshCycleDurationGOOGLE",
294        ProcHook::DEVICE,
295        ProcHook::GOOGLE_display_timing,
296        reinterpret_cast<PFN_vkVoidFunction>(GetRefreshCycleDurationGOOGLE),
297        reinterpret_cast<PFN_vkVoidFunction>(checkedGetRefreshCycleDurationGOOGLE),
298    },
299    {
300        "vkGetSwapchainGrallocUsage2ANDROID",
301        ProcHook::DEVICE,
302        ProcHook::ANDROID_native_buffer,
303        nullptr,
304        nullptr,
305    },
306    {
307        "vkGetSwapchainGrallocUsageANDROID",
308        ProcHook::DEVICE,
309        ProcHook::ANDROID_native_buffer,
310        nullptr,
311        nullptr,
312    },
313    {
314        "vkGetSwapchainImagesKHR",
315        ProcHook::DEVICE,
316        ProcHook::KHR_swapchain,
317        reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR),
318        reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainImagesKHR),
319    },
320    {
321        "vkGetSwapchainStatusKHR",
322        ProcHook::DEVICE,
323        ProcHook::KHR_shared_presentable_image,
324        reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainStatusKHR),
325        reinterpret_cast<PFN_vkVoidFunction>(checkedGetSwapchainStatusKHR),
326    },
327    {
328        "vkQueuePresentKHR",
329        ProcHook::DEVICE,
330        ProcHook::KHR_swapchain,
331        reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR),
332        reinterpret_cast<PFN_vkVoidFunction>(checkedQueuePresentKHR),
333    },
334    {
335        "vkQueueSignalReleaseImageANDROID",
336        ProcHook::DEVICE,
337        ProcHook::ANDROID_native_buffer,
338        nullptr,
339        nullptr,
340    },
341    {
342        "vkSetHdrMetadataEXT",
343        ProcHook::DEVICE,
344        ProcHook::EXT_hdr_metadata,
345        reinterpret_cast<PFN_vkVoidFunction>(SetHdrMetadataEXT),
346        reinterpret_cast<PFN_vkVoidFunction>(checkedSetHdrMetadataEXT),
347    },
348    // clang-format on
349};
350
351}  // anonymous
352
353const ProcHook* GetProcHook(const char* name) {
354    const auto& begin = g_proc_hooks;
355    const auto& end =
356        g_proc_hooks + sizeof(g_proc_hooks) / sizeof(g_proc_hooks[0]);
357    const auto hook = std::lower_bound(
358        begin, end, name,
359        [](const ProcHook& e, const char* n) { return strcmp(e.name, n) < 0; });
360    return (hook < end && strcmp(hook->name, name) == 0) ? hook : nullptr;
361}
362
363ProcHook::Extension GetProcHookExtension(const char* name) {
364    // clang-format off
365    if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer;
366    if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report;
367    if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata;
368    if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing;
369    if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface;
370    if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present;
371    if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface;
372    if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain;
373    if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image;
374    // clang-format on
375    return ProcHook::EXTENSION_UNKNOWN;
376}
377
378#define UNLIKELY(expr) __builtin_expect((expr), 0)
379
380#define INIT_PROC(required, obj, proc)                                 \
381    do {                                                               \
382        data.driver.proc =                                             \
383            reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \
384        if (UNLIKELY(required && !data.driver.proc)) {                 \
385            ALOGE("missing " #obj " proc: vk" #proc);                  \
386            success = false;                                           \
387        }                                                              \
388    } while (0)
389
390#define INIT_PROC_EXT(ext, required, obj, proc) \
391    do {                                        \
392        if (extensions[ProcHook::ext])          \
393            INIT_PROC(required, obj, proc);     \
394    } while (0)
395
396bool InitDriverTable(VkInstance instance,
397                     PFN_vkGetInstanceProcAddr get_proc,
398                     const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
399    auto& data = GetData(instance);
400    bool success = true;
401
402    // clang-format off
403    INIT_PROC(true, instance, DestroyInstance);
404    INIT_PROC(true, instance, EnumeratePhysicalDevices);
405    INIT_PROC(true, instance, GetInstanceProcAddr);
406    INIT_PROC(true, instance, GetPhysicalDeviceProperties);
407    INIT_PROC(true, instance, CreateDevice);
408    INIT_PROC(true, instance, EnumerateDeviceExtensionProperties);
409    INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT);
410    INIT_PROC_EXT(EXT_debug_report, true, instance, DestroyDebugReportCallbackEXT);
411    INIT_PROC_EXT(EXT_debug_report, true, instance, DebugReportMessageEXT);
412    // clang-format on
413
414    return success;
415}
416
417bool InitDriverTable(VkDevice dev,
418                     PFN_vkGetDeviceProcAddr get_proc,
419                     const std::bitset<ProcHook::EXTENSION_COUNT>& extensions) {
420    auto& data = GetData(dev);
421    bool success = true;
422
423    // clang-format off
424    INIT_PROC(true, dev, GetDeviceProcAddr);
425    INIT_PROC(true, dev, DestroyDevice);
426    INIT_PROC(true, dev, GetDeviceQueue);
427    INIT_PROC(true, dev, CreateImage);
428    INIT_PROC(true, dev, DestroyImage);
429    INIT_PROC(true, dev, AllocateCommandBuffers);
430    INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsageANDROID);
431    INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID);
432    INIT_PROC_EXT(ANDROID_native_buffer, true, dev, AcquireImageANDROID);
433    INIT_PROC_EXT(ANDROID_native_buffer, true, dev, QueueSignalReleaseImageANDROID);
434    // clang-format on
435
436    return success;
437}
438
439}  // namespace driver
440}  // namespace vulkan
441
442// clang-format on
443