tu: Implement deferred image creation for ANB and AHB

Based on 075d78115e ("panvk: implement deferred image creation"),
8aa2f1a94f ("panvk: add panvk_android_get_wsi_memory for AHB spec v8+"),
and 66bbd9eec8 ("panvk: implement AHB image deferred init and memory alloc").

Defer image initialization for both ANB alias images (gralloc v8+)
and AHB-backed images using vk_android_init_deferred_image() to
deep-copy the VkImageCreateInfo at vkCreateImage time.

For ANB alias images, tu_image_init() and tu_image_update_layout()
run at vkBindImageMemory2 time via tu_android_get_wsi_memory() when
the native buffer arrives.

For AHB images, tu_image_init() and tu_image_update_layout() run at
vkAllocateMemory time when the AHardwareBuffer handle is available
via dedicated allocation.

Signed-off-by: Valentine Burley <valentine.burley@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/40635>

src/freedreno/ci/freedreno-a618-fails.txt

@@ -500,11 +500,6 @@ vk_xfermodes3,Fail
 # Initial ANGLE failures
 angle-dEQP-GLES2.functional.shaders.algorithm.rgb_to_hsl_vertex,Fail
 
-# Android failures
-# ../src/freedreno/vulkan/tu_image.cc:512: VkResult tu_image_update_layout(struct tu_device *, struct tu_image *, uint64_t, const VkSubresourceLayout *) [CHIP = A6XX]: assertion "!image->force_linear_tile" failed
-ahb-dEQP-VK.api.external.memory.android_hardware_buffer.ahb_format_properties.image_formats.r8g8b8a8_unorm,Crash
-ahb-dEQP-VK.api.external.memory.android_hardware_buffer.ahb_format_properties_2.image_formats.r8g8b8a8_unorm,Crash
-
 # Early-fragment multisample autotune regressions
 dEQP-VK.fragment_operations.early_fragment.sample_count_early_fragment_tests_depth_alpha_to_coverage_samples_2_maintenance5,Fail
 dEQP-VK.fragment_operations.early_fragment.sample_count_early_fragment_tests_depth_alpha_to_coverage_samples_4_maintenance5,Fail

src/freedreno/vulkan/tu_device.cc

@@ -3691,6 +3691,45 @@ tu_AllocateMemory(VkDevice _device,
       mem->image = NULL;
    }
 
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+   if (mem->vk.ahardware_buffer && mem->image &&
+       vk_image_is_android_hardware_buffer(&mem->image->vk)) {
+      VkImageDrmFormatModifierExplicitCreateInfoEXT eci;
+      VkSubresourceLayout a_plane_layouts[TU_MAX_PLANE_COUNT];
+      result = vk_android_get_ahb_layout(mem->vk.ahardware_buffer, &eci,
+                                         a_plane_layouts, TU_MAX_PLANE_COUNT);
+      if (result != VK_SUCCESS) {
+         vk_device_memory_destroy(&device->vk, pAllocator, &mem->vk);
+         return result;
+      }
+
+      assert(mem->image->vk.android_deferred_create_info);
+
+      __vk_append_struct(mem->image->vk.android_deferred_create_info, &eci);
+
+      VkExternalMemoryImageCreateInfo external_info = {
+         .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+         .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+      };
+      __vk_append_struct(mem->image->vk.android_deferred_create_info,
+                         &external_info);
+
+      result = tu_image_init(device, mem->image,
+                             mem->image->vk.android_deferred_create_info);
+      if (result != VK_SUCCESS) {
+         vk_device_memory_destroy(&device->vk, pAllocator, &mem->vk);
+         return result;
+      }
+
+      result = TU_CALLX(device, tu_image_update_layout)(
+         device, mem->image, eci.drmFormatModifier, a_plane_layouts);
+      if (result != VK_SUCCESS) {
+         vk_device_memory_destroy(&device->vk, pAllocator, &mem->vk);
+         return result;
+      }
+   }
+#endif
+
    TU_RMV(heap_create, device, pAllocateInfo, mem);
 
    tu_memory_emit_report(device, mem, pAllocateInfo, VK_SUCCESS);

src/freedreno/vulkan/tu_image.cc

@@ -835,6 +835,63 @@ tu_image_init(struct tu_device *device, struct tu_image *image,
    return VK_SUCCESS;
 }
 
