Various code formatting

Author: marleo02

layer_gpu_support/README_LAYER.md

@@ -176,11 +176,11 @@ allocated and handled by the driver.
   level that meets this bit rate requirement will be left at the original
   application setting.
 * If `disable_external_compression` option is set to `1` , all the possible measures
-  are taken so that external compression is disabled. In case is not possible to garantuee 
-  that external compression is used, the layer will return VK_ERROR_FEATURE_NOT_PRESENT.  
-  It should be set to `2` only if the application is not presenting, and is targeting vkCreateImage.
-  Option `2` is an heuristic, compression could be disabled accidentally on internal images,
-  and is also possible that it misses external images, if they lack COLOR_ATTACHMENT_BIT.
+  are taken to ensure that external compression is disabled. In case is not possible to guarantee 
+  that external compression is used, the layer will return `VK_ERROR_FEATURE_NOT_PRESENT`.  
+  Option `2`, in addition to what happens with option `1`, enables a heuristic useful when the 
+  application is not presenting; compression could be disabled accidentally on internal images, 
+  and it may also miss external images if they lack `COLOR_ATTACHMENT_BIT`. 
   Feel free to tune the heuristic to your specific use case.
 
 #### Configuration options

layer_gpu_support/source/layer_config.hpp

@@ -170,7 +170,7 @@ class LayerConfig
      * @brief External compression control for swapchains/images.
      * 0 = passthrough (default), 
      * 1 = strip compression on external images, 
-     * 2 = strip compression on external images even without presentation, using heuristic (no garantuee!)
+     * 2 = strip compression on external images even without presentation, using heuristic (no guarantee!)
      */
     int disable_external_compression() const;
 

layer_gpu_support/source/layer_device_functions.hpp

@@ -370,22 +370,20 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkCreateImage<user_tag>(VkDevice device,
                                                              const VkAllocationCallbacks* pAllocator,
                                                              VkImage* pImage);
 
-
 // Functions for swapchains
 
 /* See Vulkan API for documentation. */
 template <>
 VKAPI_ATTR VkResult VKAPI_CALL layer_vkCreateSwapchainKHR<user_tag>(VkDevice device,
                                                                     const VkSwapchainCreateInfoKHR* pCreateInfo,
                                                                     const VkAllocationCallbacks* pAllocator,
-                                                                    VkSwapchainKHR* pSwapchain
-                                                                    );
+                                                                    VkSwapchainKHR* pSwapchain);
 
 // Functions for external DMA-buf
 
+/* See Vulkan API for documentation. */
 template <>
 VKAPI_ATTR VkResult VKAPI_CALL layer_vkAllocateMemory<user_tag>(VkDevice device,
                                                                 const VkMemoryAllocateInfo* pAllocateInfo,
                                                                 const VkAllocationCallbacks* pAllocator,
-                                                                VkDeviceMemory* pMemory
-                                                                );
+                                                                VkDeviceMemory* pMemory);

layer_gpu_support/source/layer_device_functions_allocate_memory.cpp

@@ -67,46 +67,48 @@ VKAPI_ATTR VkResult VKAPI_CALL layer_vkAllocateMemory<user_tag>(
     const VkAllocationCallbacks* pAllocator,
     VkDeviceMemory* pMemory
 ) {
-    
     LAYER_TRACE(__func__);
-
-    //fprintf(stderr, "[libGPULayers] HIT %s\n", __func__); fflush(stderr);
 
-    std::unique_lock<std::mutex> lock { g_vulkanLock };
+    std::unique_lock<std::mutex> lock{g_vulkanLock};
     auto* layer = Device::retrieve(device);
     const auto& config = layer->instance->config;
 
-    int disable_external_compression = config.disable_external_compression();
+    const int disable_external_compression = config.disable_external_compression();
 
-    //absolute passthrough if feature is off
-    if (disable_external_compression == 0) {
+    // Absolute passthrough if feature is off
+    if (disable_external_compression == 0) 
+    {
         lock.unlock();
         return layer->driver.vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
     }
 
     // Scan pNext for imports that we cannot sanitize -> hard-fail to keep the 100% guarantee that we can disable external compression
-    for (const VkBaseInStructure* n = (const VkBaseInStructure*)pAllocateInfo->pNext; n; n = n->pNext) {
+    for (const auto* n = reinterpret_cast<const VkBaseInStructure*>(pAllocateInfo->pNext); n; n = n->pNext)
+    {
 
-        if (n->sType == VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID) {
-            printf("[libGPULayers] vkAllocateMemory: AHardwareBuffer IMPORT detected. "
-                   "Cannot guarantee external compression is disabled (buffer created outside Vulkan). Failing by policy.\n");
+        if (n->sType == VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID) 
+        {
+            LAYER_LOG("[libGPULayers] vkAllocateMemory: AHardwareBuffer IMPORT detected. "
+                    "Cannot guarantee external compression is disabled (buffer created outside Vulkan). Failing by policy.");
             return VK_ERROR_FEATURE_NOT_PRESENT;
         }
 
-        if (n->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR) {
-            const VkImportMemoryFdInfoKHR* fdInfo = (const VkImportMemoryFdInfoKHR*)n;
-            if (fdInfo->handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT) {
-                printf("[libGPULayers] vkAllocateMemory: DMA-BUF memory IMPORT detected (fd=%d). "
-                       "Cannot guarantee external compression (DRM modifier may imply compression). Failing by policy.\n",
-                       fdInfo->fd);
+        if (n->sType == VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR)
+        {
+            const auto* fdInfo = reinterpret_cast<const VkImportMemoryFdInfoKHR*>(n);
+
+            if (fdInfo->handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT) 
+            {
+                LAYER_LOG("[libGPULayers] vkAllocateMemory: DMA-BUF memory IMPORT detected (fd=%d). "
+                        "Cannot guarantee external compression (DRM modifier may imply compression). Failing by policy.",
+                        fdInfo->fd);
                 return VK_ERROR_FEATURE_NOT_PRESENT;
             }
         }
-
+        
     }
 
     // Release the lock to call into the driver
     lock.unlock();
     return layer->driver.vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
-
 }