Android hardware buffer import in Vulkan (#8295)

- Platform changes for the extensions
- Platform changes for the processing of the AHB

filament/backend/CMakeLists.txt

@@ -226,10 +226,12 @@ if (FILAMENT_SUPPORTS_VULKAN)
             src/vulkan/VulkanUtility.cpp
             src/vulkan/VulkanUtility.h
     )
-    if (ANDROID OR LINUX OR WIN32)
-        list(APPEND SRCS src/vulkan/platform/VulkanPlatformAndroidLinuxWindows.cpp)
+    if (LINUX OR WIN32)
+        list(APPEND SRCS src/vulkan/platform/VulkanPlatformLinuxWindows.cpp)
     elseif (APPLE OR IOS)
         list(APPEND SRCS src/vulkan/platform/VulkanPlatformApple.mm)
+    elseif (ANDROID)
+        list(APPEND SRCS src/vulkan/platform/VulkanPlatformAndroid.cpp)
     endif()
 endif()
 

filament/backend/include/backend/platforms/VulkanPlatform.h

@@ -292,8 +292,64 @@ class VulkanPlatform : public Platform, utils::PrivateImplementation<VulkanPlatf
      */
     VkQueue getProtectedGraphicsQueue() const noexcept;
 
+    struct ExternalImageMetadata {
+        /**
+         * The width of the external image
+         */
+        uint32_t width;
+
+        /**
+         * The height of the external image
+         */
+        uint32_t height;
+
+        /**
+         * The layer count of the external image
+         */
+        uint32_t layers;
+
+        /**
+         * The format of the external image
+         */
+        VkFormat format;
+
+        /**
+         * An external buffer can be protected. This tells you if it is.
+         */
+        bool isProtected;
+
+        /**
+         * The type of external format (opaque int) if used.
+         */
+        uint64_t externalFormat;
+
+        /**
+         * Image usage
+         */
+        VkImageUsageFlags usage;
+
+        /**
+         * Allocation size
+         */
+        VkDeviceSize allocationSize;
+
+        /**
+         * Heap information
+         */
+        uint32_t memoryTypeBits;
+    };
+    virtual ExternalImageMetadata getExternalImageMetadata(void* externalImage);
+
+    using ImageData = std::pair<VkImage, VkDeviceMemory>;
+    virtual ImageData createExternalImage(void* externalImage,
+            const ExternalImageMetadata& metadata);
+
 private:
     static ExtensionSet getSwapchainInstanceExtensions();
+    static ExternalImageMetadata getExternalImageMetadataImpl(void* externalImage,
+            VkDevice device);
+    static ImageData createExternalImageImpl(void* externalImage, VkDevice device,
+            const VkAllocationCallbacks* allocator, const ExternalImageMetadata& metadata);
 
     // Platform dependent helper methods
     using SurfaceBundle = std::tuple<VkSurfaceKHR, VkExtent2D>;

filament/backend/src/vulkan/VulkanDriver.cpp

@@ -544,7 +544,25 @@ void VulkanDriver::createTextureViewSwizzleR(Handle<HwTexture> th, Handle<HwText
 }
 
 void VulkanDriver::createTextureExternalImageR(Handle<HwTexture> th, backend::TextureFormat format,
-        uint32_t width, uint32_t height, backend::TextureUsage usage, void* image) {
+        uint32_t width, uint32_t height, backend::TextureUsage usage, void* externalImage) {
+    FVK_SYSTRACE_SCOPE();
+
+    const auto& metadata = mPlatform->getExternalImageMetadata(externalImage);
+    if (metadata.isProtected) {
+        usage |= backend::TextureUsage::PROTECTED;
+    }
+
+    assert_invariant(width == metadata.width);
+    assert_invariant(height == metadata.height);
+    assert_invariant(getVkFormat(format) == metadata.format);
+
+    const auto& data = mPlatform->createExternalImage(externalImage, metadata);
+
+    auto texture = resource_ptr<VulkanTexture>::make(&mResourceManager, th, mPlatform->getDevice(),
+        mAllocator, &mResourceManager, &mCommands, data.first, data.second, metadata.format,
+        1, metadata.width, metadata.height, usage, mStagePool);
+
+    texture.inc();
 }
 
 void VulkanDriver::createTextureExternalImagePlaneR(Handle<HwTexture> th,
@@ -1172,6 +1190,7 @@ TimerQueryResult VulkanDriver::getTimerQueryValue(Handle<HwTimerQuery> tqh, uint
 }
 
 void VulkanDriver::setExternalImage(Handle<HwTexture> th, void* image) {
+
 }
 
 void VulkanDriver::setExternalImagePlane(Handle<HwTexture> th, void* image, uint32_t plane) {

filament/backend/src/vulkan/VulkanSwapChain.cpp

@@ -75,15 +75,16 @@ void VulkanSwapChain::update() {
     }
     for (auto const color: bundle.colors) {
         auto colorTexture = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager,
-                device, mAllocator, mResourceManager, mCommands, color, bundle.colorFormat, 1,
-                bundle.extent.width, bundle.extent.height, TextureUsage::COLOR_ATTACHMENT,
+                device, mAllocator, mResourceManager, mCommands, color, VK_NULL_HANDLE,
+                bundle.colorFormat, 1, bundle.extent.width, bundle.extent.height, colorUsage,
                 mStagePool);
         mColors.push_back(colorTexture);
     }
 
-    mDepth = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager, device, mAllocator,
-            mResourceManager, mCommands, bundle.depth, bundle.depthFormat, 1, bundle.extent.width,
-            bundle.extent.height, TextureUsage::DEPTH_ATTACHMENT, mStagePool);
+    mDepth = fvkmemory::resource_ptr<VulkanTexture>::construct(mResourceManager, device,
+        mAllocator, mResourceManager, mCommands, bundle.depth, VK_NULL_HANDLE,
+        bundle.depthFormat, 1, bundle.extent.width, bundle.extent.height, depthUsage,
+        mStagePool);
 
     mExtent = bundle.extent;
 }