+/* Deferred ANB image support for ANB v8+ aliased images. */
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+static VkResult
+tu_android_get_wsi_memory(struct tu_device *dev,
+                          const VkBindImageMemoryInfo *bind_info,
+                          VkDeviceMemory *out_mem_handle)
+{
+   VK_FROM_HANDLE(tu_image, img, bind_info->image);
+   VkResult result;
+
+   assert(img->vk.android_deferred_create_info);
+
+   const VkNativeBufferANDROID *anb =
+      vk_find_struct_const(bind_info->pNext, NATIVE_BUFFER_ANDROID);
+
+   /* Inject ANB into the deferred pNext chain to leverage the existing common
+    * Android helper vk_android_get_anb_layout.
+    */
+   VkNativeBufferANDROID local_anb = *anb;
+   local_anb.pNext = img->vk.android_deferred_create_info->pNext;
+   img->vk.android_deferred_create_info->pNext = &local_anb;
+
+   VkImageDrmFormatModifierExplicitCreateInfoEXT eci;
+   VkSubresourceLayout a_plane_layouts[TU_MAX_PLANE_COUNT];
+   result = vk_android_get_anb_layout(img->vk.android_deferred_create_info,
+                                      &eci, a_plane_layouts,
+                                      TU_MAX_PLANE_COUNT);
+   if (result != VK_SUCCESS)
+      return result;
+
+   VkExternalMemoryImageCreateInfo external_info = {
+      .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+      .pNext = img->vk.android_deferred_create_info->pNext,
+      .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT,
+   };
+   img->vk.android_deferred_create_info->pNext = &external_info;
+
+   result = tu_image_init(dev, img, img->vk.android_deferred_create_info);
+   if (result != VK_SUCCESS)
+      return result;
+
+   result = TU_CALLX(dev, tu_image_update_layout)(
+      dev, img, eci.drmFormatModifier, a_plane_layouts);
+   if (result != VK_SUCCESS)
+      return result;
+
+   result = vk_android_import_anb_memory(&dev->vk, &img->vk, anb,
+                                         &dev->vk.alloc);
+   if (result != VK_SUCCESS)
+      return result;
+
+   *out_mem_handle = img->vk.anb_memory;
+
+   return VK_SUCCESS;
+}
+#endif /* VK_USE_PLATFORM_ANDROID_KHR */
+
 VKAPI_ATTR VkResult VKAPI_CALL
 tu_CreateImage(VkDevice _device,
                const VkImageCreateInfo *pCreateInfo,
@@ -859,6 +916,18 @@ tu_CreateImage(VkDevice _device,
    if (!image)
       return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
 
+   if (vk_image_is_android_native_buffer_alias(&image->vk) ||
+       vk_image_is_android_hardware_buffer(&image->vk)) {
+      result = vk_android_init_deferred_image(&device->vk, &image->vk,
+                                              pCreateInfo, alloc);
+      if (result != VK_SUCCESS) {
+         vk_image_destroy(&device->vk, alloc, &image->vk);
+         return result;
+      }
+      *pImage = tu_image_to_handle(image);
+      return VK_SUCCESS;
+   }
+
    if (pCreateInfo->tiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
       const VkImageDrmFormatModifierListCreateInfoEXT *mod_info =
          vk_find_struct_const(pCreateInfo->pNext,
@@ -905,15 +974,6 @@ tu_CreateImage(VkDevice _device,
    if (result != VK_SUCCESS)
       goto fail;
 
-   /* This section is removed by the optimizer for non-ANDROID builds */
-   if (vk_image_is_android_hardware_buffer(&image->vk)) {
-      /* At this time, an AHB handle is not yet provided.
-       * Image layout will be filled up during vkBindImageMemory2
-       */
-      *pImage = tu_image_to_handle(image);
-      return VK_SUCCESS;
-   }
-
    result = TU_CALLX(device, tu_image_update_layout)(device, image, modifier,
                                                     plane_layouts);
    if (result != VK_SUCCESS)
@@ -1013,37 +1073,27 @@ tu_image_bind(struct tu_device *device,
    VkResult result;
 
    if (!mem) {
-#if DETECT_OS_ANDROID
+      VkDeviceMemory mem_handle;
-      /* TODO handle VkNativeBufferANDROID */
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
-      UNREACHABLE("VkBindImageMemoryInfo with no memory");
+      result = tu_android_get_wsi_memory(device, bind_info, &mem_handle);
+      if (result != VK_SUCCESS)
+         return result;
 #else
       const VkBindImageMemorySwapchainInfoKHR *swapchain_info =
          vk_find_struct_const(bind_info->pNext,
                               BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
       assert(swapchain_info && swapchain_info->swapchain != VK_NULL_HANDLE);
-      mem = tu_device_memory_from_handle(wsi_common_get_memory(
+      mem_handle = wsi_common_get_memory(swapchain_info->swapchain,
-         swapchain_info->swapchain, swapchain_info->imageIndex));
+                                         swapchain_info->imageIndex);
+#endif
+      mem = tu_device_memory_from_handle(mem_handle);
       /* memoryOffset is ignored when VkBindImageMemorySwapchainInfoKHR is
        * present, so we follow common wsi to set the offset to 0 here.
        */
       offset = 0;
-#endif
    }
 
    assert(mem);
-   if (vk_image_is_android_hardware_buffer(&image->vk)) {
-      VkImageDrmFormatModifierExplicitCreateInfoEXT eci;
-      VkSubresourceLayout a_plane_layouts[TU_MAX_PLANE_COUNT];
-      result = vk_android_get_ahb_layout(mem->vk.ahardware_buffer, &eci,
-                                         a_plane_layouts, TU_MAX_PLANE_COUNT);
-      if (result != VK_SUCCESS)
-         return result;
-
-      result = TU_CALLX(device, tu_image_update_layout)(
-         device, image, eci.drmFormatModifier, a_plane_layouts);
-      if (result != VK_SUCCESS)
-         return result;
-   }
    image->mem = mem;
    image->mem_offset = offset;
    image->iova = mem->iova + offset;