blob: c7f1ca0fee54dfb10cd6dc2f700091b7b0947596 [file] [log] [blame]
Mark Lobodzinski6eda00a2016-02-02 15:55:36 -07001/* Copyright (c) 2015-2016 The Khronos Group Inc.
2 * Copyright (c) 2015-2016 Valve Corporation
3 * Copyright (c) 2015-2016 LunarG, Inc.
4 * Copyright (C) 2015-2016 Google Inc.
Ian Elliott0b4d6242015-09-22 10:51:24 -06005 *
Jon Ashburn3ebf1252016-04-19 11:30:31 -06006 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
Ian Elliott0b4d6242015-09-22 10:51:24 -06009 *
Jon Ashburn3ebf1252016-04-19 11:30:31 -060010 * http://www.apache.org/licenses/LICENSE-2.0
Ian Elliott0b4d6242015-09-22 10:51:24 -060011 *
Jon Ashburn3ebf1252016-04-19 11:30:31 -060012 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
Ian Elliott0b4d6242015-09-22 10:51:24 -060017 *
Courtney Goeltzenleuchter05559522015-10-30 11:14:30 -060018 * Author: Ian Elliott <ian@lunarg.com>
Ian Elliott578e7e22016-01-05 14:03:16 -070019 * Author: Ian Elliott <ianelliott@google.com>
Ian Elliott0b4d6242015-09-22 10:51:24 -060020 */
21
Mike Weiblen6a27de52016-12-09 17:36:28 -070022// For Windows, this #include must come before other Vk headers.
23#include <vk_loader_platform.h>
24
25#include "swapchain.h"
26#include "vk_enum_string_helper.h"
27#include "vk_layer_extension_utils.h"
28#include "vk_layer_utils.h"
29#include "vk_validation_error_messages.h"
Jeremy Hayes9de0bd72016-04-13 11:57:20 -060030#include <mutex>
Ian Elliottd8c5db12015-10-07 11:32:31 -060031#include <stdio.h>
32#include <string.h>
Cody Northropd08141b2016-02-01 09:52:07 -070033#include <vulkan/vk_icd.h>
Ian Elliott68124ac2015-10-07 16:18:35 -060034
Chia-I Wu516b5082016-04-28 11:27:46 +080035namespace swapchain {
36
Jeremy Hayes9de0bd72016-04-13 11:57:20 -060037static std::mutex global_lock;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -070038
Ian Elliott0b4d6242015-09-22 10:51:24 -060039// The following is for logging error messages:
Ian Elliott68124ac2015-10-07 16:18:35 -060040static std::unordered_map<void *, layer_data *> layer_data_map;
Ian Elliott0b4d6242015-09-22 10:51:24 -060041
Jon Ashburn5484e0c2016-03-08 17:48:44 -070042static const VkExtensionProperties instance_extensions[] = {{VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}};
Courtney Goeltzenleuchter52857662015-12-01 14:08:28 -070043
Chia-I Wu40e25e72016-04-28 14:12:27 +080044static const VkLayerProperties swapchain_layer = {
Jon Ashburndc9111c2016-03-22 12:57:13 -060045 "VK_LAYER_LUNARG_swapchain", VK_LAYER_API_VERSION, 1, "LunarG Validation Layer",
Chia-I Wu40e25e72016-04-28 14:12:27 +080046};
Courtney Goeltzenleuchter52857662015-12-01 14:08:28 -070047
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -060048static void checkDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -070049 layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -070050 layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Ian Elliott0b4d6242015-09-22 10:51:24 -060051
Ian Elliott77f46ca2016-05-05 14:10:49 -060052 SwpPhysicalDevice *pPhysicalDevice = NULL;
53 {
54 auto it = my_instance_data->physicalDeviceMap.find(physicalDevice);
55 pPhysicalDevice = (it == my_instance_data->physicalDeviceMap.end()) ? NULL : &it->second;
56 }
Ian Elliott0b4d6242015-09-22 10:51:24 -060057 if (pPhysicalDevice) {
Mark Lobodzinski55cd49b2015-11-27 15:23:23 -070058 my_device_data->deviceMap[device].pPhysicalDevice = pPhysicalDevice;
59 pPhysicalDevice->pDevice = &my_device_data->deviceMap[device];
Ian Elliott0b4d6242015-09-22 10:51:24 -060060 } else {
Ian Elliott07adb112016-01-05 12:51:03 -070061 // TBD: Should we leave error in (since Swapchain really needs this
62 // link)?
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -070063 log_msg(my_instance_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
Mike Weiblen6a27de52016-12-09 17:36:28 -070064 reinterpret_cast<uint64_t>(physicalDevice), __LINE__, VALIDATION_ERROR_00031, "Swapchain",
65 "vkCreateDevice() called with a non-valid VkPhysicalDevice. %s", validation_error_map[VALIDATION_ERROR_00031]);
Ian Elliott0b4d6242015-09-22 10:51:24 -060066 }
Mark Lobodzinski55cd49b2015-11-27 15:23:23 -070067 my_device_data->deviceMap[device].device = device;
Ian Elliott0b4d6242015-09-22 10:51:24 -060068}
69
Mark Youngaa1aa3a2016-07-05 16:41:50 -060070static void checkInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) {
Ian Elliott0b4d6242015-09-22 10:51:24 -060071 uint32_t i;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -070072 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Ian Elliott0b4d6242015-09-22 10:51:24 -060073
Ian Elliott1dcd1092015-11-17 17:29:40 -070074 // Remember this instance, and whether the VK_KHR_surface extension
Ian Elliott0b4d6242015-09-22 10:51:24 -060075 // was enabled for it:
Tobin Ehlis711ff312015-10-29 12:58:13 -060076 my_data->instanceMap[instance].instance = instance;
Petros Bantolas2b40be72016-04-15 11:02:59 +010077 my_data->instanceMap[instance].displayExtensionEnabled = false;
Ian Elliott8dffaf32016-01-04 14:10:30 -070078
Ian Elliotted6b5ac2016-04-28 09:08:13 -060079 // Look for one or more debug report create info structures, and copy the
80 // callback(s) for each one found (for use by vkDestroyInstance)
81 layer_copy_tmp_callbacks(pCreateInfo->pNext, &my_data->num_tmp_callbacks, &my_data->tmp_dbg_create_infos,
82 &my_data->tmp_callbacks);
83
Ian Elliott0b4d6242015-09-22 10:51:24 -060084 // Record whether the WSI instance extension was enabled for this
85 // VkInstance. No need to check if the extension was advertised by
86 // vkEnumerateInstanceExtensionProperties(), since the loader handles that.
Jon Ashburnf19916e2016-01-11 13:12:43 -070087 for (i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
Petros Bantolas2b40be72016-04-15 11:02:59 +010088 if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_DISPLAY_EXTENSION_NAME) == 0) {
89
90 my_data->instanceMap[instance].displayExtensionEnabled = true;
91 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -070092 }
93}
94
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -070095#include "vk_dispatch_table_helper.h"
Mark Lobodzinski1079e1b2016-03-15 14:21:59 -060096static void init_swapchain(layer_data *my_data, const VkAllocationCallbacks *pAllocator) {
Ian Elliott0b4d6242015-09-22 10:51:24 -060097
Mark Lobodzinski1079e1b2016-03-15 14:21:59 -060098 layer_debug_actions(my_data->report_data, my_data->logging_callback, pAllocator, "lunarg_swapchain");
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -070099}
Ian Elliott0b4d6242015-09-22 10:51:24 -0600100
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700101static const char *presentModeStr(VkPresentModeKHR value) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700102 // Return a string corresponding to the value:
103 return string_VkPresentModeKHR(value);
104}
Ian Elliott0b4d6242015-09-22 10:51:24 -0600105
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700106static const char *sharingModeStr(VkSharingMode value) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700107 // Return a string corresponding to the value:
108 return string_VkSharingMode(value);
109}
Ian Elliott07adb112016-01-05 12:51:03 -0700110
Mike Weiblen6a27de52016-12-09 17:36:28 -0700111// TODO This overload is only preserved for validateCreateSwapchainKHR(), which doesn't have a VU msgCode defined yet.
112// When a VU msgCode is defined, this overload can be deleted, and the latter form used instead.
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600113static bool ValidateQueueFamilyIndex(layer_data *my_data, uint32_t queue_family_index, uint32_t queue_family_count,
114 VkPhysicalDevice physical_device, const char *function) {
115 bool skip_call = false;
116 if (queue_family_index >= queue_family_count) {
117 skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600118 reinterpret_cast<uint64_t>(physical_device), __LINE__, SWAPCHAIN_QUEUE_FAMILY_INDEX_TOO_LARGE,
119 swapchain_layer_name,
120 "%s() called with a queueFamilyIndex that is too large (i.e. %d). The maximum value (returned by "
121 "vkGetPhysicalDeviceQueueFamilyProperties) is only %d.",
122 function, queue_family_index, queue_family_count);
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600123 }
124 return skip_call;
125}
126
Mike Weiblen6a27de52016-12-09 17:36:28 -0700127static bool ValidateQueueFamilyIndex(layer_data *my_data, uint32_t queue_family_index, uint32_t queue_family_count,
128 VkPhysicalDevice physical_device, const char *function,
129 /*enum*/ UNIQUE_VALIDATION_ERROR_CODE msgCode) {
130 bool skip_call = false;
131 if (queue_family_index >= queue_family_count) {
132 skip_call = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
133 reinterpret_cast<uint64_t>(physical_device), __LINE__, msgCode, swapchain_layer_name,
134 "%s() called with a queueFamilyIndex that is too large (i.e. %d). The maximum value (returned by "
135 "vkGetPhysicalDeviceQueueFamilyProperties) is only %d. %s",
136 function, queue_family_index, queue_family_count, validation_error_map[msgCode]);
137 }
138 return skip_call;
139}
140
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600141VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
142 VkInstance *pInstance) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700143 VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
Ian Elliott0b4d6242015-09-22 10:51:24 -0600144
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700145 assert(chain_info->u.pLayerInfo);
146 PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700147 PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700148 if (fpCreateInstance == NULL) {
149 return VK_ERROR_INITIALIZATION_FAILED;
150 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700151
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700152 // Advance the link info for the next element on the chain
153 chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700154
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700155 VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
156 if (result != VK_SUCCESS) {
157 return result;
158 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700159
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700160 layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
Chia-I Wua6737532016-04-28 16:04:15 +0800161 my_data->instance = *pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700162 my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable;
163 layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr);
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700164
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700165 my_data->report_data = debug_report_create_instance(my_data->instance_dispatch_table, *pInstance,
166 pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames);
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700167
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700168 // Call the following function after my_data is initialized:
Mark Youngaa1aa3a2016-07-05 16:41:50 -0600169 checkInstanceRegisterExtensions(pCreateInfo, *pInstance);
Mark Lobodzinski1079e1b2016-03-15 14:21:59 -0600170 init_swapchain(my_data, pAllocator);
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700171
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700172 return result;
173}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700174
Chia-I Wufccbfe42016-04-28 14:01:30 +0800175VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700176 dispatch_key key = get_dispatch_key(instance);
177 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600178 SwpInstance *pInstance = NULL;
179 {
180 auto it = my_data->instanceMap.find(instance);
181 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
182 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700183
Ian Elliott32311832016-02-04 08:17:18 -0700184 // Call down the call chain:
185 my_data->instance_dispatch_table->DestroyInstance(instance, pAllocator);
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700186
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600187 std::lock_guard<std::mutex> lock(global_lock);
Ian Elliott32311832016-02-04 08:17:18 -0700188
Ian Elliotted6b5ac2016-04-28 09:08:13 -0600189 // Enable the temporary callback(s) here to catch cleanup issues:
190 bool callback_setup = false;
191 if (my_data->num_tmp_callbacks > 0) {
192 if (!layer_enable_tmp_callbacks(my_data->report_data, my_data->num_tmp_callbacks, my_data->tmp_dbg_create_infos,
193 my_data->tmp_callbacks)) {
194 callback_setup = true;
195 }
196 }
197
Ian Elliott32311832016-02-04 08:17:18 -0700198 // Do additional internal cleanup:
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700199 if (pInstance) {
200 // Delete all of the SwpPhysicalDevice's, SwpSurface's, and the
201 // SwpInstance associated with this instance:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700202 for (auto it = pInstance->physicalDevices.begin(); it != pInstance->physicalDevices.end(); it++) {
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700203
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700204 // Free memory that was allocated for/by this SwpPhysicalDevice:
205 SwpPhysicalDevice *pPhysicalDevice = it->second;
206 if (pPhysicalDevice) {
Ian Elliott458696a2016-02-04 06:11:17 -0700207 if (pPhysicalDevice->pDevice) {
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600208 log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700209 reinterpret_cast<uint64_t>(pPhysicalDevice->pDevice->device), __LINE__, VALIDATION_ERROR_00018,
210 swapchain_layer_name,
211 "VkDestroyInstance() called before all of its associated VkDevices were destroyed. %s",
212 validation_error_map[VALIDATION_ERROR_00018]);
Ian Elliott458696a2016-02-04 06:11:17 -0700213 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700214 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700215
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700216 // Erase the SwpPhysicalDevice's from the my_data->physicalDeviceMap (which
217 // are simply pointed to by the SwpInstance):
218 my_data->physicalDeviceMap.erase(it->second->physicalDevice);
219 }
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700220 for (auto it = pInstance->surfaces.begin(); it != pInstance->surfaces.end(); it++) {
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700221
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700222 // Free memory that was allocated for/by this SwpPhysicalDevice:
223 SwpSurface *pSurface = it->second;
224 if (pSurface) {
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600225 log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700226 reinterpret_cast<uint64_t>(pInstance->instance), __LINE__, VALIDATION_ERROR_00018, swapchain_layer_name,
227 "VkDestroyInstance() called before all of its associated VkSurfaceKHRs were destroyed. %s",
228 validation_error_map[VALIDATION_ERROR_00018]);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700229 }
230 }
231 my_data->instanceMap.erase(instance);
232 }
Mark Lobodzinski3c99d552016-02-04 13:50:23 -0700233
Ian Elliotted6b5ac2016-04-28 09:08:13 -0600234 // Disable and cleanup the temporary callback(s):
235 if (callback_setup) {
236 layer_disable_tmp_callbacks(my_data->report_data, my_data->num_tmp_callbacks, my_data->tmp_callbacks);
237 }
238 if (my_data->num_tmp_callbacks > 0) {
239 layer_free_tmp_callbacks(my_data->tmp_dbg_create_infos, my_data->tmp_callbacks);
240 my_data->num_tmp_callbacks = 0;
241 }
242
Mark Lobodzinski3c99d552016-02-04 13:50:23 -0700243 // Clean up logging callback, if any
244 while (my_data->logging_callback.size() > 0) {
245 VkDebugReportCallbackEXT callback = my_data->logging_callback.back();
246 layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
247 my_data->logging_callback.pop_back();
248 }
249 layer_debug_report_destroy_instance(my_data->report_data);
250
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700251 delete my_data->instance_dispatch_table;
252 layer_data_map.erase(key);
253}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700254
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600255VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
256 uint32_t *pQueueFamilyPropertyCount,
257 VkQueueFamilyProperties *pQueueFamilyProperties) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700258 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Ian Elliott32311832016-02-04 08:17:18 -0700259
260 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700261 my_data->instance_dispatch_table->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
262 pQueueFamilyProperties);
Ian Elliott32311832016-02-04 08:17:18 -0700263
264 // Record the result of this query:
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600265 std::lock_guard<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600266 SwpPhysicalDevice *pPhysicalDevice = NULL;
267 {
268 auto it = my_data->physicalDeviceMap.find(physicalDevice);
269 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
270 }
Ian Elliotta2bb0e02016-08-24 11:30:45 -0600271 // Note: for poorly-written applications (e.g. that don't call this command
272 // twice, the first time with pQueueFamilyProperties set to NULL, and the
273 // second time with a non-NULL pQueueFamilyProperties and with the same
274 // count as returned the first time), record the count when
275 // pQueueFamilyProperties is non-NULL:
276 if (pPhysicalDevice && pQueueFamilyPropertyCount && pQueueFamilyProperties) {
Ian Elliott32311832016-02-04 08:17:18 -0700277 pPhysicalDevice->gotQueueFamilyPropertyCount = true;
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700278 pPhysicalDevice->numOfQueueFamilies = *pQueueFamilyPropertyCount;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700279 }
280}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700281
282#ifdef VK_USE_PLATFORM_ANDROID_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600283VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
284 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700285 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600286 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700287 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600288 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600289 SwpInstance *pInstance = NULL;
290 {
291 auto it = my_data->instanceMap.find(instance);
292 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
293 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700294
Ian Elliott970a2bd2016-06-21 11:08:43 -0600295 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700296
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600297 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700298 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700299 result = my_data->instance_dispatch_table->CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600300 lock.lock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700301
Ian Elliott32311832016-02-04 08:17:18 -0700302 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600303 {
304 auto it = my_data->instanceMap.find(instance);
305 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
306 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700307 if ((result == VK_SUCCESS) && pInstance && pSurface) {
308 // Record the VkSurfaceKHR returned by the ICD:
309 my_data->surfaceMap[*pSurface].surface = *pSurface;
310 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700311 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
312 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
313 // Point to the associated SwpInstance:
314 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
315 }
Ian Elliott970a2bd2016-06-21 11:08:43 -0600316 lock.unlock();
317
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700318 return result;
319 }
320 return VK_ERROR_VALIDATION_FAILED_EXT;
321}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700322#endif // VK_USE_PLATFORM_ANDROID_KHR
323
324#ifdef VK_USE_PLATFORM_MIR_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600325VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(VkInstance instance, const VkMirSurfaceCreateInfoKHR *pCreateInfo,
326 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700327 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600328 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700329 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600330 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600331 SwpInstance *pInstance = NULL;
332 {
333 auto it = my_data->instanceMap.find(instance);
334 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
335 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700336
Ian Elliott970a2bd2016-06-21 11:08:43 -0600337 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700338
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600339 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700340 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700341 result = my_data->instance_dispatch_table->CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600342 lock.lock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700343
Ian Elliott32311832016-02-04 08:17:18 -0700344 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600345 {
346 auto it = my_data->instanceMap.find(instance);
347 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
348 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700349 if ((result == VK_SUCCESS) && pInstance && pSurface) {
350 // Record the VkSurfaceKHR returned by the ICD:
351 my_data->surfaceMap[*pSurface].surface = *pSurface;
352 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700353 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
354 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
355 // Point to the associated SwpInstance:
356 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
357 }
Ian Elliott970a2bd2016-06-21 11:08:43 -0600358 lock.unlock();
359
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700360 return result;
361 }
362 return VK_ERROR_VALIDATION_FAILED_EXT;
363}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700364
Chia-I Wufccbfe42016-04-28 14:01:30 +0800365VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR(VkPhysicalDevice physicalDevice,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600366 uint32_t queueFamilyIndex, MirConnection *connection) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700367 VkBool32 result = VK_FALSE;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600368 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700369 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600370 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600371 SwpPhysicalDevice *pPhysicalDevice = NULL;
372 {
373 auto it = my_data->physicalDeviceMap.find(physicalDevice);
374 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
375 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700376
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600377 if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600378 skip_call |= ValidateQueueFamilyIndex(my_data, queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700379 pPhysicalDevice->physicalDevice, "vkGetPhysicalDeviceMirPresentationSupportKHR",
380 VALIDATION_ERROR_01893);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700381 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600382 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700383
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600384 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700385 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700386 result = my_data->instance_dispatch_table->GetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex,
387 connection);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700388 }
389 return result;
390}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700391#endif // VK_USE_PLATFORM_MIR_KHR
392
393#ifdef VK_USE_PLATFORM_WAYLAND_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600394VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
395 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700396 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600397 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700398 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600399 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600400 SwpInstance *pInstance = NULL;
401 {
402 auto it = my_data->instanceMap.find(instance);
403 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
404 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700405
Ian Elliott970a2bd2016-06-21 11:08:43 -0600406 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700407
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600408 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700409 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700410 result = my_data->instance_dispatch_table->CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600411 lock.lock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700412
Ian Elliott32311832016-02-04 08:17:18 -0700413 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600414 {
415 auto it = my_data->instanceMap.find(instance);
416 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
417 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700418 if ((result == VK_SUCCESS) && pInstance && pSurface) {
419 // Record the VkSurfaceKHR returned by the ICD:
420 my_data->surfaceMap[*pSurface].surface = *pSurface;
421 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700422 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
423 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
424 // Point to the associated SwpInstance:
425 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
426 }
Ian Elliott970a2bd2016-06-21 11:08:43 -0600427 lock.unlock();
428
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700429 return result;
430 }
431 return VK_ERROR_VALIDATION_FAILED_EXT;
432}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700433
Chia-I Wufccbfe42016-04-28 14:01:30 +0800434VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice,
435 uint32_t queueFamilyIndex,
436 struct wl_display *display) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700437 VkBool32 result = VK_FALSE;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600438 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700439 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600440 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600441 SwpPhysicalDevice *pPhysicalDevice = NULL;
442 {
443 auto it = my_data->physicalDeviceMap.find(physicalDevice);
444 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
445 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700446
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600447 if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600448 skip_call |= ValidateQueueFamilyIndex(my_data, queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700449 pPhysicalDevice->physicalDevice, "vkGetPhysicalDeviceWaylandPresentationSupportKHR",
450 VALIDATION_ERROR_01896);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700451 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600452 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700453
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600454 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700455 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700456 result = my_data->instance_dispatch_table->GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex,
457 display);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700458 }
459 return result;
460}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700461#endif // VK_USE_PLATFORM_WAYLAND_KHR
462
463#ifdef VK_USE_PLATFORM_WIN32_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600464VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
465 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700466 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600467 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700468 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600469 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600470 SwpInstance *pInstance = NULL;
471 {
472 auto it = my_data->instanceMap.find(instance);
473 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
474 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700475
Ian Elliott970a2bd2016-06-21 11:08:43 -0600476 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700477
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600478 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700479 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700480 result = my_data->instance_dispatch_table->CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600481 lock.lock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700482
Ian Elliott32311832016-02-04 08:17:18 -0700483 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600484 {
485 auto it = my_data->instanceMap.find(instance);
486 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
487 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700488 if ((result == VK_SUCCESS) && pInstance && pSurface) {
489 // Record the VkSurfaceKHR returned by the ICD:
490 my_data->surfaceMap[*pSurface].surface = *pSurface;
491 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700492 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
493 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
494 // Point to the associated SwpInstance:
495 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
496 }
Ian Elliott970a2bd2016-06-21 11:08:43 -0600497 lock.unlock();
498
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700499 return result;
500 }
501 return VK_ERROR_VALIDATION_FAILED_EXT;
502}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700503
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600504VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice,
505 uint32_t queueFamilyIndex) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700506 VkBool32 result = VK_FALSE;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600507 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700508 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600509 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600510 SwpPhysicalDevice *pPhysicalDevice = NULL;
511 {
512 auto it = my_data->physicalDeviceMap.find(physicalDevice);
513 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
514 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700515
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600516 if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600517 skip_call |= ValidateQueueFamilyIndex(my_data, queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700518 pPhysicalDevice->physicalDevice, "vkGetPhysicalDeviceWin32PresentationSupportKHR",
519 VALIDATION_ERROR_01899);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700520 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600521 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700522
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600523 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700524 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700525 result = my_data->instance_dispatch_table->GetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700526 }
527 return result;
528}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700529#endif // VK_USE_PLATFORM_WIN32_KHR
530
531#ifdef VK_USE_PLATFORM_XCB_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600532VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
533 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700534 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600535 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700536 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600537 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600538 SwpInstance *pInstance = NULL;
539 {
540 auto it = my_data->instanceMap.find(instance);
541 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
542 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700543
Ian Elliott970a2bd2016-06-21 11:08:43 -0600544 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700545
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600546 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700547 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700548 result = my_data->instance_dispatch_table->CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600549 lock.lock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700550
Ian Elliott32311832016-02-04 08:17:18 -0700551 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600552 {
553 auto it = my_data->instanceMap.find(instance);
554 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
555 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700556 if ((result == VK_SUCCESS) && pInstance && pSurface) {
557 // Record the VkSurfaceKHR returned by the ICD:
558 my_data->surfaceMap[*pSurface].surface = *pSurface;
559 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700560 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
561 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
562 // Point to the associated SwpInstance:
563 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
564 }
Ian Elliott970a2bd2016-06-21 11:08:43 -0600565 lock.unlock();
566
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700567 return result;
568 }
569 return VK_ERROR_VALIDATION_FAILED_EXT;
570}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700571
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600572VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice,
573 uint32_t queueFamilyIndex, xcb_connection_t *connection,
574 xcb_visualid_t visual_id) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700575 VkBool32 result = VK_FALSE;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600576 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700577 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600578 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600579 SwpPhysicalDevice *pPhysicalDevice = NULL;
580 {
581 auto it = my_data->physicalDeviceMap.find(physicalDevice);
582 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
583 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700584
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600585 if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600586 skip_call |= ValidateQueueFamilyIndex(my_data, queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700587 pPhysicalDevice->physicalDevice, "vkGetPhysicalDeviceXcbPresentationSupportKHR",
588 VALIDATION_ERROR_01901);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700589 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600590 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700591
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600592 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700593 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700594 result = my_data->instance_dispatch_table->GetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex,
595 connection, visual_id);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700596 }
597 return result;
598}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700599#endif // VK_USE_PLATFORM_XCB_KHR
600
601#ifdef VK_USE_PLATFORM_XLIB_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600602VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
603 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700604 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600605 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700606 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600607 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600608 SwpInstance *pInstance = NULL;
609 {
610 auto it = my_data->instanceMap.find(instance);
611 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
612 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700613
Ian Elliott970a2bd2016-06-21 11:08:43 -0600614 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700615
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600616 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700617 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700618 result = my_data->instance_dispatch_table->CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600619 lock.lock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700620
Ian Elliott32311832016-02-04 08:17:18 -0700621 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600622 {
623 auto it = my_data->instanceMap.find(instance);
624 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
625 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700626 if ((result == VK_SUCCESS) && pInstance && pSurface) {
627 // Record the VkSurfaceKHR returned by the ICD:
628 my_data->surfaceMap[*pSurface].surface = *pSurface;
629 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700630 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
631 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
632 // Point to the associated SwpInstance:
633 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
634 }
Ian Elliott970a2bd2016-06-21 11:08:43 -0600635 lock.unlock();
636
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700637 return result;
638 }
639 return VK_ERROR_VALIDATION_FAILED_EXT;
640}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700641
Chia-I Wufccbfe42016-04-28 14:01:30 +0800642VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600643 uint32_t queueFamilyIndex, Display *dpy,
644 VisualID visualID) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700645 VkBool32 result = VK_FALSE;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600646 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700647 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600648 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600649 SwpPhysicalDevice *pPhysicalDevice = NULL;
650 {
651 auto it = my_data->physicalDeviceMap.find(physicalDevice);
652 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
653 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700654
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600655 if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600656 skip_call |= ValidateQueueFamilyIndex(my_data, queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700657 pPhysicalDevice->physicalDevice, "vkGetPhysicalDeviceXlibPresentationSupportKHR",
658 VALIDATION_ERROR_01904);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700659 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600660 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700661
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600662 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700663 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700664 result = my_data->instance_dispatch_table->GetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex,
665 dpy, visualID);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700666 }
667 return result;
668}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700669#endif // VK_USE_PLATFORM_XLIB_KHR
670
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600671VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
672 VkDisplayPlanePropertiesKHR *pProperties) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100673 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600674 bool skip_call = false;
Petros Bantolas2b40be72016-04-15 11:02:59 +0100675 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
676 std::unique_lock<std::mutex> lock(global_lock);
677 SwpPhysicalDevice *pPhysicalDevice = NULL;
678 {
679 auto it = my_data->physicalDeviceMap.find(physicalDevice);
680 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
681 }
Petros Bantolas2b40be72016-04-15 11:02:59 +0100682 lock.unlock();
683
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600684 if (!skip_call) {
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600685 result = my_data->instance_dispatch_table->GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount,
686 pProperties);
Petros Bantolas2b40be72016-04-15 11:02:59 +0100687
688 lock.lock();
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600689 if (!pPhysicalDevice->gotDisplayPlanePropertyCount) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100690 pPhysicalDevice->displayPlanePropertyCount = *pPropertyCount;
691 pPhysicalDevice->gotDisplayPlanePropertyCount = true;
692 }
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600693 // TODO store the properties for later checks
Petros Bantolas2b40be72016-04-15 11:02:59 +0100694 lock.unlock();
695
696 return result;
697 }
698 return VK_ERROR_VALIDATION_FAILED_EXT;
699}
700
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600701VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
702 uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100703 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600704 bool skip_call = false;
Petros Bantolas2b40be72016-04-15 11:02:59 +0100705 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
706 std::unique_lock<std::mutex> lock(global_lock);
707 SwpPhysicalDevice *pPhysicalDevice = NULL;
708 {
709 auto it = my_data->physicalDeviceMap.find(physicalDevice);
710 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
711 }
712
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600713 if (!pPhysicalDevice->gotDisplayPlanePropertyCount) {
714 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
715 reinterpret_cast<uint64_t>(pPhysicalDevice->pInstance->instance), __LINE__,
716 SWAPCHAIN_GET_SUPPORTED_DISPLAYS_WITHOUT_QUERY, swapchain_layer_name,
717 "Potential problem with calling vkGetDisplayPlaneSupportedDisplaysKHR() without first "
718 "querying vkGetPhysicalDeviceDisplayPlanePropertiesKHR.");
719 }
720
721 if (pPhysicalDevice->gotDisplayPlanePropertyCount && planeIndex >= pPhysicalDevice->displayPlanePropertyCount) {
722 skip_call |=
723 log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700724 reinterpret_cast<uint64_t>(pPhysicalDevice->pInstance->instance), __LINE__, VALIDATION_ERROR_01857,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600725 swapchain_layer_name,
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600726 "vkGetDisplayPlaneSupportedDisplaysKHR(): planeIndex must be in the range [0, %d] that was returned by "
Mike Weiblen6a27de52016-12-09 17:36:28 -0700727 "vkGetPhysicalDeviceDisplayPlanePropertiesKHR. Do you have the plane index hardcoded? %s",
728 pPhysicalDevice->displayPlanePropertyCount - 1, validation_error_map[VALIDATION_ERROR_01857]);
Petros Bantolas2b40be72016-04-15 11:02:59 +0100729 }
730 lock.unlock();
731
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600732 if (!skip_call) {
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600733 result = my_data->instance_dispatch_table->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount,
734 pDisplays);
Petros Bantolas2b40be72016-04-15 11:02:59 +0100735
736 return result;
737 }
Jon Ashburne699f442016-06-30 09:01:27 -0600738 // TODO validate the returned display objects
Petros Bantolas2b40be72016-04-15 11:02:59 +0100739 return VK_ERROR_VALIDATION_FAILED_EXT;
740}
741
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600742VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
743 uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100744 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600745 bool skip_call = false;
Petros Bantolas2b40be72016-04-15 11:02:59 +0100746 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
747 std::unique_lock<std::mutex> lock(global_lock);
748 SwpPhysicalDevice *pPhysicalDevice = NULL;
749 {
750 auto it = my_data->physicalDeviceMap.find(physicalDevice);
751 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
752 }
753
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600754 if (!pPhysicalDevice->gotDisplayPlanePropertyCount) {
755 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
756 reinterpret_cast<uint64_t>(pPhysicalDevice->pInstance->instance), __LINE__,
757 SWAPCHAIN_GET_SUPPORTED_DISPLAYS_WITHOUT_QUERY, swapchain_layer_name,
758 "Potential problem with calling vkGetDisplayPlaneCapabilitiesKHR() without first "
759 "querying vkGetPhysicalDeviceDisplayPlanePropertiesKHR.");
760 }
761
762 if (pPhysicalDevice->gotDisplayPlanePropertyCount && planeIndex >= pPhysicalDevice->displayPlanePropertyCount) {
763 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
764 reinterpret_cast<uint64_t>(pPhysicalDevice->pInstance->instance), __LINE__,
765 SWAPCHAIN_PLANE_INDEX_TOO_LARGE, swapchain_layer_name,
766 "vkGetDisplayPlaneCapabilitiesKHR(): planeIndex must be in the range [0, %d] that was returned by "
767 "vkGetPhysicalDeviceDisplayPlanePropertiesKHR. Do you have the plane index hardcoded?",
768 pPhysicalDevice->displayPlanePropertyCount - 1);
Petros Bantolas2b40be72016-04-15 11:02:59 +0100769 }
770
Petros Bantolas2b40be72016-04-15 11:02:59 +0100771 lock.unlock();
772
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600773 if (!skip_call) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100774 result = my_data->instance_dispatch_table->GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
775 return result;
776 }
777
778 return VK_ERROR_VALIDATION_FAILED_EXT;
779}
780
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600781VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
782 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100783 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600784 bool skip_call = false;
Petros Bantolas2b40be72016-04-15 11:02:59 +0100785 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
786 std::unique_lock<std::mutex> lock(global_lock);
787 SwpInstance *pInstance = &(my_data->instanceMap[instance]);
788
Jon Ashburne699f442016-06-30 09:01:27 -0600789 // TODO more validation checks
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600790 if (!skip_call) {
Petros Bantolas2b40be72016-04-15 11:02:59 +0100791 // Call down the call chain:
792 lock.unlock();
793 result = my_data->instance_dispatch_table->CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
794 lock.lock();
795
796 // Obtain this pointer again after locking:
797 pInstance = &(my_data->instanceMap[instance]);
798 if ((result == VK_SUCCESS) && pInstance && pSurface) {
799 // Record the VkSurfaceKHR returned by the ICD:
800 my_data->surfaceMap[*pSurface].surface = *pSurface;
801 my_data->surfaceMap[*pSurface].pInstance = pInstance;
Petros Bantolas2b40be72016-04-15 11:02:59 +0100802 my_data->surfaceMap[*pSurface].numQueueFamilyIndexSupport = 0;
803 my_data->surfaceMap[*pSurface].pQueueFamilyIndexSupport = NULL;
804 // Point to the associated SwpInstance:
805 pInstance->surfaces[*pSurface] = &my_data->surfaceMap[*pSurface];
806 }
807 lock.unlock();
808 return result;
809 }
810 return VK_ERROR_VALIDATION_FAILED_EXT;
811}
812
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600813VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600814 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700815 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600816 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600817 SwpSurface *pSurface = NULL;
818 {
819 auto it = my_data->surfaceMap.find(surface);
820 pSurface = (it == my_data->surfaceMap.end()) ? NULL : &it->second;
821 }
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700822
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600823 // Regardless of skip_call value, do some internal cleanup:
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700824 if (pSurface) {
825 // Delete the SwpSurface associated with this surface:
826 if (pSurface->pInstance) {
827 pSurface->pInstance->surfaces.erase(surface);
828 }
829 if (!pSurface->swapchains.empty()) {
Mike Weiblen6a27de52016-12-09 17:36:28 -0700830 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
831 reinterpret_cast<uint64_t>(instance), __LINE__, VALIDATION_ERROR_01844, swapchain_layer_name,
832 "vkDestroySurfaceKHR() called before all of its associated VkSwapchainKHRs were destroyed. %s",
833 validation_error_map[VALIDATION_ERROR_01844]);
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600834
835 // Empty and then delete all SwpSwapchains
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700836 for (auto it = pSurface->swapchains.begin(); it != pSurface->swapchains.end(); it++) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700837 // Delete all SwpImage's
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700838 // In case the swapchain's device hasn't been destroyed yet
839 // (which isn't likely, but is possible), delete its
840 // association with this swapchain (i.e. so we can't point to
841 // this swpchain from that device, later on):
842 if (it->second->pDevice) {
843 it->second->pDevice->swapchains.clear();
844 }
845 }
846 pSurface->swapchains.clear();
847 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700848 my_data->surfaceMap.erase(surface);
849 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600850 lock.unlock();
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -0700851
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600852 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700853 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700854 my_data->instance_dispatch_table->DestroySurfaceKHR(instance, surface, pAllocator);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700855 }
856}
857
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600858VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
859 VkPhysicalDevice *pPhysicalDevices) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700860 VkResult result = VK_SUCCESS;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700861 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Ian Elliott32311832016-02-04 08:17:18 -0700862
863 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700864 result = my_data->instance_dispatch_table->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
Ian Elliott32311832016-02-04 08:17:18 -0700865
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600866 std::lock_guard<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600867 SwpInstance *pInstance = NULL;
868 {
869 auto it = my_data->instanceMap.find(instance);
870 pInstance = (it == my_data->instanceMap.end()) ? NULL : &it->second;
871 }
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700872 if ((result == VK_SUCCESS) && pInstance && pPhysicalDevices && (*pPhysicalDeviceCount > 0)) {
Ian Elliott32311832016-02-04 08:17:18 -0700873 // Record the VkPhysicalDevices returned by the ICD:
874 for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700875 my_data->physicalDeviceMap[pPhysicalDevices[i]].physicalDevice = pPhysicalDevices[i];
Ian Elliott32311832016-02-04 08:17:18 -0700876 my_data->physicalDeviceMap[pPhysicalDevices[i]].pInstance = pInstance;
877 my_data->physicalDeviceMap[pPhysicalDevices[i]].pDevice = NULL;
878 my_data->physicalDeviceMap[pPhysicalDevices[i]].gotQueueFamilyPropertyCount = false;
Ian Elliott32311832016-02-04 08:17:18 -0700879 // Point to the associated SwpInstance:
880 if (pInstance) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700881 pInstance->physicalDevices[pPhysicalDevices[i]] = &my_data->physicalDeviceMap[pPhysicalDevices[i]];
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700882 }
883 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700884 }
Ian Elliotta3c69bc2016-02-04 15:34:59 -0700885 return result;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700886}
887
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600888VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
Chia-I Wufccbfe42016-04-28 14:01:30 +0800889 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
Chia-I Wua6737532016-04-28 16:04:15 +0800890 layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700891 VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
892
893 assert(chain_info->u.pLayerInfo);
894 PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
895 PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
Chia-I Wua6737532016-04-28 16:04:15 +0800896 PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(my_instance_data->instance, "vkCreateDevice");
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700897 if (fpCreateDevice == NULL) {
898 return VK_ERROR_INITIALIZATION_FAILED;
899 }
900
901 // Advance the link info for the next element on the chain
902 chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
903
904 VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
905 if (result != VK_SUCCESS) {
906 return result;
907 }
908
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600909 std::lock_guard<std::mutex> lock(global_lock);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700910 layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
911
912 // Setup device dispatch table
913 my_device_data->device_dispatch_table = new VkLayerDispatchTable;
914 layer_init_device_dispatch_table(*pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr);
915
916 my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
Mark Youngaa1aa3a2016-07-05 16:41:50 -0600917 checkDeviceRegisterExtensions(physicalDevice, pCreateInfo, *pDevice);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700918
919 return result;
920}
921
Chia-I Wufccbfe42016-04-28 14:01:30 +0800922VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700923 dispatch_key key = get_dispatch_key(device);
924 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
Ian Elliott32311832016-02-04 08:17:18 -0700925
926 // Call down the call chain:
927 my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
928
929 // Do some internal cleanup:
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600930 std::lock_guard<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600931 SwpDevice *pDevice = NULL;
932 {
933 auto it = my_data->deviceMap.find(device);
934 pDevice = (it == my_data->deviceMap.end()) ? NULL : &it->second;
935 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700936 if (pDevice) {
937 // Delete the SwpDevice associated with this device:
938 if (pDevice->pPhysicalDevice) {
939 pDevice->pPhysicalDevice->pDevice = NULL;
940 }
941 if (!pDevice->swapchains.empty()) {
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600942 log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700943 reinterpret_cast<uint64_t>(device), __LINE__, VALIDATION_ERROR_00049, swapchain_layer_name,
944 "vkDestroyDevice() called before all of its associated VkSwapchainKHRs were destroyed. %s",
945 validation_error_map[VALIDATION_ERROR_00049]);
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600946
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700947 // Empty and then delete all SwpSwapchain's
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700948 for (auto it = pDevice->swapchains.begin(); it != pDevice->swapchains.end(); it++) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700949 // Delete all SwpImage's
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700950 // In case the swapchain's surface hasn't been destroyed yet
951 // (which is likely) delete its association with this swapchain
952 // (i.e. so we can't point to this swpchain from that surface,
953 // later on):
954 if (it->second->pSurface) {
955 it->second->pSurface->swapchains.clear();
956 }
957 }
958 pDevice->swapchains.clear();
959 }
960 my_data->deviceMap.erase(device);
961 }
962 delete my_data->device_dispatch_table;
963 layer_data_map.erase(key);
964}
965
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600966VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
967 VkSurfaceKHR surface, VkBool32 *pSupported) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700968 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600969 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700970 layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600971 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -0600972 SwpPhysicalDevice *pPhysicalDevice = NULL;
973 {
974 auto it = my_data->physicalDeviceMap.find(physicalDevice);
975 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
976 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700977
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700978 if (!pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600979 skip_call |= log_msg(
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600980 my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -0600981 reinterpret_cast<uint64_t>(pPhysicalDevice->physicalDevice), __LINE__, SWAPCHAIN_DID_NOT_QUERY_QUEUE_FAMILIES,
982 swapchain_layer_name,
Mark Lobodzinski9b482fa2016-08-08 09:38:42 -0600983 "vkGetPhysicalDeviceSurfaceSupportKHR() called before calling the vkGetPhysicalDeviceQueueFamilyProperties function.");
Mark Lobodzinskic3b7c462016-08-08 11:09:27 -0600984 } else if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600985 skip_call |= ValidateQueueFamilyIndex(my_data, queueFamilyIndex, pPhysicalDevice->numOfQueueFamilies,
Mike Weiblen6a27de52016-12-09 17:36:28 -0700986 pPhysicalDevice->physicalDevice, "vkGetPhysicalDeviceSurfaceSupportKHR",
987 VALIDATION_ERROR_01889);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700988 }
Mark Lobodzinski0f73c0b2016-08-08 09:57:09 -0600989
Ian Elliott970a2bd2016-06-21 11:08:43 -0600990 lock.unlock();
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700991
Mark Lobodzinski38ece432016-08-08 14:36:58 -0600992 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700993 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -0700994 result = my_data->instance_dispatch_table->GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface,
995 pSupported);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -0600996 lock.lock();
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -0700997
Ian Elliott32311832016-02-04 08:17:18 -0700998 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -0600999 {
1000 auto it = my_data->physicalDeviceMap.find(physicalDevice);
1001 pPhysicalDevice = (it == my_data->physicalDeviceMap.end()) ? NULL : &it->second;
1002 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001003 if ((result == VK_SUCCESS) && pSupported && pPhysicalDevice) {
1004 // Record the result of this query:
1005 SwpInstance *pInstance = pPhysicalDevice->pInstance;
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001006 SwpSurface *pSurface = (pInstance) ? pInstance->surfaces[surface] : NULL;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001007 if (pSurface) {
1008 pPhysicalDevice->supportedSurfaces[surface] = pSurface;
1009 if (!pSurface->numQueueFamilyIndexSupport) {
1010 if (pPhysicalDevice->gotQueueFamilyPropertyCount) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001011 pSurface->pQueueFamilyIndexSupport =
1012 (VkBool32 *)malloc(pPhysicalDevice->numOfQueueFamilies * sizeof(VkBool32));
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001013 if (pSurface->pQueueFamilyIndexSupport != NULL) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001014 pSurface->numQueueFamilyIndexSupport = pPhysicalDevice->numOfQueueFamilies;
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -07001015 }
1016 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001017 }
1018 if (pSurface->numQueueFamilyIndexSupport) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001019 pSurface->pQueueFamilyIndexSupport[queueFamilyIndex] = *pSupported;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001020 }
1021 }
1022 }
Ian Elliott970a2bd2016-06-21 11:08:43 -06001023 lock.unlock();
1024
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001025 return result;
1026 }
1027 return VK_ERROR_VALIDATION_FAILED_EXT;
1028}
Mark Lobodzinskib39d9e62016-02-02 17:06:29 -07001029
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001030// This function does the up-front validation work for vkCreateSwapchainKHR(),
Dustin Graves080069b2016-04-05 13:48:15 -06001031// and returns true if a logging callback indicates that the call down the
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001032// chain should be skipped:
Dustin Graves080069b2016-04-05 13:48:15 -06001033static bool validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, VkSwapchainKHR *pSwapchain) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001034 // TODO: Validate cases of re-creating a swapchain (the current code
1035 // assumes a new swapchain is being created).
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001036 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001037 layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Ian Elliott77f46ca2016-05-05 14:10:49 -06001038 SwpDevice *pDevice = NULL;
1039 {
1040 auto it = my_data->deviceMap.find(device);
1041 pDevice = (it == my_data->deviceMap.end()) ? NULL : &it->second;
1042 }
Ian Elliott0b4d6242015-09-22 10:51:24 -06001043
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001044 // Keep around a useful pointer to pPhysicalDevice:
1045 SwpPhysicalDevice *pPhysicalDevice = pDevice->pPhysicalDevice;
Ian Elliottf7f8ff02015-12-30 14:55:41 -07001046
Mark Lobodzinskid40b2db2016-02-25 13:56:57 -07001047 // Validate pCreateInfo values with result of
1048 // vkGetPhysicalDeviceQueueFamilyProperties
1049 if (pPhysicalDevice && pPhysicalDevice->gotQueueFamilyPropertyCount) {
Michael Mc Donnell75ecdb72016-04-03 14:47:51 -07001050 for (uint32_t i = 0; i < pCreateInfo->queueFamilyIndexCount; i++) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001051 skip_call |= ValidateQueueFamilyIndex(my_data, pCreateInfo->pQueueFamilyIndices[i], pPhysicalDevice->numOfQueueFamilies,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001052 pPhysicalDevice->physicalDevice, "vkCreateSwapchainKHR");
Mark Lobodzinskid40b2db2016-02-25 13:56:57 -07001053 }
1054 }
1055
Chris Forbese2d83832016-10-12 15:00:46 +13001056 if (pCreateInfo) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001057 // Validate pCreateInfo->surface to make sure that
1058 // vkGetPhysicalDeviceSurfaceSupportKHR() reported this as a supported
1059 // surface:
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001060 SwpSurface *pSurface = ((pPhysicalDevice) ? pPhysicalDevice->supportedSurfaces[pCreateInfo->surface] : NULL);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001061 if (!pSurface) {
Mike Weiblen6a27de52016-12-09 17:36:28 -07001062 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
1063 reinterpret_cast<uint64_t>(device), __LINE__, VALIDATION_ERROR_01922, swapchain_layer_name,
1064 "The surface in pCreateInfo->surface, that was given to vkCreateSwapchainKHR(), must be a surface "
1065 "that is supported by the device as determined by vkGetPhysicalDeviceSurfaceSupportKHR(). "
1066 "However, vkGetPhysicalDeviceSurfaceSupportKHR() was never called with this surface. %s",
1067 validation_error_map[VALIDATION_ERROR_01922]);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001068 }
Ian Elliott4f147fc2016-01-20 08:52:08 -07001069
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001070 }
Ian Elliottf7f8ff02015-12-30 14:55:41 -07001071
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001072 // Validate pCreateInfo->imageSharingMode and related values:
1073 if (pCreateInfo->imageSharingMode == VK_SHARING_MODE_CONCURRENT) {
Mike Weiblen6a27de52016-12-09 17:36:28 -07001074 if (pCreateInfo->queueFamilyIndexCount <= 1) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001075 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
Mike Weiblen6a27de52016-12-09 17:36:28 -07001076 reinterpret_cast<uint64_t>(device), __LINE__, VALIDATION_ERROR_02338, swapchain_layer_name,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001077 "vkCreateSwapchainKHR() called with a supported pCreateInfo->sharingMode of (i.e. %s), but with a "
Mike Weiblen6a27de52016-12-09 17:36:28 -07001078 "bad value(s) for pCreateInfo->queueFamilyIndexCount or pCreateInfo->pQueueFamilyIndices). %s",
1079 sharingModeStr(pCreateInfo->imageSharingMode), validation_error_map[VALIDATION_ERROR_02338]);
1080 }
1081
1082 if (!pCreateInfo->pQueueFamilyIndices) {
1083 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
1084 reinterpret_cast<uint64_t>(device), __LINE__, VALIDATION_ERROR_02337, swapchain_layer_name,
1085 "vkCreateSwapchainKHR() called with a supported pCreateInfo->sharingMode of (i.e. %s), but with a "
1086 "bad value(s) for pCreateInfo->queueFamilyIndexCount or pCreateInfo->pQueueFamilyIndices). %s",
1087 sharingModeStr(pCreateInfo->imageSharingMode), validation_error_map[VALIDATION_ERROR_02337]);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001088 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001089 }
Mike Weiblen6a27de52016-12-09 17:36:28 -07001090
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001091 return skip_call;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001092}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001093
Chia-I Wufccbfe42016-04-28 14:01:30 +08001094VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001095 const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001096 VkResult result = VK_SUCCESS;
1097 layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001098 std::unique_lock<std::mutex> lock(global_lock);
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001099 bool skip_call = validateCreateSwapchainKHR(device, pCreateInfo, pSwapchain);
Ian Elliott970a2bd2016-06-21 11:08:43 -06001100 lock.unlock();
Ian Elliott0b4d6242015-09-22 10:51:24 -06001101
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001102 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001103 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001104 result = my_data->device_dispatch_table->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001105 lock.lock();
Ian Elliott0b4d6242015-09-22 10:51:24 -06001106
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001107 if (result == VK_SUCCESS) {
1108 // Remember the swapchain's handle, and link it to the device:
Ian Elliott77f46ca2016-05-05 14:10:49 -06001109 SwpDevice *pDevice = NULL;
1110 {
1111 auto it = my_data->deviceMap.find(device);
1112 pDevice = (it == my_data->deviceMap.end()) ? NULL : &it->second;
1113 }
Ian Elliott0b4d6242015-09-22 10:51:24 -06001114
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001115 my_data->swapchainMap[*pSwapchain].swapchain = *pSwapchain;
1116 if (pDevice) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001117 pDevice->swapchains[*pSwapchain] = &my_data->swapchainMap[*pSwapchain];
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001118 }
1119 my_data->swapchainMap[*pSwapchain].pDevice = pDevice;
1120 my_data->swapchainMap[*pSwapchain].imageCount = 0;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001121 // Store a pointer to the surface
1122 SwpPhysicalDevice *pPhysicalDevice = pDevice->pPhysicalDevice;
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001123 SwpInstance *pInstance = (pPhysicalDevice) ? pPhysicalDevice->pInstance : NULL;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001124 layer_data *my_instance_data =
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001125 ((pInstance) ? get_my_data_ptr(get_dispatch_key(pInstance->instance), layer_data_map) : NULL);
1126 SwpSurface *pSurface = ((my_data && pCreateInfo) ? &my_instance_data->surfaceMap[pCreateInfo->surface] : NULL);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001127 my_data->swapchainMap[*pSwapchain].pSurface = pSurface;
1128 if (pSurface) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001129 pSurface->swapchains[*pSwapchain] = &my_data->swapchainMap[*pSwapchain];
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001130 }
1131 }
Ian Elliott970a2bd2016-06-21 11:08:43 -06001132 lock.unlock();
1133
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001134 return result;
1135 }
1136 return VK_ERROR_VALIDATION_FAILED_EXT;
1137}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001138
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001139VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001140 // TODOs:
1141 //
1142 // - Implement a check for validity language that reads: All uses of
Ian Elliotta5d13a92016-04-07 09:05:45 -06001143 // presentable images acquired from pname:swapchain must: have completed
1144 // execution
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001145 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001146 layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001147 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott0b4d6242015-09-22 10:51:24 -06001148
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001149 // Regardless of skip_call value, do some internal cleanup:
Ian Elliott77f46ca2016-05-05 14:10:49 -06001150 SwpSwapchain *pSwapchain = NULL;
1151 {
1152 auto it = my_data->swapchainMap.find(swapchain);
1153 pSwapchain = (it == my_data->swapchainMap.end()) ? NULL : &it->second;
1154 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001155 if (pSwapchain) {
1156 // Delete the SwpSwapchain associated with this swapchain:
1157 if (pSwapchain->pDevice) {
1158 pSwapchain->pDevice->swapchains.erase(swapchain);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001159 }
1160 if (pSwapchain->pSurface) {
1161 pSwapchain->pSurface->swapchains.erase(swapchain);
1162 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001163 my_data->swapchainMap.erase(swapchain);
1164 }
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001165 lock.unlock();
Ian Elliott0b4d6242015-09-22 10:51:24 -06001166
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001167 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001168 // Call down the call chain:
1169 my_data->device_dispatch_table->DestroySwapchainKHR(device, swapchain, pAllocator);
1170 }
1171}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001172
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001173VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
1174 VkImage *pSwapchainImages) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001175 VkResult result = VK_SUCCESS;
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001176 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001177 layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001178 std::unique_lock<std::mutex> lock(global_lock);
Ian Elliott8b9e2562016-01-05 13:00:50 -07001179
Ian Elliott77f46ca2016-05-05 14:10:49 -06001180 SwpSwapchain *pSwapchain = NULL;
1181 {
1182 auto it = my_data->swapchainMap.find(swapchain);
1183 pSwapchain = (it == my_data->swapchainMap.end()) ? NULL : &it->second;
1184 }
Mark Lobodzinski0f73c0b2016-08-08 09:57:09 -06001185 if (pSwapchain && pSwapchainImages) {
1186 // Compare the preliminary value of *pSwapchainImageCount with the value this time:
Ian Elliottfdf3ffa2016-05-05 14:06:53 -06001187 if (pSwapchain->imageCount == 0) {
Mark Lobodzinski0f73c0b2016-08-08 09:57:09 -06001188 // Since we haven't recorded a preliminary value of *pSwapchainImageCount, that likely means that the application didn't
1189 // previously call this function with a NULL value of pSwapchainImages:
Mark Lobodzinski6a7e9332016-08-16 09:06:15 -06001190 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001191 reinterpret_cast<uint64_t>(device), __LINE__, SWAPCHAIN_PRIOR_COUNT, swapchain_layer_name,
1192 "vkGetSwapchainImagesKHR() called with non-NULL pSwapchainImageCount; but no prior positive "
1193 "value has been seen for pSwapchainImages.");
Ian Elliottfdf3ffa2016-05-05 14:06:53 -06001194 } else if (*pSwapchainImageCount > pSwapchain->imageCount) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001195 skip_call |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001196 reinterpret_cast<uint64_t>(device), __LINE__, SWAPCHAIN_INVALID_COUNT, swapchain_layer_name,
1197 "vkGetSwapchainImagesKHR() called with non-NULL pSwapchainImageCount, and with "
1198 "pSwapchainImages set to a value (%d) that is greater than the value (%d) that was returned when "
1199 "pSwapchainImageCount was NULL.",
1200 *pSwapchainImageCount, pSwapchain->imageCount);
Ian Elliottfdf3ffa2016-05-05 14:06:53 -06001201 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001202 }
Ian Elliott970a2bd2016-06-21 11:08:43 -06001203 lock.unlock();
Ian Elliott0b4d6242015-09-22 10:51:24 -06001204
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001205 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001206 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001207 result = my_data->device_dispatch_table->GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001208 lock.lock();
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001209
Ian Elliott32311832016-02-04 08:17:18 -07001210 // Obtain this pointer again after locking:
Ian Elliott77f46ca2016-05-05 14:10:49 -06001211 {
1212 auto it = my_data->swapchainMap.find(swapchain);
1213 pSwapchain = (it == my_data->swapchainMap.end()) ? NULL : &it->second;
1214 }
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001215 if ((result == VK_SUCCESS) && pSwapchain && !pSwapchainImages && pSwapchainImageCount) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001216 // Record the result of this preliminary query:
1217 pSwapchain->imageCount = *pSwapchainImageCount;
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001218 } else if ((result == VK_SUCCESS) && pSwapchain && pSwapchainImages && pSwapchainImageCount &&
1219 (*pSwapchainImageCount > 0)) {
Ian Elliottfdf3ffa2016-05-05 14:06:53 -06001220 // Record the images and their state:
1221 pSwapchain->imageCount = *pSwapchainImageCount;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001222 }
Ian Elliott970a2bd2016-06-21 11:08:43 -06001223 lock.unlock();
1224
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001225 return result;
1226 }
1227 return VK_ERROR_VALIDATION_FAILED_EXT;
1228}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001229
Mark Young1a867442016-07-01 15:18:27 -06001230VKAPI_ATTR void VKAPI_CALL
1231GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001232 bool skip_call = false;
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001233 layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Ian Elliottc4db6952016-01-21 14:29:45 -07001234
Mark Lobodzinski38ece432016-08-08 14:36:58 -06001235 if (!skip_call) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001236 // Call down the call chain:
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001237 my_data->device_dispatch_table->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
Ian Elliottc4db6952016-01-21 14:29:45 -07001238
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001239 // Remember the queue's handle, and link it to the device:
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001240 std::lock_guard<std::mutex> lock(global_lock);
Ian Elliott77f46ca2016-05-05 14:10:49 -06001241 SwpDevice *pDevice = NULL;
1242 {
1243 auto it = my_data->deviceMap.find(device);
1244 pDevice = (it == my_data->deviceMap.end()) ? NULL : &it->second;
1245 }
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001246 my_data->queueMap[&pQueue].queue = *pQueue;
1247 if (pDevice) {
1248 pDevice->queues[*pQueue] = &my_data->queueMap[*pQueue];
1249 }
1250 my_data->queueMap[&pQueue].pDevice = pDevice;
1251 my_data->queueMap[&pQueue].queueFamilyIndex = queueFamilyIndex;
1252 }
1253}
Ian Elliottc4db6952016-01-21 14:29:45 -07001254
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001255VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance instance,
1256 const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
1257 const VkAllocationCallbacks *pAllocator,
1258 VkDebugReportCallbackEXT *pMsgCallback) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001259 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001260 VkResult result =
1261 my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001262 if (VK_SUCCESS == result) {
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001263 std::lock_guard<std::mutex> lock(global_lock);
Mark Lobodzinski97c4d512016-05-19 15:27:18 -06001264 result = layer_create_msg_callback(my_data->report_data, false, pCreateInfo, pAllocator, pMsgCallback);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001265 }
1266 return result;
1267}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001268
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001269VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
Chia-I Wufccbfe42016-04-28 14:01:30 +08001270 const VkAllocationCallbacks *pAllocator) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001271 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
1272 my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
Jeremy Hayes9de0bd72016-04-13 11:57:20 -06001273 std::lock_guard<std::mutex> lock(global_lock);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001274 layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
1275}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001276
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001277VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
1278 VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
1279 int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001280 layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001281 my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix,
1282 pMsg);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001283}
Courtney Goeltzenleuchterf0de7242015-12-01 14:10:55 -07001284
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001285VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t *pCount, VkLayerProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001286 return util_GetLayerProperties(1, &swapchain_layer, pCount, pProperties);
1287}
1288
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001289VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
1290 VkLayerProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001291 return util_GetLayerProperties(1, &swapchain_layer, pCount, pProperties);
1292}
1293
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001294VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
1295 VkExtensionProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001296 if (pLayerName && !strcmp(pLayerName, swapchain_layer.layerName))
1297 return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties);
1298
1299 return VK_ERROR_LAYER_NOT_PRESENT;
1300}
1301
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001302VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
1303 uint32_t *pCount, VkExtensionProperties *pProperties) {
Chia-I Wu2b481252016-04-28 14:21:13 +08001304 if (pLayerName && !strcmp(pLayerName, swapchain_layer.layerName))
Chia-I Wu045209e2016-04-28 11:21:49 +08001305 return util_GetExtensionProperties(0, nullptr, pCount, pProperties);
Chia-I Wu2b481252016-04-28 14:21:13 +08001306
1307 assert(physicalDevice);
1308
1309 dispatch_key key = get_dispatch_key(physicalDevice);
1310 layer_data *my_data = get_my_data_ptr(key, layer_data_map);
1311 return my_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
Chia-I Wu045209e2016-04-28 11:21:49 +08001312}
1313
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001314static PFN_vkVoidFunction intercept_core_instance_command(const char *name);
Chia-I Wu22813c72016-04-28 14:38:57 +08001315
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001316static PFN_vkVoidFunction intercept_khr_surface_command(const char *name, VkInstance instance);
Chia-I Wu22813c72016-04-28 14:38:57 +08001317
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001318static PFN_vkVoidFunction intercept_core_device_command(const char *name);
Courtney Goeltzenleuchter00150eb2016-01-08 12:18:43 -07001319
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001320static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev);
Chia-I Wu83245952016-05-05 16:13:19 +08001321
Chia-I Wu9bc0b582016-04-28 14:38:57 +08001322VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) {
1323 PFN_vkVoidFunction proc = intercept_core_device_command(funcName);
1324 if (proc)
1325 return proc;
1326
1327 assert(device);
Ian Elliott0b4d6242015-09-22 10:51:24 -06001328
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001329 layer_data *my_data;
Ian Elliott0b4d6242015-09-22 10:51:24 -06001330
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001331 my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001332 VkLayerDispatchTable *pDisp = my_data->device_dispatch_table;
Chia-I Wu83245952016-05-05 16:13:19 +08001333
1334 proc = intercept_khr_swapchain_command(funcName, device);
1335 if (proc)
1336 return proc;
Courtney Goeltzenleuchter00150eb2016-01-08 12:18:43 -07001337
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001338 if (pDisp->GetDeviceProcAddr == NULL)
1339 return NULL;
1340 return pDisp->GetDeviceProcAddr(device, funcName);
1341}
Ian Elliott0b4d6242015-09-22 10:51:24 -06001342
Chia-I Wufccbfe42016-04-28 14:01:30 +08001343VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) {
Chia-I Wu22813c72016-04-28 14:38:57 +08001344 PFN_vkVoidFunction proc = intercept_core_instance_command(funcName);
Chia-I Wu5ae2f652016-04-28 15:16:59 +08001345 if (!proc)
1346 proc = intercept_core_device_command(funcName);
1347 if (!proc)
1348 proc = intercept_khr_swapchain_command(funcName, VK_NULL_HANDLE);
Chia-I Wu22813c72016-04-28 14:38:57 +08001349 if (proc)
1350 return proc;
Courtney Goeltzenleuchter52857662015-12-01 14:08:28 -07001351
Chia-I Wu5ae2f652016-04-28 15:16:59 +08001352 assert(instance);
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001353
1354 layer_data *my_data;
1355 my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
Jon Ashburn5484e0c2016-03-08 17:48:44 -07001356 VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
Ian Elliott68124ac2015-10-07 16:18:35 -06001357
Chia-I Wu5ae2f652016-04-28 15:16:59 +08001358 proc = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
1359 if (!proc)
1360 proc = intercept_khr_surface_command(funcName, instance);
Chia-I Wu22813c72016-04-28 14:38:57 +08001361 if (proc)
1362 return proc;
Ian Elliott0b4d6242015-09-22 10:51:24 -06001363
Mark Lobodzinski1ed594e2016-02-03 09:57:14 -07001364 if (pTable->GetInstanceProcAddr == NULL)
1365 return NULL;
1366 return pTable->GetInstanceProcAddr(instance, funcName);
1367}
Chia-I Wu045209e2016-04-28 11:21:49 +08001368
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001369static PFN_vkVoidFunction intercept_core_instance_command(const char *name) {
Chia-I Wu22813c72016-04-28 14:38:57 +08001370 static const struct {
1371 const char *name;
1372 PFN_vkVoidFunction proc;
1373 } core_instance_commands[] = {
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001374 {"vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr)},
1375 {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(CreateInstance)},
1376 {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance)},
1377 {"vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice)},
1378 {"vkEnumeratePhysicalDevices", reinterpret_cast<PFN_vkVoidFunction>(EnumeratePhysicalDevices)},
1379 {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties)},
1380 {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties)},
1381 {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties)},
1382 {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties)},
1383 {"vkGetPhysicalDeviceQueueFamilyProperties", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceQueueFamilyProperties)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001384 };
1385
1386 for (size_t i = 0; i < ARRAY_SIZE(core_instance_commands); i++) {
1387 if (!strcmp(core_instance_commands[i].name, name))
1388 return core_instance_commands[i].proc;
1389 }
1390
1391 return nullptr;
1392}
1393
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001394static PFN_vkVoidFunction intercept_khr_surface_command(const char *name, VkInstance instance) {
Chia-I Wu22813c72016-04-28 14:38:57 +08001395 static const struct {
1396 const char *name;
1397 PFN_vkVoidFunction proc;
1398 } khr_surface_commands[] = {
1399#ifdef VK_USE_PLATFORM_ANDROID_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001400 {"vkCreateAndroidSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateAndroidSurfaceKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001401#endif // VK_USE_PLATFORM_ANDROID_KHR
1402#ifdef VK_USE_PLATFORM_MIR_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001403 {"vkCreateMirSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateMirSurfaceKHR)},
1404 {"vkGetPhysicalDeviceMirPresentationSupportKHR",
1405 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceMirPresentationSupportKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001406#endif // VK_USE_PLATFORM_MIR_KHR
1407#ifdef VK_USE_PLATFORM_WAYLAND_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001408 {"vkCreateWaylandSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateWaylandSurfaceKHR)},
1409 {"vkGetPhysicalDeviceWaylandPresentationSupportKHR",
1410 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWaylandPresentationSupportKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001411#endif // VK_USE_PLATFORM_WAYLAND_KHR
1412#ifdef VK_USE_PLATFORM_WIN32_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001413 {"vkCreateWin32SurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateWin32SurfaceKHR)},
1414 {"vkGetPhysicalDeviceWin32PresentationSupportKHR",
1415 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceWin32PresentationSupportKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001416#endif // VK_USE_PLATFORM_WIN32_KHR
1417#ifdef VK_USE_PLATFORM_XCB_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001418 {"vkCreateXcbSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateXcbSurfaceKHR)},
1419 {"vkGetPhysicalDeviceXcbPresentationSupportKHR",
1420 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXcbPresentationSupportKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001421#endif // VK_USE_PLATFORM_XCB_KHR
1422#ifdef VK_USE_PLATFORM_XLIB_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001423 {"vkCreateXlibSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateXlibSurfaceKHR)},
1424 {"vkGetPhysicalDeviceXlibPresentationSupportKHR",
1425 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceXlibPresentationSupportKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001426#endif // VK_USE_PLATFORM_XLIB_KHR
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001427 {"vkDestroySurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(DestroySurfaceKHR)},
1428 {"vkGetPhysicalDeviceSurfaceSupportKHR", reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceSurfaceSupportKHR)},
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001429 {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR",
1430 reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceDisplayPlanePropertiesKHR)},
1431 {"vkGetDisplayPlaneSupportedDisplaysKHR", reinterpret_cast<PFN_vkVoidFunction>(GetDisplayPlaneSupportedDisplaysKHR)},
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001432 {"vkGetDisplayPlaneCapabilitiesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetDisplayPlaneCapabilitiesKHR)},
1433 {"vkCreateDisplayPlaneSurfaceKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateDisplayPlaneSurfaceKHR)},
Chia-I Wu22813c72016-04-28 14:38:57 +08001434 };
1435
1436 // do not check if VK_KHR_*_surface is enabled (why?)
1437
1438 for (size_t i = 0; i < ARRAY_SIZE(khr_surface_commands); i++) {
1439 if (!strcmp(khr_surface_commands[i].name, name))
1440 return khr_surface_commands[i].proc;
1441 }
1442
1443 return nullptr;
1444}
1445
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001446static PFN_vkVoidFunction intercept_core_device_command(const char *name) {
Chia-I Wu9bc0b582016-04-28 14:38:57 +08001447 static const struct {
1448 const char *name;
1449 PFN_vkVoidFunction proc;
1450 } core_device_commands[] = {
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001451 {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr)},
1452 {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice)},
1453 {"vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue)},
Chia-I Wu9bc0b582016-04-28 14:38:57 +08001454 };
1455
1456 for (size_t i = 0; i < ARRAY_SIZE(core_device_commands); i++) {
1457 if (!strcmp(core_device_commands[i].name, name))
1458 return core_device_commands[i].proc;
1459 }
1460
1461 return nullptr;
1462}
1463
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001464static PFN_vkVoidFunction intercept_khr_swapchain_command(const char *name, VkDevice dev) {
Chia-I Wu83245952016-05-05 16:13:19 +08001465 static const struct {
1466 const char *name;
1467 PFN_vkVoidFunction proc;
1468 } khr_swapchain_commands[] = {
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001469 {"vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR)},
1470 {"vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR)},
1471 {"vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR)},
Chia-I Wu83245952016-05-05 16:13:19 +08001472 };
1473
1474 // do not check if VK_KHR_swapchain is enabled (why?)
1475
1476 for (size_t i = 0; i < ARRAY_SIZE(khr_swapchain_commands); i++) {
1477 if (!strcmp(khr_swapchain_commands[i].name, name))
1478 return khr_swapchain_commands[i].proc;
1479 }
1480
1481 return nullptr;
1482}
1483
Chia-I Wu516b5082016-04-28 11:27:46 +08001484} // namespace swapchain
1485
1486// vk_layer_logging.h expects these to be defined
1487
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001488VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(VkInstance instance,
1489 const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
1490 const VkAllocationCallbacks *pAllocator,
1491 VkDebugReportCallbackEXT *pMsgCallback) {
Chia-I Wufccbfe42016-04-28 14:01:30 +08001492 return swapchain::CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
Chia-I Wu516b5082016-04-28 11:27:46 +08001493}
1494
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001495VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
1496 const VkAllocationCallbacks *pAllocator) {
Chia-I Wufccbfe42016-04-28 14:01:30 +08001497 swapchain::DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
Chia-I Wu516b5082016-04-28 11:27:46 +08001498}
1499
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001500VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
1501 VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
1502 int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
Chia-I Wufccbfe42016-04-28 14:01:30 +08001503 swapchain::DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
Chia-I Wu516b5082016-04-28 11:27:46 +08001504}
1505
Chia-I Wub02600c2016-05-20 07:11:22 +08001506// loader-layer interface v0, just wrappers since there is only a layer
Chia-I Wu516b5082016-04-28 11:27:46 +08001507
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001508VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pCount,
1509 VkExtensionProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001510 return swapchain::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
Chia-I Wu045209e2016-04-28 11:21:49 +08001511}
1512
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001513VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(uint32_t *pCount,
1514 VkLayerProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001515 return swapchain::EnumerateInstanceLayerProperties(pCount, pProperties);
Chia-I Wu045209e2016-04-28 11:21:49 +08001516}
1517
Mark Lobodzinskid0ef5212016-08-08 14:41:55 -06001518VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
1519 VkLayerProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001520 // the layer command handles VK_NULL_HANDLE just fine internally
1521 assert(physicalDevice == VK_NULL_HANDLE);
1522 return swapchain::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
Chia-I Wu516b5082016-04-28 11:27:46 +08001523}
1524
1525VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
1526 const char *pLayerName, uint32_t *pCount,
1527 VkExtensionProperties *pProperties) {
Chia-I Wub02600c2016-05-20 07:11:22 +08001528 // the layer command handles VK_NULL_HANDLE just fine internally
1529 assert(physicalDevice == VK_NULL_HANDLE);
Chia-I Wu2b481252016-04-28 14:21:13 +08001530 return swapchain::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount, pProperties);
Chia-I Wu516b5082016-04-28 11:27:46 +08001531}
1532
1533VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char *funcName) {
Chia-I Wufccbfe42016-04-28 14:01:30 +08001534 return swapchain::GetDeviceProcAddr(dev, funcName);
Chia-I Wu516b5082016-04-28 11:27:46 +08001535}
1536
1537VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *funcName) {
Chia-I Wufccbfe42016-04-28 14:01:30 +08001538 return swapchain::GetInstanceProcAddr(instance, funcName);
Chia-I Wu045209e2016-04-28 11:21:49 +08001539}