filament/backend/src/vulkan/VulkanTexture.cpp

@@ -164,14 +164,15 @@ VulkanTextureState::VulkanTextureState(VkDevice device, VmaAllocator allocator,
 // Constructor for internally passed VkImage
 VulkanTexture::VulkanTexture(VkDevice device, VmaAllocator allocator,
         fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, VkImage image,
-        VkFormat format, uint8_t samples, uint32_t width, uint32_t height, TextureUsage tusage,
-        VulkanStagePool& stagePool)
+        VkDeviceMemory memory, VkFormat format, uint8_t samples, uint32_t width,
+        uint32_t height, TextureUsage tusage, VulkanStagePool& stagePool)
     : HwTexture(SamplerType::SAMPLER_2D, 1, samples, width, height, 1, TextureFormat::UNUSED,
               tusage),
       mState(fvkmemory::resource_ptr<VulkanTextureState>::construct(resourceManager, device,
               allocator, commands, stagePool, format, imgutil::getViewType(SamplerType::SAMPLER_2D),
               1, 1, getDefaultLayoutImpl(tusage), any(usage & TextureUsage::PROTECTED))) {
     mState->mTextureImage = image;
+    mState->mTextureImageMemory = memory;
     mPrimaryViewRange = mState->mFullViewRange;
 }
 

filament/backend/src/vulkan/VulkanTexture.h

@@ -94,8 +94,8 @@ struct VulkanTexture : public HwTexture, fvkmemory::Resource {
     // The texture will never destroy the given VkImage, but it does manages its subresources.
     VulkanTexture(VkDevice device, VmaAllocator allocator,
             fvkmemory::ResourceManager* resourceManager, VulkanCommands* commands, VkImage image,
-            VkFormat format, uint8_t samples, uint32_t width, uint32_t height, TextureUsage tusage,
-            VulkanStagePool& stagePool);
+            VkDeviceMemory memory, VkFormat format, uint8_t samples, uint32_t width, uint32_t height,
+            TextureUsage tusage, VulkanStagePool& stagePool);
 
     // Constructor for creating a texture view for wrt specific mip range
     VulkanTexture(VkDevice device, VkPhysicalDevice physicalDevice, VulkanContext const& context,

filament/backend/src/vulkan/platform/VulkanPlatform.cpp

@@ -194,6 +194,15 @@ ExtensionSet getDeviceExtensions(VkPhysicalDevice device) {
 #if FVK_ENABLED(FVK_DEBUG_DEBUG_UTILS)
             VK_EXT_DEBUG_MARKER_EXTENSION_NAME,
 #endif
+    // We only support external image for Android for now, but nothing bars us from 
+    // supporting other platforms.
+#if defined(__ANDROID__)
+            VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
+            VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME,
+            VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
+            VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
+ #endif
+
             VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME,
             VK_KHR_MAINTENANCE1_EXTENSION_NAME,
             VK_KHR_MAINTENANCE2_EXTENSION_NAME,
@@ -945,6 +954,16 @@ VkQueue VulkanPlatform::getProtectedGraphicsQueue() const noexcept {
     return mImpl->mProtectedGraphicsQueue;
 }
 
+VulkanPlatform::ExternalImageMetadata VulkanPlatform::getExternalImageMetadata(
+        void* externalImage) {
+    return getExternalImageMetadataImpl(externalImage, mImpl->mDevice);
+}
+
+VulkanPlatform::ImageData VulkanPlatform::createExternalImage(void* externalImage,
+            const ExternalImageMetadata& metadata) {
+    return createExternalImageImpl(externalImage, mImpl->mDevice, nullptr, metadata);
+}
+
 #undef SWAPCHAIN_RET_FUNC
 
 }// namespace filament::backend