diff options
Diffstat (limited to 'layers/image.cpp')
| -rw-r--r-- | layers/image.cpp | 1626 |
1 files changed, 643 insertions, 983 deletions
diff --git a/layers/image.cpp b/layers/image.cpp index 56d1bb5c..a40b2f23 100644 --- a/layers/image.cpp +++ b/layers/image.cpp @@ -58,33 +58,37 @@ using namespace std; using namespace std; struct layer_data { - debug_report_data *report_data; - vector<VkDebugReportCallbackEXT> logging_callback; - VkLayerDispatchTable *device_dispatch_table; + debug_report_data *report_data; + vector<VkDebugReportCallbackEXT> logging_callback; + VkLayerDispatchTable* device_dispatch_table; VkLayerInstanceDispatchTable *instance_dispatch_table; - VkPhysicalDevice physicalDevice; - VkPhysicalDeviceProperties physicalDeviceProperties; + VkPhysicalDevice physicalDevice; + VkPhysicalDeviceProperties physicalDeviceProperties; unordered_map<VkImage, IMAGE_STATE> imageMap; - layer_data() - : report_data(nullptr), device_dispatch_table(nullptr), - instance_dispatch_table(nullptr), physicalDevice(0), - physicalDeviceProperties(){}; + layer_data() : + report_data(nullptr), + device_dispatch_table(nullptr), + instance_dispatch_table(nullptr), + physicalDevice(0), + physicalDeviceProperties() + {}; }; -static unordered_map<void *, layer_data *> layer_data_map; +static unordered_map<void*, layer_data*> layer_data_map; -static void InitImage(layer_data *data, - const VkAllocationCallbacks *pAllocator) { +static void InitImage(layer_data *data, const VkAllocationCallbacks *pAllocator) +{ VkDebugReportCallbackEXT callback; uint32_t report_flags = getLayerOptionFlags("ImageReportFlags", 0); uint32_t debug_action = 0; - getLayerOptionEnum("ImageDebugAction", (uint32_t *)&debug_action); - if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) { + getLayerOptionEnum("ImageDebugAction", (uint32_t *) &debug_action); + if(debug_action & VK_DBG_LAYER_ACTION_LOG_MSG) + { FILE *log_output = NULL; - const char *option_str = getLayerOption("ImageLogFilename"); + const char* option_str = getLayerOption("ImageLogFilename"); log_output = getLayerLogOutput(option_str, "Image"); VkDebugReportCallbackCreateInfoEXT dbgInfo; memset(&dbgInfo, 0, sizeof(dbgInfo)); @@ -92,8 +96,7 @@ static void InitImage(layer_data *data, dbgInfo.pfnCallback = log_callback; dbgInfo.pUserData = log_output; dbgInfo.flags = report_flags; - layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, - &callback); + layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback); data->logging_callback.push_back(callback); } @@ -103,63 +106,56 @@ static void InitImage(layer_data *data, dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT; dbgInfo.pfnCallback = win32_debug_output_msg; dbgInfo.flags = report_flags; - layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, - &callback); + layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback); data->logging_callback.push_back(callback); } } VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( - VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkDebugReportCallbackEXT *pMsgCallback) { - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - VkResult res = - my_data->instance_dispatch_table->CreateDebugReportCallbackEXT( - instance, pCreateInfo, pAllocator, pMsgCallback); + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pMsgCallback) +{ + layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); + VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback); if (res == VK_SUCCESS) { - res = layer_create_msg_callback(my_data->report_data, pCreateInfo, - pAllocator, pMsgCallback); + res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback); } return res; } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkDestroyDebugReportCallbackEXT(VkInstance instance, - VkDebugReportCallbackEXT msgCallback, - const VkAllocationCallbacks *pAllocator) { - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT( - instance, msgCallback, pAllocator); +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT msgCallback, + const VkAllocationCallbacks* pAllocator) +{ + layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); + my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator); layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator); } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkDebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objType, uint64_t object, - size_t location, int32_t msgCode, - const char *pLayerPrefix, const char *pMsg) { - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - my_data->instance_dispatch_table->DebugReportMessageEXT( - instance, flags, objType, object, location, msgCode, pLayerPrefix, - pMsg); +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objType, + uint64_t object, + size_t location, + int32_t msgCode, + const char* pLayerPrefix, + const char* pMsg) +{ + layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); + my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg); } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkInstance *pInstance) { - VkLayerInstanceCreateInfo *chain_info = - get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = - chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkCreateInstance fpCreateInstance = - (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance"); + PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; + PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance) fpGetInstanceProcAddr(NULL, "vkCreateInstance"); if (fpCreateInstance == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } @@ -171,25 +167,23 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL if (result != VK_SUCCESS) return result; - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map); + layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map); my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable; - layer_init_instance_dispatch_table( - *pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr); + layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr); my_data->report_data = debug_report_create_instance( - my_data->instance_dispatch_table, *pInstance, - pCreateInfo->enabledExtensionCount, - pCreateInfo->ppEnabledExtensionNames); + my_data->instance_dispatch_table, + *pInstance, + pCreateInfo->enabledExtensionCount, + pCreateInfo->ppEnabledExtensionNames); InitImage(my_data, pAllocator); return result; } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkDestroyInstance(VkInstance instance, - const VkAllocationCallbacks *pAllocator) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) +{ // Grab the key before the instance is destroyed. dispatch_key key = get_dispatch_key(instance); layer_data *my_data = get_my_data_ptr(key, layer_data_map); @@ -206,22 +200,17 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL layer_debug_report_destroy_instance(my_data->report_data); delete my_data->instance_dispatch_table; layer_data_map.erase(key); + } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkCreateDevice(VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { - VkLayerDeviceCreateInfo *chain_info = - get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) +{ + VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO); assert(chain_info->u.pLayerInfo); - PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = - chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = - chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; - PFN_vkCreateDevice fpCreateDevice = - (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice"); + PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr; + PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice) fpGetInstanceProcAddr(NULL, "vkCreateDevice"); if (fpCreateDevice == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } @@ -229,34 +218,28 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL // Advance the link info for the next element on the chain chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext; - VkResult result = - fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); + VkResult result = fpCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); if (result != VK_SUCCESS) { return result; } - layer_data *my_instance_data = - get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - layer_data *my_device_data = - get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map); + layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); + layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map); // Setup device dispatch table my_device_data->device_dispatch_table = new VkLayerDispatchTable; - layer_init_device_dispatch_table( - *pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr); + layer_init_device_dispatch_table(*pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr); - my_device_data->report_data = layer_debug_report_create_device( - my_instance_data->report_data, *pDevice); + my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice); my_device_data->physicalDevice = physicalDevice; - my_instance_data->instance_dispatch_table->GetPhysicalDeviceProperties( - physicalDevice, &(my_device_data->physicalDeviceProperties)); + my_instance_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, &(my_device_data->physicalDeviceProperties)); return result; } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) +{ dispatch_key key = get_dispatch_key(device); layer_data *my_data = get_my_data_ptr(key, layer_data_map); my_data->device_dispatch_table->DestroyDevice(device, pAllocator); @@ -265,196 +248,181 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL } static const VkExtensionProperties instance_extensions[] = { - {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION}}; - -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkEnumerateInstanceExtensionProperties(const char *pLayerName, - uint32_t *pCount, - VkExtensionProperties *pProperties) { - return util_GetExtensionProperties(1, instance_extensions, pCount, - pProperties); + { + VK_EXT_DEBUG_REPORT_EXTENSION_NAME, + VK_EXT_DEBUG_REPORT_SPEC_VERSION + } +}; + +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char *pLayerName, + uint32_t *pCount, + VkExtensionProperties* pProperties) +{ + return util_GetExtensionProperties(1, instance_extensions, pCount, pProperties); } -static const VkLayerProperties pc_global_layers[] = {{ - "VK_LAYER_LUNARG_image", VK_API_VERSION, VK_MAKE_VERSION(0, 1, 0), - "Validation layer: image", -}}; +static const VkLayerProperties pc_global_layers[] = { + { + "VK_LAYER_LUNARG_image", + VK_API_VERSION, + VK_MAKE_VERSION(0, 1, 0), + "Validation layer: image", + } +}; -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkEnumerateInstanceLayerProperties(uint32_t *pCount, - VkLayerProperties *pProperties) { +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t *pCount, + VkLayerProperties* pProperties) +{ return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), - pc_global_layers, pCount, pProperties); + pc_global_layers, + pCount, pProperties); } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, - const char *pLayerName, - uint32_t *pCount, - VkExtensionProperties *pProperties) { +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pCount, + VkExtensionProperties* pProperties) +{ // Image does not have any physical device extensions if (pLayerName == NULL) { dispatch_key key = get_dispatch_key(physicalDevice); layer_data *my_data = get_my_data_ptr(key, layer_data_map); VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; - return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, - pCount, pProperties); + return pTable->EnumerateDeviceExtensionProperties( + physicalDevice, + NULL, + pCount, + pProperties); } else { return util_GetExtensionProperties(0, NULL, pCount, pProperties); } } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, - uint32_t *pCount, - VkLayerProperties *pProperties) { +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pCount, + VkLayerProperties* pProperties) +{ // ParamChecker's physical device layers are the same as global - return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), - pc_global_layers, pCount, pProperties); + return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), pc_global_layers, + pCount, pProperties); } // Start of the Image layer proper // Returns TRUE if a format is a depth-compatible format -bool is_depth_format(VkFormat format) { +bool is_depth_format(VkFormat format) +{ bool result = VK_FALSE; switch (format) { - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D32_SFLOAT: - case VK_FORMAT_S8_UINT: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - result = VK_TRUE; - break; - default: - break; + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_S8_UINT: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + result = VK_TRUE; + break; + default: + break; } return result; } -static inline uint32_t validate_VkImageLayoutKHR(VkImageLayout input_value) { +static inline uint32_t validate_VkImageLayoutKHR(VkImageLayout input_value) +{ return ((validate_VkImageLayout(input_value) == 1) || (input_value == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR)); } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkImage *pImage) { - VkBool32 skipCall = VK_FALSE; - VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + VkBool32 skipCall = VK_FALSE; + VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; VkImageFormatProperties ImageFormatProperties = {0}; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(device), layer_data_map); - VkPhysicalDevice physicalDevice = device_data->physicalDevice; - layer_data *phy_dev_data = - get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkPhysicalDevice physicalDevice = device_data->physicalDevice; + layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - if (pCreateInfo->format != VK_FORMAT_UNDEFINED) { + if (pCreateInfo->format != VK_FORMAT_UNDEFINED) + { VkFormatProperties properties; - phy_dev_data->instance_dispatch_table - ->GetPhysicalDeviceFormatProperties( + phy_dev_data->instance_dispatch_table->GetPhysicalDeviceFormatProperties( device_data->physicalDevice, pCreateInfo->format, &properties); - if ((properties.linearTilingFeatures) == 0 && - (properties.optimalTilingFeatures == 0)) { - char const str[] = "vkCreateImage parameter, VkFormat " - "pCreateInfo->format, contains unsupported " - "format"; - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str); + if ((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) + { + char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains unsupported format"; + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", str); } } - // Internal call to get format info. Still goes through layers, could - // potentially go directly to ICD. - phy_dev_data->instance_dispatch_table - ->GetPhysicalDeviceImageFormatProperties( - physicalDevice, pCreateInfo->format, pCreateInfo->imageType, - pCreateInfo->tiling, pCreateInfo->usage, pCreateInfo->flags, - &ImageFormatProperties); + // Internal call to get format info. Still goes through layers, could potentially go directly to ICD. + phy_dev_data->instance_dispatch_table->GetPhysicalDeviceImageFormatProperties( + physicalDevice, pCreateInfo->format, pCreateInfo->imageType, pCreateInfo->tiling, + pCreateInfo->usage, pCreateInfo->flags, &ImageFormatProperties); - VkDeviceSize imageGranularity = - device_data->physicalDeviceProperties.limits.bufferImageGranularity; + VkDeviceSize imageGranularity = device_data->physicalDeviceProperties.limits.bufferImageGranularity; imageGranularity = imageGranularity == 1 ? 0 : imageGranularity; - if ((pCreateInfo->extent.depth > ImageFormatProperties.maxExtent.depth) || - (pCreateInfo->extent.width > ImageFormatProperties.maxExtent.width) || + if ((pCreateInfo->extent.depth > ImageFormatProperties.maxExtent.depth) || + (pCreateInfo->extent.width > ImageFormatProperties.maxExtent.width) || (pCreateInfo->extent.height > ImageFormatProperties.maxExtent.height)) { - skipCall |= log_msg( - phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, - IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", - "CreateImage extents exceed allowable limits for format: " - "Width = %d Height = %d Depth = %d: Limits for Width = %d Height " - "= %d Depth = %d for format %s.", - pCreateInfo->extent.width, pCreateInfo->extent.height, - pCreateInfo->extent.depth, ImageFormatProperties.maxExtent.width, - ImageFormatProperties.maxExtent.height, - ImageFormatProperties.maxExtent.depth, - string_VkFormat(pCreateInfo->format)); + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, + IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", + "CreateImage extents exceed allowable limits for format: " + "Width = %d Height = %d Depth = %d: Limits for Width = %d Height = %d Depth = %d for format %s.", + pCreateInfo->extent.width, pCreateInfo->extent.height, pCreateInfo->extent.depth, + ImageFormatProperties.maxExtent.width, ImageFormatProperties.maxExtent.height, ImageFormatProperties.maxExtent.depth, + string_VkFormat(pCreateInfo->format)); + } - uint64_t totalSize = - ((uint64_t)pCreateInfo->extent.width * - (uint64_t)pCreateInfo->extent.height * - (uint64_t)pCreateInfo->extent.depth * - (uint64_t)pCreateInfo->arrayLayers * - (uint64_t)pCreateInfo->samples * - (uint64_t)vk_format_get_size(pCreateInfo->format) + - (uint64_t)imageGranularity) & - ~(uint64_t)imageGranularity; + uint64_t totalSize = ((uint64_t)pCreateInfo->extent.width * + (uint64_t)pCreateInfo->extent.height * + (uint64_t)pCreateInfo->extent.depth * + (uint64_t)pCreateInfo->arrayLayers * + (uint64_t)pCreateInfo->samples * + (uint64_t)vk_format_get_size(pCreateInfo->format) + + (uint64_t)imageGranularity ) & ~(uint64_t)imageGranularity; if (totalSize > ImageFormatProperties.maxResourceSize) { - skipCall |= - log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, - __LINE__, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", - "CreateImage resource size exceeds allowable maximum " - "Image resource size = %#" PRIxLEAST64 - ", maximum resource size = %#" PRIxLEAST64 " ", - totalSize, ImageFormatProperties.maxResourceSize); + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, + IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", + "CreateImage resource size exceeds allowable maximum " + "Image resource size = %#" PRIxLEAST64 ", maximum resource size = %#" PRIxLEAST64 " ", + totalSize, ImageFormatProperties.maxResourceSize); } if (pCreateInfo->mipLevels > ImageFormatProperties.maxMipLevels) { - skipCall |= - log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, - __LINE__, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", - "CreateImage mipLevels=%d exceeds allowable maximum " - "supported by format of %d", - pCreateInfo->mipLevels, ImageFormatProperties.maxMipLevels); + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, + IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", + "CreateImage mipLevels=%d exceeds allowable maximum supported by format of %d", + pCreateInfo->mipLevels, ImageFormatProperties.maxMipLevels); } if (pCreateInfo->arrayLayers > ImageFormatProperties.maxArrayLayers) { - skipCall |= log_msg( - phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, - IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", - "CreateImage arrayLayers=%d exceeds allowable maximum supported by " - "format of %d", - pCreateInfo->arrayLayers, ImageFormatProperties.maxArrayLayers); + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, + IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", + "CreateImage arrayLayers=%d exceeds allowable maximum supported by format of %d", + pCreateInfo->arrayLayers, ImageFormatProperties.maxArrayLayers); } if ((pCreateInfo->samples & ImageFormatProperties.sampleCounts) == 0) { - skipCall |= - log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, - __LINE__, IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", - "CreateImage samples %s is not supported by format 0x%.8X", - string_VkSampleCountFlagBits(pCreateInfo->samples), - ImageFormatProperties.sampleCounts); + skipCall |= log_msg(phy_dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)pImage, __LINE__, + IMAGE_INVALID_FORMAT_LIMITS_VIOLATION, "Image", + "CreateImage samples %s is not supported by format 0x%.8X", + string_VkSampleCountFlagBits(pCreateInfo->samples), ImageFormatProperties.sampleCounts); } if (VK_FALSE == skipCall) { - result = device_data->device_dispatch_table->CreateImage( - device, pCreateInfo, pAllocator, pImage); + result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage); } if (result == VK_SUCCESS) { device_data->imageMap[*pImage] = IMAGE_STATE(pCreateInfo); @@ -462,350 +430,213 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL return result; } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkDestroyImage(VkDevice device, VkImage image, - const VkAllocationCallbacks *pAllocator) { - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(device), layer_data_map); +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); device_data->imageMap.erase(image); device_data->device_dispatch_table->DestroyImage(device, image, pAllocator); } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkCreateRenderPass(VkDevice device, - const VkRenderPassCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkRenderPass *pRenderPass) { - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(device), layer_data_map); +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); VkBool32 skipCall = VK_FALSE; - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - if (pCreateInfo->pAttachments[i].format != VK_FORMAT_UNDEFINED) { + for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) + { + if(pCreateInfo->pAttachments[i].format != VK_FORMAT_UNDEFINED) + { VkFormatProperties properties; - get_my_data_ptr(get_dispatch_key(my_data->physicalDevice), - layer_data_map) - ->instance_dispatch_table->GetPhysicalDeviceFormatProperties( - my_data->physicalDevice, - pCreateInfo->pAttachments[i].format, &properties); - - if ((properties.linearTilingFeatures) == 0 && - (properties.optimalTilingFeatures == 0)) { + get_my_data_ptr(get_dispatch_key(my_data->physicalDevice), layer_data_map)->instance_dispatch_table->GetPhysicalDeviceFormatProperties( + my_data->physicalDevice, pCreateInfo->pAttachments[i].format, &properties); + + if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0)) + { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VkFormat in " - "pCreateInfo->pAttachments[" << i - << "], contains unsupported format"; - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid - skipCall |= log_msg( - my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_FORMAT_UNSUPPORTED, "IMAGE", "%s", ss.str().c_str()); + ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], contains unsupported format"; + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_FORMAT_UNSUPPORTED, "IMAGE", "%s", ss.str().c_str()); } } } - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - if (!validate_VkImageLayoutKHR( - pCreateInfo->pAttachments[i].initialLayout) || - !validate_VkImageLayoutKHR( - pCreateInfo->pAttachments[i].finalLayout)) { + for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) + { + if(!validate_VkImageLayoutKHR(pCreateInfo->pAttachments[i].initialLayout) || + !validate_VkImageLayoutKHR(pCreateInfo->pAttachments[i].finalLayout)) + { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VkImageLayout in " - "pCreateInfo->pAttachments[" << i << "], is unrecognized"; - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid - skipCall |= - log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments[" << i << "], is unrecognized"; + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - if (!validate_VkAttachmentLoadOp(pCreateInfo->pAttachments[i].loadOp)) { + for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) + { + if(!validate_VkAttachmentLoadOp(pCreateInfo->pAttachments[i].loadOp)) + { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in " - "pCreateInfo->pAttachments[" << i << "], is unrecognized"; - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid - skipCall |= - log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments[" << i << "], is unrecognized"; + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - if (!validate_VkAttachmentStoreOp( - pCreateInfo->pAttachments[i].storeOp)) { + for(uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) + { + if(!validate_VkAttachmentStoreOp(pCreateInfo->pAttachments[i].storeOp)) + { std::stringstream ss; - ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in " - "pCreateInfo->pAttachments[" << i << "], is unrecognized"; - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid - skipCall |= - log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments[" << i << "], is unrecognized"; + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } // Any depth buffers specified as attachments? bool depthFormatPresent = VK_FALSE; - for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { - depthFormatPresent |= - is_depth_format(pCreateInfo->pAttachments[i].format); + for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) + { + depthFormatPresent |= is_depth_format(pCreateInfo->pAttachments[i].format); } if (depthFormatPresent == VK_FALSE) { - // No depth attachment is present, validate that subpasses set - // depthStencilAttachment to VK_ATTACHMENT_UNUSED; + // No depth attachment is present, validate that subpasses set depthStencilAttachment to VK_ATTACHMENT_UNUSED; for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) { if (pCreateInfo->pSubpasses[i].pDepthStencilAttachment && - pCreateInfo->pSubpasses[i] - .pDepthStencilAttachment->attachment != - VK_ATTACHMENT_UNUSED) { + pCreateInfo->pSubpasses[i].pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) { std::stringstream ss; - ss << "vkCreateRenderPass has no depth/stencil attachment, yet " - "subpass[" << i - << "] has VkSubpassDescription::depthStencilAttachment " - "value that is not VK_ATTACHMENT_UNUSED"; - skipCall |= - log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_RENDERPASS_INVALID_DS_ATTACHMENT, "IMAGE", - "%s", ss.str().c_str()); + ss << "vkCreateRenderPass has no depth/stencil attachment, yet subpass[" << i << "] has VkSubpassDescription::depthStencilAttachment value that is not VK_ATTACHMENT_UNUSED"; + skipCall |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_RENDERPASS_INVALID_DS_ATTACHMENT, "IMAGE", "%s", ss.str().c_str()); } } } if (skipCall) return VK_ERROR_VALIDATION_FAILED_EXT; - VkResult result = my_data->device_dispatch_table->CreateRenderPass( - device, pCreateInfo, pAllocator, pRenderPass); + VkResult result = my_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); return result; } -VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL - vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, - VkImageView *pView) { +VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); auto imageEntry = device_data->imageMap.find(pCreateInfo->image); if (imageEntry != device_data->imageMap.end()) { - if (pCreateInfo->subresourceRange.baseMipLevel >= - imageEntry->second.mipLevels) { + if (pCreateInfo->subresourceRange.baseMipLevel >= imageEntry->second.mipLevels) { std::stringstream ss; - ss << "vkCreateImageView called with baseMipLevel " - << pCreateInfo->subresourceRange.baseMipLevel << " for image " - << pCreateInfo->image << " that only has " - << imageEntry->second.mipLevels << " mip levels."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel + << " for image " << pCreateInfo->image << " that only has " << imageEntry->second.mipLevels << " mip levels."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } - if (pCreateInfo->subresourceRange.baseArrayLayer >= - imageEntry->second.arraySize) { + if (pCreateInfo->subresourceRange.baseArrayLayer >= imageEntry->second.arraySize) { std::stringstream ss; - ss << "vkCreateImageView called with baseArrayLayer " - << pCreateInfo->subresourceRange.baseArrayLayer << " for image " - << pCreateInfo->image << " that only has " - << imageEntry->second.arraySize << " mip levels."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image " + << pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } if (!pCreateInfo->subresourceRange.levelCount) { std::stringstream ss; - ss << "vkCreateImageView called with 0 in " - "pCreateInfo->subresourceRange.levelCount."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.levelCount."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } if (!pCreateInfo->subresourceRange.layerCount) { std::stringstream ss; - ss << "vkCreateImageView called with 0 in " - "pCreateInfo->subresourceRange.layerCount."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); + ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.layerCount."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } - VkImageCreateFlags imageFlags = imageEntry->second.flags; - VkFormat imageFormat = imageEntry->second.format; - VkFormat ivciFormat = pCreateInfo->format; - VkImageAspectFlags aspectMask = - pCreateInfo->subresourceRange.aspectMask; + VkImageCreateFlags imageFlags = imageEntry->second.flags; + VkFormat imageFormat = imageEntry->second.format; + VkFormat ivciFormat = pCreateInfo->format; + VkImageAspectFlags aspectMask = pCreateInfo->subresourceRange.aspectMask; // Validate VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT state if (imageFlags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) { - // Format MUST be compatible (in the same format compatibility - // class) as the format the image was created with - if (vk_format_get_compatibility_class(imageFormat) != - vk_format_get_compatibility_class(ivciFormat)) { + // Format MUST be compatible (in the same format compatibility class) as the format the image was created with + if (vk_format_get_compatibility_class(imageFormat) != vk_format_get_compatibility_class(ivciFormat)) { std::stringstream ss; - ss << "vkCreateImageView(): ImageView format " - << string_VkFormat(ivciFormat) - << " is not in the same format compatibility class as image " - "(" << (uint64_t)pCreateInfo->image << ") format " - << string_VkFormat(imageFormat) - << ". Images created with the " - "VK_IMAGE_CREATE_MUTABLE_FORMAT BIT " - << "can support ImageViews with differing formats but they " - "must be in the same compatibility class."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + ss << "vkCreateImageView(): ImageView format " << string_VkFormat(ivciFormat) << " is not in the same format compatibility class as image (" << + (uint64_t)pCreateInfo->image << ") format " << string_VkFormat(imageFormat) << ". Images created with the VK_IMAGE_CREATE_MUTABLE_FORMAT BIT " << + "can support ImageViews with differing formats but they must be in the same compatibility class."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } } else { // Format MUST be IDENTICAL to the format the image was created with if (imageFormat != ivciFormat) { std::stringstream ss; - ss << "vkCreateImageView() format " - << string_VkFormat(ivciFormat) << " differs from image " - << (uint64_t)pCreateInfo->image << " format " - << string_VkFormat(imageFormat) - << ". Formats MUST be IDENTICAL unless " - "VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image " - "creation."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, + ss << "vkCreateImageView() format " << string_VkFormat(ivciFormat) << " differs from image " << (uint64_t)pCreateInfo->image << " format " << + string_VkFormat(imageFormat) << ". Formats MUST be IDENTICAL unless VK_IMAGE_CREATE_MUTABLE_FORMAT BIT was set on image creation."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__, IMAGE_VIEW_CREATE_ERROR, "IMAGE", "%s", ss.str().c_str()); } } - // Validate correct image aspect bits for desired formats and format - // consistency + // Validate correct image aspect bits for desired formats and format consistency if (vk_format_is_color(imageFormat)) { - if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != - VK_IMAGE_ASPECT_COLOR_BIT) { + if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) { std::stringstream ss; - ss << "vkCreateImageView: Color image formats must have the " - "VK_IMAGE_ASPECT_COLOR_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != aspectMask) { std::stringstream ss; - ss << "vkCreateImageView: Color image formats must have ONLY " - "the VK_IMAGE_ASPECT_COLOR_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if (VK_FALSE == vk_format_is_color(ivciFormat)) { std::stringstream ss; - ss << "vkCreateImageView: The image view's format can differ " - "from the parent image's format, but both must be " - << "color formats. ImageFormat is " - << string_VkFormat(imageFormat) << " ImageViewFormat is " - << string_VkFormat(ivciFormat); - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); + ss << "vkCreateImageView: The image view's format can differ from the parent image's format, but both must be " + << "color formats. ImageFormat is " << string_VkFormat(imageFormat) << " ImageViewFormat is " << string_VkFormat(ivciFormat); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); } - // TODO: Uncompressed formats are compatible if they occupy they - // same number of bits per pixel. - // Compressed formats are compatible if the only difference - // between them is the numerical type of - // the uncompressed pixels (e.g. signed vs. unsigned, or sRGB - // vs. UNORM encoding). - } else if (vk_format_is_depth_and_stencil(imageFormat)) { - if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | - VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) { + // TODO: Uncompressed formats are compatible if they occupy they same number of bits per pixel. + // Compressed formats are compatible if the only difference between them is the numerical type of + // the uncompressed pixels (e.g. signed vs. unsigned, or sRGB vs. UNORM encoding). + } else if (vk_format_is_depth_and_stencil(imageFormat)) { + if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) == 0) { std::stringstream ss; - ss << "vkCreateImageView: Depth/stencil image formats must " - "have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and " - "VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Depth/stencil image formats must have at least one of VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } - if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | - VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) { + if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) { std::stringstream ss; - ss << "vkCreateImageView: Combination depth/stencil image " - "formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and " - "VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } - } else if (vk_format_is_depth_only(imageFormat)) { - if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != - VK_IMAGE_ASPECT_DEPTH_BIT) { + } else if (vk_format_is_depth_only(imageFormat)) { + if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) { std::stringstream ss; - ss << "vkCreateImageView: Depth-only image formats must have " - "the VK_IMAGE_ASPECT_DEPTH_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspectMask) { std::stringstream ss; - ss << "vkCreateImageView: Depth-only image formats can have " - "only the VK_IMAGE_ASPECT_DEPTH_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } - } else if (vk_format_is_stencil_only(imageFormat)) { - if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != - VK_IMAGE_ASPECT_STENCIL_BIT) { + } else if (vk_format_is_stencil_only(imageFormat)) { + if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) { std::stringstream ss; - ss << "vkCreateImageView: Stencil-only image formats must have " - "the VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspectMask) { std::stringstream ss; - ss << "vkCreateImageView: Stencil-only image formats can have " - "only the VK_IMAGE_ASPECT_STENCIL_BIT set"; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - (uint64_t)pCreateInfo->image, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCreateImageView: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)pCreateInfo->image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } } @@ -814,81 +645,74 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL return VK_ERROR_VALIDATION_FAILED_EXT; } - VkResult result = device_data->device_dispatch_table->CreateImageView( - device, pCreateInfo, pAllocator, pView); + VkResult result = device_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView); return result; } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue *pColor, uint32_t rangeCount, - const VkImageSubresourceRange *pRanges) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue *pColor, + uint32_t rangeCount, + const VkImageSubresourceRange *pRanges) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // For each range, image aspect must be color only for (uint32_t i = 0; i < rangeCount; i++) { if (pRanges[i].aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { - char const str[] = "vkCmdClearColorImage aspectMasks for all " - "subresource ranges must be set to " - "VK_IMAGE_ASPECT_COLOR_BIT"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); + char const str[] = "vkCmdClearColorImage aspectMasks for all subresource ranges must be set to VK_IMAGE_ASPECT_COLOR_BIT"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdClearColorImage( - commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + device_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, + pColor, rangeCount, pRanges); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue *pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange *pRanges) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue *pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange *pRanges) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); // For each range, Image aspect must be depth or stencil or both for (uint32_t i = 0; i < rangeCount; i++) { - if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != - VK_IMAGE_ASPECT_DEPTH_BIT) && - ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != - VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = "vkCmdClearDepthStencilImage aspectMasks for " - "all subresource ranges must be " - "set to VK_IMAGE_ASPECT_DEPTH_BIT and/or " - "VK_IMAGE_ASPECT_STENCIL_BIT"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); + if (((pRanges[i].aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) && + ((pRanges[i].aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) + { + char const str[] = "vkCmdClearDepthStencilImage aspectMasks for all subresource ranges must be " + "set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdClearDepthStencilImage( - commandBuffer, image, imageLayout, pDepthStencil, rangeCount, - pRanges); + device_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer, + image, imageLayout, pDepthStencil, rangeCount, pRanges); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageCopy *pRegions) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy *pRegions) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); auto srcImageEntry = device_data->imageMap.find(srcImage); auto dstImageEntry = device_data->imageMap.find(dstImage); @@ -897,262 +721,201 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL // For each region, src aspect mask must match dest aspect mask // For each region, color aspects cannot be mixed with depth/stencil aspects for (uint32_t i = 0; i < regionCount; i++) { - if (pRegions[i].srcSubresource.layerCount == 0) { - char const str[] = "vkCmdCopyImage: number of layers in source " - "subresource is zero"; + if(pRegions[i].srcSubresource.layerCount == 0) + { + char const str[] = "vkCmdCopyImage: number of layers in source subresource is zero"; // TODO: Verify against Valid Use section of spec - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if (pRegions[i].dstSubresource.layerCount == 0) { - char const str[] = "vkCmdCopyImage: number of layers in " - "destination subresource is zero"; + if(pRegions[i].dstSubresource.layerCount == 0) + { + char const str[] = "vkCmdCopyImage: number of layers in destination subresource is zero"; // TODO: Verify against Valid Use section of spec - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if (pRegions[i].srcSubresource.layerCount != - pRegions[i].dstSubresource.layerCount) { - char const str[] = "vkCmdCopyImage: number of layers in source and " - "destination subresources must match"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) + { + char const str[] = "vkCmdCopyImage: number of layers in source and destination subresources must match"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if (pRegions[i].srcSubresource.aspectMask != - pRegions[i].dstSubresource.aspectMask) { - char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for " - "each region must match"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if (pRegions[i].srcSubresource.aspectMask != pRegions[i].dstSubresource.aspectMask) { + char const str[] = "vkCmdCopyImage: Src and dest aspectMasks for each region must match"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if ((pRegions[i].srcSubresource.aspectMask & - VK_IMAGE_ASPECT_COLOR_BIT) && - (pRegions[i].srcSubresource.aspectMask & - (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) { - char const str[] = "vkCmdCopyImage aspectMask cannot specify both " - "COLOR and DEPTH/STENCIL aspects"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); + if ((pRegions[i].srcSubresource.aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) && + (pRegions[i].srcSubresource.aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT))) { + char const str[] = "vkCmdCopyImage aspectMask cannot specify both COLOR and DEPTH/STENCIL aspects"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } - if ((srcImageEntry != device_data->imageMap.end()) && - (dstImageEntry != device_data->imageMap.end())) { - if (srcImageEntry->second.imageType != - dstImageEntry->second.imageType) { - char const str[] = "vkCmdCopyImage called with unmatched source " - "and dest image types."; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str); + if ((srcImageEntry != device_data->imageMap.end()) + && (dstImageEntry != device_data->imageMap.end())) { + if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) { + char const str[] = "vkCmdCopyImage called with unmatched source and dest image types."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str); } // Check that format is same size or exact stencil/depth if (is_depth_format(srcImageEntry->second.format)) { if (srcImageEntry->second.format != dstImageEntry->second.format) { - char const str[] = "vkCmdCopyImage called with unmatched " - "source and dest image depth/stencil " - "formats."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); + char const str[] = "vkCmdCopyImage called with unmatched source and dest image depth/stencil formats."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); } } else { size_t srcSize = vk_format_get_size(srcImageEntry->second.format); size_t destSize = vk_format_get_size(dstImageEntry->second.format); if (srcSize != destSize) { - char const str[] = "vkCmdCopyImage called with unmatched " - "source and dest image format sizes."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); + char const str[] = "vkCmdCopyImage called with unmatched source and dest image format sizes."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); } } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdCopyImage( - commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, - regionCount, pRegions); + device_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage, + srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } } -VKAPI_ATTR void VKAPI_CALL - vkCmdClearAttachments(VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment *pAttachments, - uint32_t rectCount, const VkClearRect *pRects) { +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects) +{ VkBool32 skipCall = VK_FALSE; VkImageAspectFlags aspectMask; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); for (uint32_t i = 0; i < attachmentCount; i++) { aspectMask = pAttachments[i].aspectMask; if (aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) { if (aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { - // VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this - // attachment - char const str[] = "vkCmdClearAttachments aspectMask [%d] must " - "set only VK_IMAGE_ASPECT_COLOR_BIT of a " - "color attachment."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i); + // VK_IMAGE_ASPECT_COLOR_BIT is not the only bit set for this attachment + char const str[] = "vkCmdClearAttachments aspectMask [%d] must set only VK_IMAGE_ASPECT_COLOR_BIT of a color attachment."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i); } } else { // Image aspect must be depth or stencil or both - if (((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != - VK_IMAGE_ASPECT_DEPTH_BIT) && - ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != - VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = "vkCmdClearAttachments aspectMask [%d] must " - "be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or " - "VK_IMAGE_ASPECT_STENCIL_BIT"; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i); + if (((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) && + ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT)) + { + char const str[] = "vkCmdClearAttachments aspectMask [%d] must be set to VK_IMAGE_ASPECT_DEPTH_BIT and/or VK_IMAGE_ASPECT_STENCIL_BIT"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str, i); } } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdClearAttachments( - commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + device_data->device_dispatch_table->CmdClearAttachments(commandBuffer, + attachmentCount, pAttachments, rectCount, pRects); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy *pRegions) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy *pRegions) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - // For each region, the number of layers in the image subresource should not - // be zero + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + // For each region, the number of layers in the image subresource should not be zero // Image aspect must be ONE OF color, depth, stencil for (uint32_t i = 0; i < regionCount; i++) { - if (pRegions[i].imageSubresource.layerCount == 0) { - char const str[] = "vkCmdCopyImageToBuffer: number of layers in " - "image subresource is zero"; - // TODO: Verify against Valid Use section of spec, if this case - // yields undefined results, then it's an error - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].imageSubresource.layerCount == 0) + { + char const str[] = "vkCmdCopyImageToBuffer: number of layers in image subresource is zero"; + // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } VkImageAspectFlags aspectMask = pRegions[i].imageSubresource.aspectMask; if ((aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) && (aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) && (aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each " - "region must specify only COLOR or DEPTH or " - "STENCIL"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); + char const str[] = "vkCmdCopyImageToBuffer: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdCopyImageToBuffer( - commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, - pRegions); + device_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer, + srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, - VkImage dstImage, VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy *pRegions) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy *pRegions) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - // For each region, the number of layers in the image subresource should not - // be zero + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + // For each region, the number of layers in the image subresource should not be zero // Image aspect must be ONE OF color, depth, stencil for (uint32_t i = 0; i < regionCount; i++) { - if (pRegions[i].imageSubresource.layerCount == 0) { - char const str[] = "vkCmdCopyBufferToImage: number of layers in " - "image subresource is zero"; - // TODO: Verify against Valid Use section of spec, if this case - // yields undefined results, then it's an error - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].imageSubresource.layerCount == 0) + { + char const str[] = "vkCmdCopyBufferToImage: number of layers in image subresource is zero"; + // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } VkImageAspectFlags aspectMask = pRegions[i].imageSubresource.aspectMask; if ((aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) && (aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) && (aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) { - char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each " - "region must specify only COLOR or DEPTH or " - "STENCIL"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); + char const str[] = "vkCmdCopyBufferToImage: aspectMasks for each region must specify only COLOR or DEPTH or STENCIL"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdCopyBufferToImage( - commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, - pRegions); + device_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer, + srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageBlit *pRegions, VkFilter filter) { - VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - - auto srcImageEntry = device_data->imageMap.find(srcImage); +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit *pRegions, + VkFilter filter) +{ + VkBool32 skipCall = VK_FALSE; + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + + auto srcImageEntry = device_data->imageMap.find(srcImage); auto dstImageEntry = device_data->imageMap.find(dstImage); - if ((srcImageEntry != device_data->imageMap.end()) && + if ((srcImageEntry != device_data->imageMap.end()) && (dstImageEntry != device_data->imageMap.end())) { VkFormat srcFormat = srcImageEntry->second.format; @@ -1162,17 +925,11 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL if ((vk_format_is_sint(srcFormat) && !vk_format_is_sint(dstFormat)) || (vk_format_is_uint(srcFormat) && !vk_format_is_uint(dstFormat))) { std::stringstream ss; - ss << "vkCmdBlitImage: If one of srcImage and dstImage images has " - "signed/unsigned integer format, " - << "the other one must also have signed/unsigned integer " - "format. " - << "Source format is " << string_VkFormat(srcFormat) - << " Destination format is " << string_VkFormat(dstFormat); - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT, - "IMAGE", "%s", ss.str().c_str()); + ss << "vkCmdBlitImage: If one of srcImage and dstImage images has signed/unsigned integer format, " + << "the other one must also have signed/unsigned integer format. " + << "Source format is " << string_VkFormat(srcFormat) << " Destination format is " << string_VkFormat(dstFormat); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); } // Validate aspect bits and formats for depth/stencil images @@ -1180,118 +937,70 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vk_format_is_depth_or_stencil(dstFormat)) { if (srcFormat != dstFormat) { std::stringstream ss; - ss << "vkCmdBlitImage: If one of srcImage and dstImage images " - "has a format of depth, stencil or depth " - << "stencil, the other one must have exactly the same " - "format. " - << "Source format is " << string_VkFormat(srcFormat) - << " Destination format is " << string_VkFormat(dstFormat); - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT, - "IMAGE", "%s", ss.str().c_str()); + ss << "vkCmdBlitImage: If one of srcImage and dstImage images has a format of depth, stencil or depth " + << "stencil, the other one must have exactly the same format. " + << "Source format is " << string_VkFormat(srcFormat) << " Destination format is " << string_VkFormat(dstFormat); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FORMAT, "IMAGE", "%s", ss.str().c_str()); } for (uint32_t i = 0; i < regionCount; i++) { - if (pRegions[i].srcSubresource.layerCount == 0) { - char const str[] = "vkCmdBlitImage: number of layers in " - "source subresource is zero"; - // TODO: Verify against Valid Use section of spec, if this - // case yields undefined results, then it's an error - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].srcSubresource.layerCount == 0) + { + char const str[] = "vkCmdBlitImage: number of layers in source subresource is zero"; + // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if (pRegions[i].dstSubresource.layerCount == 0) { - char const str[] = "vkCmdBlitImage: number of layers in " - "destination subresource is zero"; - // TODO: Verify against Valid Use section of spec, if this - // case yields undefined results, then it's an error - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].dstSubresource.layerCount == 0) + { + char const str[] = "vkCmdBlitImage: number of layers in destination subresource is zero"; + // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if (pRegions[i].srcSubresource.layerCount != - pRegions[i].dstSubresource.layerCount) { - char const str[] = "vkCmdBlitImage: number of layers in " - "source and destination subresources " - "must match"; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].srcSubresource.layerCount != pRegions[i].dstSubresource.layerCount) + { + char const str[] = "vkCmdBlitImage: number of layers in source and destination subresources must match"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - VkImageAspectFlags srcAspect = - pRegions[i].srcSubresource.aspectMask; - VkImageAspectFlags dstAspect = - pRegions[i].dstSubresource.aspectMask; + VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspectMask; + VkImageAspectFlags dstAspect = pRegions[i].dstSubresource.aspectMask; if (srcAspect != dstAspect) { std::stringstream ss; - ss << "vkCmdBlitImage: Image aspects of depth/stencil " - "images should match"; - // TODO: Verify against Valid Use section of spec, if this - // case yields undefined results, then it's an error - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCmdBlitImage: Image aspects of depth/stencil images should match"; + // TODO: Verify against Valid Use section of spec, if this case yields undefined results, then it's an error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } if (vk_format_is_depth_and_stencil(srcFormat)) { - if ((srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) && - (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT)) { + if ((srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) && (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT)) { std::stringstream ss; - ss << "vkCmdBlitImage: Combination depth/stencil image " - "formats must have only one of " - "VK_IMAGE_ASPECT_DEPTH_BIT " - << "and VK_IMAGE_ASPECT_STENCIL_BIT set in srcImage " - "and dstImage"; - skipCall |= log_msg( - device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCmdBlitImage: Combination depth/stencil image formats must have only one of VK_IMAGE_ASPECT_DEPTH_BIT " + << "and VK_IMAGE_ASPECT_STENCIL_BIT set in srcImage and dstImage"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_stencil_only(srcFormat)) { if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) { std::stringstream ss; - ss << "vkCmdBlitImage: Stencil-only image formats must " - "have only the VK_IMAGE_ASPECT_STENCIL_BIT " + ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT " << "set in both the srcImage and dstImage"; - skipCall |= log_msg( - device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_depth_only(srcFormat)) { if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) { std::stringstream ss; - ss << "vkCmdBlitImage: Depth-only image formats must " - "have only the VK_IMAGE_ASPECT_DEPTH " + ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH " << "set in both the srcImage and dstImage"; - skipCall |= log_msg( - device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } } @@ -1302,173 +1011,140 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vk_format_is_int(srcFormat)) { if (filter != VK_FILTER_NEAREST) { std::stringstream ss; - ss << "vkCmdBlitImage: If the format of srcImage is a depth, " - "stencil, depth stencil or integer-based format " + ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, depth stencil or integer-based format " << "then filter must be VK_FILTER_NEAREST."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FILTER, - "IMAGE", "%s", ss.str().c_str()); + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_FILTER, "IMAGE", "%s", ss.str().c_str()); } } } - device_data->device_dispatch_table->CmdBlitImage( - commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, - regionCount, pRegions, filter); + device_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage, + srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); } VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier *pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier *pImageMemoryBarriers) { + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier *pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier *pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier *pImageMemoryBarriers) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); - - for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { - VkImageMemoryBarrier const *const barrier = - (VkImageMemoryBarrier const *const) & pImageMemoryBarriers[i]; - if (barrier->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) { - if (barrier->subresourceRange.layerCount == 0) { + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + + for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) + { + VkImageMemoryBarrier const*const barrier = (VkImageMemoryBarrier const*const) &pImageMemoryBarriers[i]; + if (barrier->sType == VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER) + { + if (barrier->subresourceRange.layerCount == 0) + { std::stringstream ss; - ss << "vkCmdPipelineBarrier called with 0 in ppMemoryBarriers[" - << i << "]->subresourceRange.layerCount."; - skipCall |= log_msg(device_data->report_data, - VK_DEBUG_REPORT_ERROR_BIT_EXT, - (VkDebugReportObjectTypeEXT)0, 0, __LINE__, - IMAGE_INVALID_IMAGE_RESOURCE, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkCmdPipelineBarrier called with 0 in ppMemoryBarriers[" << i << "]->subresourceRange.layerCount."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, + 0, __LINE__, IMAGE_INVALID_IMAGE_RESOURCE, "IMAGE", "%s", ss.str().c_str()); } } } - if (skipCall) { + if (skipCall) + { return; } - device_data->device_dispatch_table->CmdPipelineBarrier( - commandBuffer, srcStageMask, dstStageMask, dependencyFlags, - memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, - pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + device_data->device_dispatch_table->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, + memoryBarrierCount, pMemoryBarriers, + bufferMemoryBarrierCount, pBufferMemoryBarriers, + imageMemoryBarrierCount, pImageMemoryBarriers); } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, - VkImageLayout srcImageLayout, VkImage dstImage, - VkImageLayout dstImageLayout, uint32_t regionCount, - const VkImageResolve *pRegions) { +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve *pRegions) +{ VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); + layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map); auto srcImageEntry = device_data->imageMap.find(srcImage); auto dstImageEntry = device_data->imageMap.find(dstImage); - // For each region, the number of layers in the image subresource should not - // be zero + // For each region, the number of layers in the image subresource should not be zero // For each region, src and dest image aspect must be color only for (uint32_t i = 0; i < regionCount; i++) { - if (pRegions[i].srcSubresource.layerCount == 0) { - char const str[] = "vkCmdResolveImage: number of layers in source " - "subresource is zero"; - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid/error - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].srcSubresource.layerCount == 0) + { + char const str[] = "vkCmdResolveImage: number of layers in source subresource is zero"; + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid/error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if (pRegions[i].dstSubresource.layerCount == 0) { - char const str[] = "vkCmdResolveImage: number of layers in " - "destination subresource is zero"; - - // TODO: Verify against Valid Use section of spec. Generally if - // something yield an undefined result, it's invalid/error - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); + if(pRegions[i].dstSubresource.layerCount == 0) + { + char const str[] = "vkCmdResolveImage: number of layers in destination subresource is zero"; + + // TODO: Verify against Valid Use section of spec. Generally if something yield an undefined result, it's invalid/error + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_WARN_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_ASPECT, "IMAGE", str); } - if ((pRegions[i].srcSubresource.aspectMask != - VK_IMAGE_ASPECT_COLOR_BIT) || - (pRegions[i].dstSubresource.aspectMask != - VK_IMAGE_ASPECT_COLOR_BIT)) { - char const str[] = "vkCmdResolveImage: src and dest aspectMasks " - "for each region must specify only " - "VK_IMAGE_ASPECT_COLOR_BIT"; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); + if ((pRegions[i].srcSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) || + (pRegions[i].dstSubresource.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT)) { + char const str[] = "vkCmdResolveImage: src and dest aspectMasks for each region must specify only VK_IMAGE_ASPECT_COLOR_BIT"; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", str); } } - if ((srcImageEntry != device_data->imageMap.end()) && + if ((srcImageEntry != device_data->imageMap.end()) && (dstImageEntry != device_data->imageMap.end())) { if (srcImageEntry->second.format != dstImageEntry->second.format) { - char const str[] = "vkCmdResolveImage called with unmatched source " - "and dest formats."; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); + char const str[] = "vkCmdResolveImage called with unmatched source and dest formats."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_FORMAT, "IMAGE", str); } - if (srcImageEntry->second.imageType != - dstImageEntry->second.imageType) { - char const str[] = "vkCmdResolveImage called with unmatched source " - "and dest image types."; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str); + if (srcImageEntry->second.imageType != dstImageEntry->second.imageType) { + char const str[] = "vkCmdResolveImage called with unmatched source and dest image types."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_MISMATCHED_IMAGE_TYPE, "IMAGE", str); } if (srcImageEntry->second.samples == VK_SAMPLE_COUNT_1_BIT) { - char const str[] = "vkCmdResolveImage called with source sample " - "count less than 2."; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str); + char const str[] = "vkCmdResolveImage called with source sample count less than 2."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str); } if (dstImageEntry->second.samples != VK_SAMPLE_COUNT_1_BIT) { - char const str[] = "vkCmdResolveImage called with dest sample " - "count greater than 1."; - skipCall |= - log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - (uint64_t)commandBuffer, __LINE__, - IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str); + char const str[] = "vkCmdResolveImage called with dest sample count greater than 1."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + (uint64_t)commandBuffer, __LINE__, IMAGE_INVALID_RESOLVE_SAMPLES, "IMAGE", str); } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->CmdResolveImage( - commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, - regionCount, pRegions); + device_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage, + srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkGetImageSubresourceLayout(VkDevice device, VkImage image, - const VkImageSubresource *pSubresource, - VkSubresourceLayout *pLayout) { - VkBool32 skipCall = VK_FALSE; - layer_data *device_data = - get_my_data_ptr(get_dispatch_key(device), layer_data_map); - VkFormat format; +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource *pSubresource, + VkSubresourceLayout *pLayout) +{ + VkBool32 skipCall = VK_FALSE; + layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); + VkFormat format; auto imageEntry = device_data->imageMap.find(image); @@ -1478,89 +1154,75 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL if (vk_format_is_color(format)) { if (pSubresource->aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) { std::stringstream ss; - ss << "vkGetImageSubresourceLayout: For color formats, the " - "aspectMask field of VkImageSubresource must be " - "VK_IMAGE_ASPECT_COLOR."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)image, - __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkGetImageSubresourceLayout: For color formats, the aspectMask field of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } else if (vk_format_is_depth_or_stencil(format)) { if ((pSubresource->aspectMask != VK_IMAGE_ASPECT_DEPTH_BIT) && (pSubresource->aspectMask != VK_IMAGE_ASPECT_STENCIL_BIT)) { std::stringstream ss; - ss << "vkGetImageSubresourceLayout: For depth/stencil formats, " - "the aspectMask selects either the depth or stencil " - "image aspectMask."; - skipCall |= log_msg( - device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, (uint64_t)image, - __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", - ss.str().c_str()); + ss << "vkGetImageSubresourceLayout: For depth/stencil formats, the aspectMask selects either the depth or stencil image aspectMask."; + skipCall |= log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + (uint64_t)image, __LINE__, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", "%s", ss.str().c_str()); } } } if (VK_FALSE == skipCall) { - device_data->device_dispatch_table->GetImageSubresourceLayout( - device, image, pSubresource, pLayout); + device_data->device_dispatch_table->GetImageSubresourceLayout(device, + image, pSubresource, pLayout); } } -VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL - vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties *pProperties) { - layer_data *phy_dev_data = - get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); - phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties( - physicalDevice, pProperties); +VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) +{ + layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map); + phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, pProperties); } -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL - vkGetDeviceProcAddr(VkDevice device, const char *funcName) { +VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName) +{ if (!strcmp(funcName, "vkGetDeviceProcAddr")) - return (PFN_vkVoidFunction)vkGetDeviceProcAddr; + return (PFN_vkVoidFunction) vkGetDeviceProcAddr; if (!strcmp(funcName, "vkDestroyDevice")) - return (PFN_vkVoidFunction)vkDestroyDevice; + return (PFN_vkVoidFunction) vkDestroyDevice; if (!strcmp(funcName, "vkCreateImage")) - return (PFN_vkVoidFunction)vkCreateImage; + return (PFN_vkVoidFunction) vkCreateImage; if (!strcmp(funcName, "vkDestroyImage")) - return (PFN_vkVoidFunction)vkDestroyImage; + return (PFN_vkVoidFunction) vkDestroyImage; if (!strcmp(funcName, "vkCreateImageView")) - return (PFN_vkVoidFunction)vkCreateImageView; + return (PFN_vkVoidFunction) vkCreateImageView; if (!strcmp(funcName, "vkCreateRenderPass")) - return (PFN_vkVoidFunction)vkCreateRenderPass; + return (PFN_vkVoidFunction) vkCreateRenderPass; if (!strcmp(funcName, "vkCmdClearColorImage")) - return (PFN_vkVoidFunction)vkCmdClearColorImage; + return (PFN_vkVoidFunction) vkCmdClearColorImage; if (!strcmp(funcName, "vkCmdClearDepthStencilImage")) - return (PFN_vkVoidFunction)vkCmdClearDepthStencilImage; + return (PFN_vkVoidFunction) vkCmdClearDepthStencilImage; if (!strcmp(funcName, "vkCmdClearAttachments")) - return (PFN_vkVoidFunction)vkCmdClearAttachments; + return (PFN_vkVoidFunction) vkCmdClearAttachments; if (!strcmp(funcName, "vkCmdCopyImage")) - return (PFN_vkVoidFunction)vkCmdCopyImage; + return (PFN_vkVoidFunction) vkCmdCopyImage; if (!strcmp(funcName, "vkCmdCopyImageToBuffer")) - return (PFN_vkVoidFunction)vkCmdCopyImageToBuffer; + return (PFN_vkVoidFunction) vkCmdCopyImageToBuffer; if (!strcmp(funcName, "vkCmdCopyBufferToImage")) - return (PFN_vkVoidFunction)vkCmdCopyBufferToImage; + return (PFN_vkVoidFunction) vkCmdCopyBufferToImage; if (!strcmp(funcName, "vkCmdBlitImage")) - return (PFN_vkVoidFunction)vkCmdBlitImage; + return (PFN_vkVoidFunction) vkCmdBlitImage; if (!strcmp(funcName, "vkCmdPipelineBarrier")) - return (PFN_vkVoidFunction)vkCmdPipelineBarrier; + return (PFN_vkVoidFunction) vkCmdPipelineBarrier; if (!strcmp(funcName, "vkCmdResolveImage")) - return (PFN_vkVoidFunction)vkCmdResolveImage; + return (PFN_vkVoidFunction) vkCmdResolveImage; if (!strcmp(funcName, "vkGetImageSubresourceLayout")) - return (PFN_vkVoidFunction)vkGetImageSubresourceLayout; + return (PFN_vkVoidFunction) vkGetImageSubresourceLayout; if (device == NULL) { return NULL; } - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(device), layer_data_map); + layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map); - VkLayerDispatchTable *pTable = my_data->device_dispatch_table; + VkLayerDispatchTable* pTable = my_data->device_dispatch_table; { if (pTable->GetDeviceProcAddr == NULL) return NULL; @@ -1568,40 +1230,38 @@ VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL } } -VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL - vkGetInstanceProcAddr(VkInstance instance, const char *funcName) { +VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char* funcName) +{ if (!strcmp(funcName, "vkGetInstanceProcAddr")) - return (PFN_vkVoidFunction)vkGetInstanceProcAddr; + return (PFN_vkVoidFunction) vkGetInstanceProcAddr; if (!strcmp(funcName, "vkCreateInstance")) - return (PFN_vkVoidFunction)vkCreateInstance; + return (PFN_vkVoidFunction) vkCreateInstance; if (!strcmp(funcName, "vkDestroyInstance")) - return (PFN_vkVoidFunction)vkDestroyInstance; + return (PFN_vkVoidFunction) vkDestroyInstance; if (!strcmp(funcName, "vkCreateDevice")) - return (PFN_vkVoidFunction)vkCreateDevice; + return (PFN_vkVoidFunction) vkCreateDevice; if (!strcmp(funcName, "vkEnumerateInstanceLayerProperties")) - return (PFN_vkVoidFunction)vkEnumerateInstanceLayerProperties; + return (PFN_vkVoidFunction) vkEnumerateInstanceLayerProperties; if (!strcmp(funcName, "vkEnumerateInstanceExtensionProperties")) - return (PFN_vkVoidFunction)vkEnumerateInstanceExtensionProperties; + return (PFN_vkVoidFunction) vkEnumerateInstanceExtensionProperties; if (!strcmp(funcName, "vkEnumerateDeviceLayerProperties")) - return (PFN_vkVoidFunction)vkEnumerateDeviceLayerProperties; + return (PFN_vkVoidFunction) vkEnumerateDeviceLayerProperties; if (!strcmp(funcName, "vkEnumerateDeviceExtensionProperties")) - return (PFN_vkVoidFunction)vkEnumerateDeviceExtensionProperties; + return (PFN_vkVoidFunction) vkEnumerateDeviceExtensionProperties; if (!strcmp(funcName, "vkGetPhysicalDeviceProperties")) - return (PFN_vkVoidFunction)vkGetPhysicalDeviceProperties; + return (PFN_vkVoidFunction) vkGetPhysicalDeviceProperties; if (instance == NULL) { return NULL; } - layer_data *my_data = - get_my_data_ptr(get_dispatch_key(instance), layer_data_map); + layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map); - PFN_vkVoidFunction fptr = - debug_report_get_instance_proc_addr(my_data->report_data, funcName); - if (fptr) + PFN_vkVoidFunction fptr = debug_report_get_instance_proc_addr(my_data->report_data, funcName); + if(fptr) return fptr; - VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table; + VkLayerInstanceDispatchTable* pTable = my_data->instance_dispatch_table; if (pTable->GetInstanceProcAddr == NULL) return NULL; return pTable->GetInstanceProcAddr(instance, funcName); |