From 601d21296e13f63e9c3fee8efae757ddfd0a6a67 Mon Sep 17 00:00:00 2001 From: Unknown <0.tamas.marton@gmail.com> Date: Sun, 13 May 2018 19:29:47 +0100 Subject: [PATCH] format --- driver/AlignedAllocator.h | 32 +-- driver/CustomAssert.h | 20 +- driver/driver.c | 226 +++++++++---------- driver/kernelInterface.c | 448 +++++++++++++++++++------------------- driver/modeset.c | 58 ++--- driver/vkExt.h | 18 +- test/test.cpp | 4 +- 7 files changed, 403 insertions(+), 403 deletions(-) diff --git a/driver/AlignedAllocator.h b/driver/AlignedAllocator.h index a84e417..8f9471c 100644 --- a/driver/AlignedAllocator.h +++ b/driver/AlignedAllocator.h @@ -8,31 +8,31 @@ extern "C" { void* alignedAlloc( unsigned bytes, unsigned alignment ) { - if( !bytes ) - { - return 0; - } + if( !bytes ) + { + return 0; + } - const unsigned maxBytes = 1024 * 1024 * 1024; //1GB is max on RPi + const unsigned maxBytes = 1024 * 1024 * 1024; //1GB is max on RPi - if( bytes > maxBytes ) - { - return 0; //bad alloc - } + if( bytes > maxBytes ) + { + return 0; //bad alloc + } - void* pv = 0; + void* pv = 0; - if( posix_memalign( &pv, alignment, bytes ) ) - { - pv = 0; //allocation failed - } + if( posix_memalign( &pv, alignment, bytes ) ) + { + pv = 0; //allocation failed + } - return pv; + return pv; } void alignedFree( void* p ) { - free( p ); + free( p ); } #if defined (__cplusplus) diff --git a/driver/CustomAssert.h b/driver/CustomAssert.h index 1fb8c29..da51ee9 100644 --- a/driver/CustomAssert.h +++ b/driver/CustomAssert.h @@ -14,17 +14,17 @@ __inline__ static void DEBUG_BREAK(void) } #ifdef DEBUG_BUILD - #define assert(expr) \ - if( expr ){} \ - else \ - { \ - printf("Assert failed: %s\n" \ - "File: %s\n" \ - "Line: %i\n", #expr, __FILE__, __LINE__); \ - DEBUG_BREAK(); \ - } +#define assert(expr) \ + if( expr ){} \ + else \ +{ \ + printf("Assert failed: %s\n" \ + "File: %s\n" \ + "Line: %i\n", #expr, __FILE__, __LINE__); \ + DEBUG_BREAK(); \ +} #else - #define assert(expr) //do nothing +#define assert(expr) //do nothing #endif #if defined (__cplusplus) diff --git a/driver/driver.c b/driver/driver.c index e333128..1bc13e6 100644 --- a/driver/driver.c +++ b/driver/driver.c @@ -364,9 +364,9 @@ int findDeviceExtension(char* name) * e.g. if the layer implementation is replaced by a different version between those calls. */ VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { assert(!pLayerName); //TODO layers ignored for now assert(pPropertyCount); @@ -399,9 +399,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( * created and returned to the application. */ VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) { assert(pInstance); assert(pCreateInfo); @@ -466,9 +466,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( * available physical devices were returned. */ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices) + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices) { assert(instance); @@ -509,8 +509,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceProperties */ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) { assert(physicalDevice); assert(pProperties); @@ -539,8 +539,8 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkGetPhysicalDeviceFeatures */ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures) + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures) { assert(physicalDevice); assert(pFeatures); @@ -552,10 +552,10 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkEnumerateDeviceExtensionProperties */ VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) { assert(physicalDevice); assert(!pLayerName); //layers ignored for now @@ -588,9 +588,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( * is less than the number of queue families available, at most pQueueFamilyPropertyCount structures will be written. */ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties) + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) { assert(physicalDevice); assert(pQueueFamilyPropertyCount); @@ -617,10 +617,10 @@ VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( * does this queue family support presentation to this surface? */ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported) + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported) { assert(pSupported); assert(surface); @@ -636,10 +636,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( * Implementation of our RPI specific "extension" */ VkResult vkCreateRpiSurfaceKHR( - VkInstance instance, - const VkRpiSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) + VkInstance instance, + const VkRpiSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) { assert(instance); //assert(pCreateInfo); //ignored for now @@ -659,9 +659,9 @@ VkResult vkCreateRpiSurfaceKHR( * (but we'll do so anyways...) */ VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator) + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator) { assert(instance); assert(surface); @@ -684,10 +684,10 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( * fail due to lack of device-specific resources (in addition to the other errors). If that occurs, vkCreateDevice will return VK_ERROR_TOO_MANY_OBJECTS. */ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice) + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice) { assert(physicalDevice); assert(pDevice); @@ -764,10 +764,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( * To get queues that were created with a non-zero flags parameter use vkGetDeviceQueue2. */ VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue) + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue) { assert(device); assert(pQueue); @@ -792,10 +792,10 @@ VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( * When created, the semaphore is in the unsignaled state. */ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore) + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore) { assert(device); assert(pSemaphore); @@ -820,9 +820,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( * capabilities the specified device supports for a swapchain created for the surface */ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { assert(physicalDevice); assert(surface); @@ -855,10 +855,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( * VK_INCOMPLETE will be returned instead of VK_SUCCESS to indicate that not all the available values were returned. */ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats) + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats) { assert(physicalDevice); assert(surface); @@ -902,10 +902,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( * VK_SUCCESS to indicate that not all the available values were returned. */ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes) + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) { assert(physicalDevice); assert(surface); @@ -942,10 +942,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkCreateSwapchainKHR */ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain) + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain) { assert(device); assert(pCreateInfo); @@ -969,10 +969,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( * indicate that not all the available values were returned. */ VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages) + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages) { assert(device); assert(swapchain); @@ -1013,10 +1013,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( * as well as operations that allocate, free, and reset command buffers or the pool itself. */ VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool) + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool) { assert(device); assert(pCreateInfo); @@ -1063,9 +1063,9 @@ VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( * the implementation must destroy all successfully created command buffer objects from this command, set all entries of the pCommandBuffers array to NULL and return the error. */ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) { assert(device); assert(pAllocateInfo); @@ -1135,8 +1135,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkBeginCommandBuffer */ VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo) + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo) { assert(commandBuffer); assert(pBeginInfo); @@ -1183,16 +1183,16 @@ VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( * If dependencyFlags includes VK_DEPENDENCY_BY_REGION_BIT, then any dependency between framebuffer-space pipeline stages is framebuffer-local - otherwise it is framebuffer-global. */ 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) { assert(commandBuffer); @@ -1205,12 +1205,12 @@ VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( * These commands are only allowed outside of a render pass instance. */ VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) { assert(commandBuffer); @@ -1224,7 +1224,7 @@ VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( * and is moved to the executable state. */ VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( - VkCommandBuffer commandBuffer) + VkCommandBuffer commandBuffer) { assert(commandBuffer); @@ -1237,12 +1237,12 @@ VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkAcquireNextImageKHR */ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex) + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex) { assert(device); assert(swapchain); @@ -1271,10 +1271,10 @@ VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( * the implementation must return VK_ERROR_DEVICE_LOST. See Lost Device. */ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence) + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence) { assert(queue); @@ -1300,8 +1300,8 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( * the set of queue operations are still considered to be enqueued and thus any semaphore to be waited on gets unsignaled when the corresponding queue operation is complete. */ VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo) + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo) { assert(queue); assert(pPresentInfo); @@ -1366,9 +1366,9 @@ VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( * allocated from commandPool recorded into it, becomes invalid. */ VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator) + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator) { assert(device); assert(commandPool); @@ -1396,9 +1396,9 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySemaphore */ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator) + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator) { assert(device); assert(semaphore); @@ -1413,9 +1413,9 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( * https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#vkDestroySwapchainKHR */ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator) + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator) { assert(device); assert(swapchain); @@ -1433,8 +1433,8 @@ VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( * first parameter of the corresponding vkCreate* or vkAllocate* command */ VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator) + VkDevice device, + const VkAllocationCallbacks* pAllocator) { assert(device); @@ -1449,8 +1449,8 @@ VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( * */ VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator) + VkInstance instance, + const VkAllocationCallbacks* pAllocator) { assert(instance); diff --git a/driver/kernelInterface.c b/driver/kernelInterface.c index ef6f1e2..ca28d45 100644 --- a/driver/kernelInterface.c +++ b/driver/kernelInterface.c @@ -42,59 +42,59 @@ static uint32_t align(uint32_t num, uint32_t alignment) int vc4_get_chip_info(int fd) { - struct drm_vc4_get_param ident0 = { - .param = DRM_VC4_PARAM_V3D_IDENT0, - }; - struct drm_vc4_get_param ident1 = { - .param = DRM_VC4_PARAM_V3D_IDENT1, - }; - int ret; + struct drm_vc4_get_param ident0 = { + .param = DRM_VC4_PARAM_V3D_IDENT0, + }; + struct drm_vc4_get_param ident1 = { + .param = DRM_VC4_PARAM_V3D_IDENT1, + }; + int ret; - ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_PARAM, &ident0); - if (ret != 0) { - if (errno == EINVAL) { - /* Backwards compatibility with 2835 kernels which + ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_PARAM, &ident0); + if (ret != 0) { + if (errno == EINVAL) { + /* Backwards compatibility with 2835 kernels which * only do V3D 2.1. */ - return 21; - } else { - printf("Couldn't get V3D IDENT0: %s\n", - strerror(errno)); - return 0; - } - } - ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_PARAM, &ident1); - if (ret != 0) { - printf("Couldn't get V3D IDENT1: %s\n", - strerror(errno)); - return 0; + return 21; + } else { + printf("Couldn't get V3D IDENT0: %s\n", + strerror(errno)); + return 0; } + } + ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_PARAM, &ident1); + if (ret != 0) { + printf("Couldn't get V3D IDENT1: %s\n", + strerror(errno)); + return 0; + } - uint32_t major = (ident0.value >> 24) & 0xff; - uint32_t minor = (ident1.value >> 0) & 0xf; - uint32_t v3d_ver = major * 10 + minor; + uint32_t major = (ident0.value >> 24) & 0xff; + uint32_t minor = (ident1.value >> 0) & 0xf; + uint32_t v3d_ver = major * 10 + minor; - if (v3d_ver != 21 && v3d_ver != 26) { - printf("V3D %d.%d not supported.\n", - v3d_ver / 10, - v3d_ver % 10); - return 0; - } + if (v3d_ver != 21 && v3d_ver != 26) { + printf("V3D %d.%d not supported.\n", + v3d_ver / 10, + v3d_ver % 10); + return 0; + } - return v3d_ver; + return v3d_ver; } int vc4_has_feature(int fd, uint32_t feature) { - struct drm_vc4_get_param p = { - .param = feature, - }; - int ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_PARAM, &p); + struct drm_vc4_get_param p = { + .param = feature, + }; + int ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_PARAM, &p); - if (ret != 0) - return 0; + if (ret != 0) + return 0; - return p.value; + return p.value; } int vc4_test_tiling(int fd) @@ -104,7 +104,7 @@ int vc4_test_tiling(int fd) * 0 cannot be a valid GEM object, so use that. */ struct drm_vc4_get_tiling get_tiling = { - .handle = 0x0, + .handle = 0x0, }; int ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_TILING, &get_tiling); if (ret == -1 && errno == ENOENT) @@ -118,29 +118,29 @@ int vc4_test_tiling(int fd) uint64_t vc4_bo_get_tiling(int fd, uint32_t bo, uint64_t mod) { struct drm_vc4_get_tiling get_tiling = { - .handle = bo, + .handle = bo, }; int ret = drmIoctl(fd, DRM_IOCTL_VC4_GET_TILING, &get_tiling); if (ret != 0) { - return DRM_FORMAT_MOD_LINEAR; + return DRM_FORMAT_MOD_LINEAR; } else if (mod == DRM_FORMAT_MOD_INVALID) { - return get_tiling.modifier; + return get_tiling.modifier; } else if (mod != get_tiling.modifier) { - printf("Modifier 0x%llx vs. tiling (0x%llx) mismatch\n", - (long long)mod, get_tiling.modifier); - return 0; + printf("Modifier 0x%llx vs. tiling (0x%llx) mismatch\n", + (long long)mod, get_tiling.modifier); + return 0; } } int vc4_bo_set_tiling(int fd, uint32_t bo, uint64_t mod) { struct drm_vc4_set_tiling set_tiling = { - .handle = bo, - .modifier = mod, + .handle = bo, + .modifier = mod, }; int ret = drmIoctl(fd, DRM_IOCTL_VC4_SET_TILING, - &set_tiling); + &set_tiling); if (ret != 0) { return 0; @@ -151,170 +151,170 @@ int vc4_bo_set_tiling(int fd, uint32_t bo, uint64_t mod) void* vc4_bo_map_unsynchronized(int fd, uint32_t bo, uint32_t size) { - uint64_t offset; - int ret; + uint64_t offset; + int ret; - //if (bo->map) - // return bo->map; + //if (bo->map) + // return bo->map; - struct drm_vc4_mmap_bo map; - memset(&map, 0, sizeof(map)); - map.handle = bo; - ret = drmIoctl(fd, DRM_IOCTL_VC4_MMAP_BO, &map); - offset = map.offset; - if (ret != 0) { - printf("map ioctl failure\n"); - return 0; - } + struct drm_vc4_mmap_bo map; + memset(&map, 0, sizeof(map)); + map.handle = bo; + ret = drmIoctl(fd, DRM_IOCTL_VC4_MMAP_BO, &map); + offset = map.offset; + if (ret != 0) { + printf("map ioctl failure\n"); + return 0; + } - void* mapPtr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, - fd, offset); - if (mapPtr == MAP_FAILED) { - printf("mmap of bo %d (offset 0x%016llx, size %d) failed\n", - bo, (long long)offset, size); - return 0; - } - //VG(VALGRIND_MALLOCLIKE_BLOCK(bo->map, bo->size, 0, false)); + void* mapPtr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, + fd, offset); + if (mapPtr == MAP_FAILED) { + printf("mmap of bo %d (offset 0x%016llx, size %d) failed\n", + bo, (long long)offset, size); + return 0; + } + //VG(VALGRIND_MALLOCLIKE_BLOCK(bo->map, bo->size, 0, false)); - return mapPtr; + return mapPtr; } static int vc4_bo_wait_ioctl(int fd, uint32_t handle, uint64_t timeout_ns) { - struct drm_vc4_wait_bo wait = { - .handle = handle, + struct drm_vc4_wait_bo wait = { + .handle = handle, .timeout_ns = timeout_ns, - }; - int ret = drmIoctl(fd, DRM_IOCTL_VC4_WAIT_BO, &wait); - if (ret == -1) - { - printf("bo wait fail: %s", strerror(errno)); - return 0; - } - else - { - return 1; - } + }; + int ret = drmIoctl(fd, DRM_IOCTL_VC4_WAIT_BO, &wait); + if (ret == -1) + { + printf("bo wait fail: %s", strerror(errno)); + return 0; + } + else + { + return 1; + } } int vc4_bo_wait(int fd, uint32_t bo, uint64_t timeout_ns) { - int ret = vc4_bo_wait_ioctl(fd, bo, timeout_ns); - if (ret) { - if (ret != -ETIME) { - fprintf(stderr, "wait failed: %d\n", ret); - } - - return 0; + int ret = vc4_bo_wait_ioctl(fd, bo, timeout_ns); + if (ret) { + if (ret != -ETIME) { + fprintf(stderr, "wait failed: %d\n", ret); } - return 1; + return 0; + } + + return 1; } static int vc4_seqno_wait_ioctl(int fd, uint64_t seqno, uint64_t timeout_ns) { - struct drm_vc4_wait_seqno wait = { - .seqno = seqno, + struct drm_vc4_wait_seqno wait = { + .seqno = seqno, .timeout_ns = timeout_ns, - }; - int ret = drmIoctl(fd, DRM_IOCTL_VC4_WAIT_SEQNO, &wait); - if (ret == -1) - { - printf("bo wait fail: %s", strerror(errno)); - return 0; - } - else - { - return 1; - } + }; + int ret = drmIoctl(fd, DRM_IOCTL_VC4_WAIT_SEQNO, &wait); + if (ret == -1) + { + printf("bo wait fail: %s", strerror(errno)); + return 0; + } + else + { + return 1; + } } int vc4_seqno_wait(int fd, uint64_t* lastFinishedSeqno, uint64_t seqno, uint64_t timeout_ns) { - if (*lastFinishedSeqno >= seqno) - return 1; + if (*lastFinishedSeqno >= seqno) + return 1; - int ret = vc4_seqno_wait_ioctl(fd, seqno, timeout_ns); - if (ret) { - if (ret != -ETIME) { - printf("wait failed: %d\n", ret); - } - - return 0; + int ret = vc4_seqno_wait_ioctl(fd, seqno, timeout_ns); + if (ret) { + if (ret != -ETIME) { + printf("wait failed: %d\n", ret); } - *lastFinishedSeqno = seqno; - return 1; + return 0; + } + + *lastFinishedSeqno = seqno; + return 1; } int vc4_bo_flink(int fd, uint32_t bo, uint32_t *name) { - struct drm_gem_flink flink = { - .handle = bo, - }; - int ret = drmIoctl(fd, DRM_IOCTL_GEM_FLINK, &flink); - if (ret) { - printf("Failed to flink bo %d: %s\n", - bo, strerror(errno)); - //free(bo); - return 0; - } + struct drm_gem_flink flink = { + .handle = bo, + }; + int ret = drmIoctl(fd, DRM_IOCTL_GEM_FLINK, &flink); + if (ret) { + printf("Failed to flink bo %d: %s\n", + bo, strerror(errno)); + //free(bo); + return 0; + } - //bo->private = false; - *name = flink.name; + //bo->private = false; + *name = flink.name; - return 1; + return 1; } uint32_t vc4_bo_alloc_shader(int fd, const void *data, uint32_t* size) { - int ret; + int ret; - uint32_t alignedSize = align(*size, ARM_PAGE_SIZE); + uint32_t alignedSize = align(*size, ARM_PAGE_SIZE); - struct drm_vc4_create_shader_bo create = { - .size = *alignedSize, + struct drm_vc4_create_shader_bo create = { + .size = *alignedSize, .data = (uintptr_t)data, - }; + }; - ret = drmIoctl(fd, DRM_IOCTL_VC4_CREATE_SHADER_BO, - &create); + ret = drmIoctl(fd, DRM_IOCTL_VC4_CREATE_SHADER_BO, + &create); - if (ret != 0) { - printf("create shader ioctl failure\n"); - return 0; - } + if (ret != 0) { + printf("create shader ioctl failure\n"); + return 0; + } - *size = alignedSize; + *size = alignedSize; - return create.handle; + return create.handle; } uint32_t vc4_bo_open_name(int fd, uint32_t name) - //uint32_t winsys_stride) +//uint32_t winsys_stride) { - struct drm_gem_open o = { - .name = name - }; - int ret = drmIoctl(fd, DRM_IOCTL_GEM_OPEN, &o); - if (ret) { - printf("Failed to open bo %d: %s\n", - name, strerror(errno)); - return 0; - } + struct drm_gem_open o = { + .name = name + }; + int ret = drmIoctl(fd, DRM_IOCTL_GEM_OPEN, &o); + if (ret) { + printf("Failed to open bo %d: %s\n", + name, strerror(errno)); + return 0; + } - return o.handle; + return o.handle; } uint32_t vc4_bo_alloc(int fd, uint32_t size, const char *name) { - int cleared_and_retried = 0; - struct drm_vc4_create_bo create; - int ret; + int cleared_and_retried = 0; + struct drm_vc4_create_bo create; + int ret; - uint32_t alignedSize = align(size, ARM_PAGE_SIZE); + uint32_t alignedSize = align(size, ARM_PAGE_SIZE); - /*bo = vc4_bo_from_cache(screen, size, name); + /*bo = vc4_bo_from_cache(screen, size, name); if (bo) { if (dump_stats) { fprintf(stderr, "Allocated %s %dkb from cache:\n", @@ -324,14 +324,14 @@ uint32_t vc4_bo_alloc(int fd, uint32_t size, const char *name) return bo; }*/ - memset(&create, 0, sizeof(create)); - create.size = alignedSize; + memset(&create, 0, sizeof(create)); + create.size = alignedSize; - ret = drmIoctl(fd, DRM_IOCTL_VC4_CREATE_BO, &create); - uint32_t handle = create.handle; + ret = drmIoctl(fd, DRM_IOCTL_VC4_CREATE_BO, &create); + uint32_t handle = create.handle; - if (ret != 0) { - /*if (!list_empty(&screen->bo_cache.time_list) && + if (ret != 0) { + /*if (!list_empty(&screen->bo_cache.time_list) && !cleared_and_retried) { cleared_and_retried = true; vc4_bo_cache_free_all(&screen->bo_cache); @@ -339,37 +339,37 @@ uint32_t vc4_bo_alloc(int fd, uint32_t size, const char *name) } free(bo);*/ - return 0; - } + return 0; + } - vc4_bo_label(screen, bo, "%s", name); + vc4_bo_label(screen, bo, "%s", name); - return handle; + return handle; } void vc4_bo_free(int fd, uint32_t bo, void* mappedAddr, uint32_t size) { - if (mappedAddr) { - munmap(mappedAddr, size); - //VG(VALGRIND_FREELIKE_BLOCK(bo->map, 0)); - } + if (mappedAddr) { + munmap(mappedAddr, size); + //VG(VALGRIND_FREELIKE_BLOCK(bo->map, 0)); + } - struct drm_gem_close c; - memset(&c, 0, sizeof(c)); - c.handle = bo; - int ret = drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &c); - if (ret != 0) - { - printf("close object %d: %s\n", bo, strerror(errno)); - } + struct drm_gem_close c; + memset(&c, 0, sizeof(c)); + c.handle = bo; + int ret = drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &c); + if (ret != 0) + { + printf("close object %d: %s\n", bo, strerror(errno)); + } } int vc4_bo_unpurgeable(int fd, uint32_t bo, int hasMadvise) { - struct drm_vc4_gem_madvise arg = { - .handle = bo, + struct drm_vc4_gem_madvise arg = { + .handle = bo, .madv = VC4_MADV_WILLNEED, - }; + }; if (!hasMadvise) return 1; @@ -382,10 +382,10 @@ int vc4_bo_unpurgeable(int fd, uint32_t bo, int hasMadvise) void vc4_bo_purgeable(int fd, uint32_t bo, int hasMadvise) { - struct drm_vc4_gem_madvise arg = { - .handle = bo, + struct drm_vc4_gem_madvise arg = { + .handle = bo, .madv = VC4_MADV_DONTNEED, - }; + }; if (hasMadvise) { @@ -398,61 +398,61 @@ void vc4_bo_label(int fd, uint32_t bo, const char* name) //TODO don't use in release! struct drm_vc4_label_bo label = { - .handle = bo, - .len = strlen(name), - .name = (uintptr_t)name, + .handle = bo, + .len = strlen(name), + .name = (uintptr_t)name, }; drmIoctl(fd, DRM_IOCTL_VC4_LABEL_BO, &label); } int vc4_bo_get_dmabuf(int fd, uint32_t bo) { - int boFd; - int ret = drmPrimeHandleToFD(fd, bo, - O_CLOEXEC, &boFd); - if (ret != 0) { - printf("Failed to export gem bo %d to dmabuf\n", - bo); - return 0; - } + int boFd; + int ret = drmPrimeHandleToFD(fd, bo, + O_CLOEXEC, &boFd); + if (ret != 0) { + printf("Failed to export gem bo %d to dmabuf\n", + bo); + return 0; + } - return boFd; + return boFd; } void* vc4_bo_map(int fd, uint32_t bo, uint32_t size) { - void* map = vc4_bo_map_unsynchronized(fd, bo, size); + void* map = vc4_bo_map_unsynchronized(fd, bo, size); - //wait infinitely - int ok = vc4_bo_wait(fd, bo, WAIT_TIMEOUT_INFINITE); - if (!ok) { - printf("BO wait for map failed\n"); - return 0; - } + //wait infinitely + int ok = vc4_bo_wait(fd, bo, WAIT_TIMEOUT_INFINITE); + if (!ok) { + printf("BO wait for map failed\n"); + return 0; + } - return map; + return map; } void vc4_cl_submit(int fd, struct drm_vc4_submit_cl submit, uint64_t* lastEmittedSeqno, uint64_t* lastFinishedSeqno) { - int ret = drmIoctl(fd, DRM_IOCTL_VC4_SUBMIT_CL, &submit); + int ret = drmIoctl(fd, DRM_IOCTL_VC4_SUBMIT_CL, &submit); - static int warned = 0; - if (ret && !warned) { - printf("Draw call returned %s. " - "Expect corruption.\n", strerror(errno)); - warned = 1; - } else if (!ret) { - *lastEmittedSeqno = submit.seqno; - } + static int warned = 0; + if (ret && !warned) { + printf("Draw call returned %s. " + "Expect corruption.\n", strerror(errno)); + warned = 1; + } else if (!ret) { + *lastEmittedSeqno = submit.seqno; + } - if (*lastEmittedSeqno - *lastFinishedSeqno > 5) { - uint64_t seqno = *lastFinishedSeqno - 5; - if (!vc4_seqno_wait(fd, - &seqno, - WAIT_TIMEOUT_INFINITE)) - { - printf("Job throttling failed\n"); - } + if (*lastEmittedSeqno - *lastFinishedSeqno > 5) { + uint64_t seqno = *lastFinishedSeqno - 5; + if (!vc4_seqno_wait(fd, + &seqno, + WAIT_TIMEOUT_INFINITE)) + { + printf("Job throttling failed\n"); } + } } diff --git a/driver/modeset.c b/driver/modeset.c index 7fa21c7..225bee4 100644 --- a/driver/modeset.c +++ b/driver/modeset.c @@ -50,11 +50,11 @@ //static struct modeset_dev *modeset_list = NULL; static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, - struct modeset_dev *dev); + struct modeset_dev *dev); static int modeset_create_fb(int fd, struct modeset_buf *buf); static void modeset_destroy_fb(int fd, struct modeset_buf *buf); static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, - struct modeset_dev *dev); + struct modeset_dev *dev); /* @@ -144,10 +144,10 @@ modeset_dev* modeset_create(int fd) iter->saved_crtc = drmModeGetCrtc(fd, iter->crtc); buf = &iter->bufs[iter->front_buf]; ret = drmModeSetCrtc(fd, iter->crtc, buf->fb, 0, 0, - &iter->conn, 1, &iter->mode); + &iter->conn, 1, &iter->mode); if (ret) printf("cannot set CRTC for connector %u (%d): %m\n", - iter->conn, errno); + iter->conn, errno); } return ret_dev; @@ -162,21 +162,21 @@ modeset_dev* modeset_create(int fd) */ static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, - struct modeset_dev *dev) + struct modeset_dev *dev) { int ret; // check if a monitor is connected if (conn->connection != DRM_MODE_CONNECTED) { printf("ignoring unused connector %u\n", - conn->connector_id); + conn->connector_id); return -ENOENT; } // check if there is at least one valid mode if (conn->count_modes == 0) { printf("no valid mode for connector %u\n", - conn->connector_id); + conn->connector_id); return -EFAULT; } @@ -187,13 +187,13 @@ static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, dev->bufs[1].width = conn->modes[0].hdisplay; dev->bufs[1].height = conn->modes[0].vdisplay; printf("mode for connector %u is %ux%u\n", - conn->connector_id, dev->bufs[0].width, dev->bufs[0].height); + conn->connector_id, dev->bufs[0].width, dev->bufs[0].height); // find a crtc for this connector ret = modeset_find_crtc(fd, res, conn, dev); if (ret) { printf("no valid crtc for connector %u\n", - conn->connector_id); + conn->connector_id); return ret; } @@ -201,7 +201,7 @@ static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, ret = modeset_create_fb(fd, &dev->bufs[0]); if (ret) { printf("cannot create framebuffer for connector %u\n", - conn->connector_id); + conn->connector_id); return ret; } @@ -209,7 +209,7 @@ static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, ret = modeset_create_fb(fd, &dev->bufs[1]); if (ret) { printf("cannot create framebuffer for connector %u\n", - conn->connector_id); + conn->connector_id); modeset_destroy_fb(fd, &dev->bufs[0]); return ret; } @@ -222,7 +222,7 @@ static int modeset_setup_dev(int fd, drmModeRes *res, drmModeConnector *conn, */ static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, - modeset_dev *dev) + modeset_dev *dev) { drmModeEncoder *enc; unsigned int i, j; @@ -263,7 +263,7 @@ static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, enc = drmModeGetEncoder(fd, conn->encoders[i]); if (!enc) { printf("cannot retrieve encoder %u:%u (%d): %m\n", - i, conn->encoders[i], errno); + i, conn->encoders[i], errno); continue; } @@ -294,7 +294,7 @@ static int modeset_find_crtc(int fd, drmModeRes *res, drmModeConnector *conn, } printf("cannot find suitable CRTC for connector %u\n", - conn->connector_id); + conn->connector_id); return -ENOENT; } @@ -320,7 +320,7 @@ static int modeset_create_fb(int fd, struct modeset_buf *buf) ret = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq); if (ret < 0) { printf("cannot create dumb buffer (%d): %m\n", - errno); + errno); return -errno; } buf->stride = creq.pitch; @@ -329,10 +329,10 @@ static int modeset_create_fb(int fd, struct modeset_buf *buf) // create framebuffer object for the dumb-buffer ret = drmModeAddFB(fd, buf->width, buf->height, 24, 32, buf->stride, - buf->handle, &buf->fb); + buf->handle, &buf->fb); if (ret) { printf("cannot create framebuffer (%d): %m\n", - errno); + errno); ret = -errno; memset(&dreq, 0, sizeof(dreq)); @@ -347,7 +347,7 @@ static int modeset_create_fb(int fd, struct modeset_buf *buf) ret = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq); if (ret) { printf("cannot map dumb buffer (%d): %m\n", - errno); + errno); ret = -errno; drmModeRmFB(fd, buf->fb); @@ -359,10 +359,10 @@ static int modeset_create_fb(int fd, struct modeset_buf *buf) // perform actual memory mapping buf->map = mmap(0, buf->size, PROT_READ | PROT_WRITE, MAP_SHARED, - fd, mreq.offset); + fd, mreq.offset); if (buf->map == MAP_FAILED) { printf("cannot mmap dumb buffer (%d): %m\n", - errno); + errno); ret = -errno; drmModeRmFB(fd, buf->fb); @@ -447,10 +447,10 @@ void modeset_swapbuffer(int fd, modeset_dev* dev, unsigned index) buf = &iter->bufs[iter->front_buf ^ 1]; ret = drmModeSetCrtc(fd, iter->crtc, buf->fb, 0, 0, - &iter->conn, 1, &iter->mode); + &iter->conn, 1, &iter->mode); if (ret) printf("cannot flip CRTC for connector %u (%d): %m\n", - iter->conn, errno); + iter->conn, errno); else iter->front_buf ^= 1; } @@ -472,13 +472,13 @@ void modeset_destroy(int fd, modeset_dev* dev) // restore saved CRTC configuration drmModeSetCrtc(fd, - iter->saved_crtc->crtc_id, - iter->saved_crtc->buffer_id, - iter->saved_crtc->x, - iter->saved_crtc->y, - &iter->conn, - 1, - &iter->saved_crtc->mode); + iter->saved_crtc->crtc_id, + iter->saved_crtc->buffer_id, + iter->saved_crtc->x, + iter->saved_crtc->y, + &iter->conn, + 1, + &iter->saved_crtc->mode); drmModeFreeCrtc(iter->saved_crtc); // destroy framebuffers diff --git a/driver/vkExt.h b/driver/vkExt.h index acb0cf0..28921c4 100644 --- a/driver/vkExt.h +++ b/driver/vkExt.h @@ -14,18 +14,18 @@ typedef enum VkRpiSurfaceCreateFlagsKHR { } VkRpiSurfaceCreateFlagsKHR; typedef struct VkRpiSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkRpiSurfaceCreateFlagsKHR flags; //reserved - //maybe include some other stuff dunno - } VkRpiSurfaceCreateInfoKHR; + VkStructureType sType; + const void* pNext; + VkRpiSurfaceCreateFlagsKHR flags; //reserved + //maybe include some other stuff dunno +} VkRpiSurfaceCreateInfoKHR; //extension name something like: VK_KHR_rpi_surface VkResult vkCreateRpiSurfaceKHR( - VkInstance instance, - const VkRpiSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); + VkInstance instance, + const VkRpiSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); #ifdef __cplusplus diff --git a/test/test.cpp b/test/test.cpp index 4220240..f04c74b 100644 --- a/test/test.cpp +++ b/test/test.cpp @@ -89,7 +89,7 @@ void mainLoop() { for(int c = 0; c < 120; ++c){ draw(); - // glfwPollEvents(); + // glfwPollEvents(); } } @@ -401,7 +401,7 @@ void createSwapChain() { // Note: AMD driver bug, though it would be nice to implement a workaround that doesn't use transfering //if (!(surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) { // std::cerr << "swap chain image does not support VK_IMAGE_TRANSFER_DST usage" << std::endl; - //assert(0); + //assert(0); //} // Determine transformation to use (preferring no transform)