[Tizen] Support render texture for vulkan + impeller (#17)

Add new struct FlutterVulkanTexture  for embedder :
```
typedef struct {
  /// Handle to the VkImage that is owned by the embedder. The engine will
  /// bind this image for writing the frame.
  FlutterVulkanImageHandle image;
  /// The VkDeviceMemory that backs the iamge.
  FlutterVulkanDeviceMemoryHandle image_memory;
  /// The VkFormat of the image (for example: VK_FORMAT_R8G8B8A8_UNORM).
  uint32_t format;
  /// User data to be returned on the invocation of the destruction callback.
  void* user_data;
  /// Callback invoked (on an engine managed thread) that asks the embedder to
  /// collect the texture.
  VoidCallback destruction_callback;
  /// Optional parameters for texture height/width, default is 0, non-zero means
  /// the texture has the specified width/height.
  /// Width of the texture.
  size_t width;
  /// Height of the texture.
  size_t height;
} FlutterVulkanTexture;
```
The implement of [texture
source](https://github.com/flutter-tizen/flutter/pull/17/files#diff-7955a8522a753162869f2e8ca0017a83f4854b60800c844202e70c3aa00ff0c9R5-R204)
refer to the solution of android
platform(https://github.com/flutter-tizen/flutter/blob/flutter-3.35.3/engine/src/flutter/impeller/renderer/backend/vulkan/android/ahb_texture_source_vk.cc)

and I have submitted the code [Support render texture for
embedder](xiaowei-guan/embedder@6a94746),
I will create a new PR after[ support vulkan
backend](flutter-tizen/embedder#110) PR
released.

Author: xiaowei-guan

engine/src/flutter/shell/platform/embedder/BUILD.gn

@@ -167,6 +167,8 @@ template("embedder_source_set") {
 
     if (embedder_enable_vulkan) {
       sources += [
+        "embedder_external_texture_vulkan.cc",
+        "embedder_external_texture_vulkan.h",
         "embedder_surface_vulkan.cc",
         "embedder_surface_vulkan.h",
       ]
@@ -175,6 +177,8 @@ template("embedder_source_set") {
         sources += [
           "embedder_surface_vulkan_impeller.cc",
           "embedder_surface_vulkan_impeller.h",
+          "embedder_external_texture_source_vulkan.cc",
+          "embedder_external_texture_source_vulkan.h",
         ]
       }
 

engine/src/flutter/shell/platform/embedder/embedder.cc

@@ -2342,6 +2342,27 @@ FlutterEngineResult FlutterEngineInitialize(size_t version,
           external_texture_metal_callback);
     }
   }
+#endif
+#ifdef SHELL_ENABLE_VULKAN
+  if (config->type == kVulkan) {
+    const FlutterVulkanRendererConfig* vulkan_config = &config->vulkan;
+    if (auto callback = SAFE_ACCESS(vulkan_config,
+                                    external_texture_frame_callback, nullptr)) {
+      auto external_texture_vulkan_callback =
+          [ptr = callback, user_data](
+              int64_t texture_identifier, size_t width,
+              size_t height) -> std::unique_ptr<FlutterVulkanTexture> {
+        std::unique_ptr<FlutterVulkanTexture> texture =
+            std::make_unique<FlutterVulkanTexture>();
+        if (!ptr(user_data, texture_identifier, width, height, texture.get())) {
+          return nullptr;
+        }
+        return texture;
+      };
+      external_texture_resolver = std::make_unique<ExternalTextureResolver>(
+          external_texture_vulkan_callback);
+    }
+  }
 #endif
   auto custom_task_runners = SAFE_ACCESS(args, custom_task_runners, nullptr);
   auto thread_config_callback = [&custom_task_runners](

engine/src/flutter/shell/platform/embedder/embedder.h

@@ -924,6 +924,9 @@ typedef void* FlutterVulkanQueueHandle;
 /// Alias for VkImage.
 typedef uint64_t FlutterVulkanImageHandle;
 
+/// Alias for VkDeviceMemory.
+typedef uint64_t FlutterVulkanDeviceMemoryHandle;
+
 typedef struct {
   /// The size of this struct. Must be sizeof(FlutterVulkanImage).
   size_t struct_size;
@@ -952,6 +955,36 @@ typedef bool (*FlutterVulkanPresentCallback)(
     void* /* user data */,
     const FlutterVulkanImage* /* image */);
 
+typedef struct {
+  /// Handle to the VkImage that is owned by the embedder. The engine will
+  /// bind this image for writing the frame.
+  FlutterVulkanImageHandle image;
+  /// The VkDeviceMemory that backs the iamge.
+  FlutterVulkanDeviceMemoryHandle image_memory;
+  /// The VkFormat of the image (for example: VK_FORMAT_R8G8B8A8_UNORM).
+  uint32_t format;
+  /// User data to be returned on the invocation of the destruction callback.
+  void* user_data;
+  /// Callback invoked (on an engine managed thread) that asks the embedder to
+  /// collect the texture.
+  VoidCallback destruction_callback;
+  /// Optional parameters for texture height/width, default is 0, non-zero means
+  /// the texture has the specified width/height.
+  /// Width of the texture.
+  size_t width;
+  /// Height of the texture.
+  size_t height;
+} FlutterVulkanTexture;
+
+/// Callback to provide an external texture for a given texture_id.
+/// See: external_texture_frame_callback.
+typedef bool (*FlutterVulkanTextureFrameCallback)(
+    void* /* user data */,
+    int64_t /* texture identifier */,
+    size_t /* width */,
+    size_t /* height */,
+    FlutterVulkanTexture* /* texture out */);
+
 typedef struct {
   /// The size of this struct. Must be sizeof(FlutterVulkanRendererConfig).
   size_t struct_size;
@@ -1015,7 +1048,11 @@ typedef struct {
   /// without any additional synchronization.
   /// Not used if a FlutterCompositor is supplied in FlutterProjectArgs.
   FlutterVulkanPresentCallback present_image_callback;
-
+  /// When the embedder specifies that a texture has a frame available, the
+  /// engine will call this method (on an internal engine managed thread) so
+  /// that external texture details can be supplied to the engine for subsequent
+  /// composition.
+  FlutterVulkanTextureFrameCallback external_texture_frame_callback;
 } FlutterVulkanRendererConfig;
 
 typedef struct {

engine/src/flutter/shell/platform/embedder/embedder_external_texture_resolver.cc

@@ -21,6 +21,12 @@ EmbedderExternalTextureResolver::EmbedderExternalTextureResolver(
     : metal_callback_(std::move(metal_callback)) {}
 #endif
 
+#ifdef SHELL_ENABLE_VULKAN
+EmbedderExternalTextureResolver::EmbedderExternalTextureResolver(
+    EmbedderExternalTextureVulkan::ExternalTextureCallback vulkan_callback)
+    : vulkan_callback_(std::move(vulkan_callback)) {}
+#endif
+
 std::unique_ptr<Texture>
 EmbedderExternalTextureResolver::ResolveExternalTexture(int64_t texture_id) {
 #ifdef SHELL_ENABLE_GL
@@ -37,6 +43,13 @@ EmbedderExternalTextureResolver::ResolveExternalTexture(int64_t texture_id) {
   }
 #endif
 
+#ifdef SHELL_ENABLE_VULKAN
+  if (vulkan_callback_) {
+    return std::make_unique<EmbedderExternalTextureVulkan>(texture_id,
+                                                           vulkan_callback_);
+  }
+#endif
+
   return nullptr;
 }
 
@@ -53,6 +66,12 @@ bool EmbedderExternalTextureResolver::SupportsExternalTextures() {
   }
 #endif
 
+#ifdef SHELL_ENABLE_VULKAN
+  if (vulkan_callback_) {
+    return true;
+  }
+#endif
+
   return false;
 }
 

engine/src/flutter/shell/platform/embedder/embedder_external_texture_resolver.h

@@ -17,6 +17,10 @@
 #include "flutter/shell/platform/embedder/embedder_external_texture_metal.h"
 #endif
 
+#ifdef SHELL_ENABLE_VULKAN
+#include "flutter/shell/platform/embedder/embedder_external_texture_vulkan.h"
+#endif
+
 namespace flutter {
 class EmbedderExternalTextureResolver {
  public:
@@ -34,6 +38,11 @@ class EmbedderExternalTextureResolver {
       EmbedderExternalTextureMetal::ExternalTextureCallback metal_callback);
 #endif
 
+#ifdef SHELL_ENABLE_VULKAN
+  explicit EmbedderExternalTextureResolver(
+      EmbedderExternalTextureVulkan::ExternalTextureCallback vulkan_callback);
+#endif
+
   std::unique_ptr<Texture> ResolveExternalTexture(int64_t texture_id);
 
   bool SupportsExternalTextures();
@@ -47,6 +56,9 @@ class EmbedderExternalTextureResolver {
   EmbedderExternalTextureMetal::ExternalTextureCallback metal_callback_;
 #endif
 
+#ifdef SHELL_ENABLE_VULKAN
+  EmbedderExternalTextureVulkan::ExternalTextureCallback vulkan_callback_;
+#endif
   FML_DISALLOW_COPY_AND_ASSIGN(EmbedderExternalTextureResolver);
 };
 }  // namespace flutter

engine/src/flutter/shell/platform/embedder/embedder_external_texture_source_vulkan.cc

@@ -0,0 +1,204 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/platform/embedder/embedder_external_texture_source_vulkan.h"
+
+#include "impeller/renderer/backend/vulkan/allocator_vk.h"
+#include "impeller/renderer/backend/vulkan/context_vk.h"
+#include "impeller/renderer/backend/vulkan/texture_source_vk.h"
+#include "impeller/renderer/backend/vulkan/yuv_conversion_library_vk.h"
+#include "vulkan/vulkan.hpp"
+
+namespace flutter {
+
+bool RequiresYCBCRConversion(impeller::vk::Format format) {
+  switch (format) {
+    case impeller::vk::Format::eG8B8R83Plane420Unorm:
+    case impeller::vk::Format::eG8B8R82Plane420Unorm:
+    case impeller::vk::Format::eG8B8R83Plane422Unorm:
+    case impeller::vk::Format::eG8B8R82Plane422Unorm:
+    case impeller::vk::Format::eG8B8R83Plane444Unorm:
+      return true;
+    default:
+      // NOTE: NOT EXHAUSTIVE.
+      break;
+  }
+  return false;
+}
+
+EmbedderExternalTextureSourceVulkan::EmbedderExternalTextureSourceVulkan(
+    const std::shared_ptr<impeller::Context>& p_context,
+    FlutterVulkanTexture* embedder_desc)
+    : TextureSourceVK(ToTextureDescriptor(embedder_desc)) {
+  const auto& context = impeller::ContextVK::Cast(*p_context);
+  const auto& device = context.GetDevice();
+  texture_image_ =
+      impeller::vk::Image(reinterpret_cast<VkImage>(embedder_desc->image));
+  texture_device_memory_ = impeller::vk::DeviceMemory(
+      reinterpret_cast<VkDeviceMemory>(embedder_desc->image_memory));
+
+  needs_yuv_conversion_ = RequiresYCBCRConversion(
+      static_cast<impeller::vk::Format>(embedder_desc->format));
+  std::shared_ptr<impeller::YUVConversionVK> yuv_conversion;
+  if (needs_yuv_conversion_) {
+    // Figure out how to perform YUV conversions.
+    yuv_conversion = CreateYUVConversion(context, embedder_desc);
+    if (!yuv_conversion || !yuv_conversion->IsValid()) {
+      VALIDATION_LOG << "Fail to create yuv conversion";
+      return;
+    }
+  }
+
+  // Create image view for the newly created image.
+  if (!CreateTextureImageView(device, embedder_desc, yuv_conversion)) {
+    VALIDATION_LOG << "Fail to create texture image view";
+    return;
+  }
+
+  yuv_conversion_ = std::move(yuv_conversion);
+  is_valid_ = true;
+}
+
+impeller::PixelFormat ToPixelFormat(int32_t vk_format) {
+  switch (vk_format) {
+    case VK_FORMAT_UNDEFINED:
+      return impeller::PixelFormat::kUnknown;
+    case VK_FORMAT_R8G8B8A8_UNORM:
+      return impeller::PixelFormat::kR8G8B8A8UNormInt;
+    case VK_FORMAT_R8G8B8A8_SRGB:
+      return impeller::PixelFormat::kR8G8B8A8UNormIntSRGB;
+    case VK_FORMAT_B8G8R8A8_UNORM:
+      return impeller::PixelFormat::kB8G8R8A8UNormInt;
+    case VK_FORMAT_B8G8R8A8_SRGB:
+      return impeller::PixelFormat::kB8G8R8A8UNormIntSRGB;
+    case VK_FORMAT_R32G32B32A32_SFLOAT:
+      return impeller::PixelFormat::kR32G32B32A32Float;
+    case VK_FORMAT_R16G16B16A16_SFLOAT:
+      return impeller::PixelFormat::kR16G16B16A16Float;
+    case VK_FORMAT_S8_UINT:
+      return impeller::PixelFormat::kS8UInt;
+    case VK_FORMAT_D24_UNORM_S8_UINT:
+      return impeller::PixelFormat::kD24UnormS8Uint;
+    case VK_FORMAT_D32_SFLOAT_S8_UINT:
+      return impeller::PixelFormat::kD32FloatS8UInt;
+    case VK_FORMAT_R8_UNORM:
+      return impeller::PixelFormat::kR8UNormInt;
+    case VK_FORMAT_R8G8_UNORM:
+      return impeller::PixelFormat::kR8G8UNormInt;
+    default:
+      return impeller::PixelFormat::kUnknown;
+  }
+}
+
+impeller::TextureDescriptor
+EmbedderExternalTextureSourceVulkan::ToTextureDescriptor(
+    FlutterVulkanTexture* embedder_desc) {
+  const auto size =
+      impeller::ISize{static_cast<int64_t>(embedder_desc->width),
+                      static_cast<int64_t>(embedder_desc->height)};
+  impeller::TextureDescriptor desc;
+  desc.storage_mode = impeller::StorageMode::kDevicePrivate;
+  desc.format = ToPixelFormat(embedder_desc->format);
+  desc.size = size;
+  desc.type = impeller::TextureType::kTexture2D;
+  desc.sample_count = impeller::SampleCount::kCount1;
+  desc.compression_type = impeller::CompressionType::kLossless;
+  desc.mip_count = 1u;
+  desc.usage = impeller::TextureUsage::kRenderTarget;
+  return desc;
+}
+
+std::shared_ptr<impeller::YUVConversionVK>
+EmbedderExternalTextureSourceVulkan::CreateYUVConversion(
+    const impeller::ContextVK& context,
+    FlutterVulkanTexture* embedder_desc) {
+  impeller::YUVConversionDescriptorVK conversion_chain;
+  auto& conversion_info = conversion_chain.get();
+
+  conversion_info.format =
+      static_cast<impeller::vk::Format>(embedder_desc->format);
+  conversion_info.ycbcrModel =
+      impeller::vk::SamplerYcbcrModelConversion::eYcbcr709;
+  conversion_info.ycbcrRange = impeller::vk::SamplerYcbcrRange::eItuFull;
+  conversion_info.components = {impeller::vk::ComponentSwizzle::eIdentity,
+                                impeller::vk::ComponentSwizzle::eIdentity,
+                                impeller::vk::ComponentSwizzle::eIdentity,
+                                impeller::vk::ComponentSwizzle::eIdentity};
+  conversion_info.xChromaOffset = impeller::vk::ChromaLocation::eCositedEven;
+  conversion_info.yChromaOffset = impeller::vk::ChromaLocation::eCositedEven;
+  conversion_info.chromaFilter = impeller::vk::Filter::eNearest;
+  conversion_info.forceExplicitReconstruction = false;
+  return context.GetYUVConversionLibrary()->GetConversion(conversion_chain);
+}
+
+bool EmbedderExternalTextureSourceVulkan::CreateTextureImageView(
+    const impeller::vk::Device& device,
+    FlutterVulkanTexture* embedder_desc,
+    const std::shared_ptr<impeller::YUVConversionVK>& yuv_conversion_wrapper) {
+  impeller::vk::StructureChain<impeller::vk::ImageViewCreateInfo,
+                               impeller::vk::SamplerYcbcrConversionInfo>
+      view_chain;
+  auto& view_info = view_chain.get();
+  view_info.image = texture_image_;
+  view_info.viewType = impeller::vk::ImageViewType::e2D;
+  view_info.format = static_cast<impeller::vk::Format>(embedder_desc->format);
+  view_info.subresourceRange.aspectMask =
+      impeller::vk::ImageAspectFlagBits::eColor;
+  view_info.subresourceRange.baseMipLevel = 0u;
+  view_info.subresourceRange.baseArrayLayer = 0u;
+  view_info.subresourceRange.levelCount = 1;
+  view_info.subresourceRange.layerCount = 1;
+
+  if (RequiresYCBCRConversion(
+          static_cast<impeller::vk::Format>(embedder_desc->format))) {
+    view_chain.get<impeller::vk::SamplerYcbcrConversionInfo>().conversion =
+        yuv_conversion_wrapper->GetConversion();
+  } else {
+    view_chain.unlink<impeller::vk::SamplerYcbcrConversionInfo>();
+  }
+  auto image_view = device.createImageViewUnique(view_info);
+  if (image_view.result != impeller::vk::Result::eSuccess) {
+    return false;
+  }
+  texture_image_view_ = std::move(image_view.value);
+  return true;
+}
+
+// |TextureSourceVK|
+EmbedderExternalTextureSourceVulkan::~EmbedderExternalTextureSourceVulkan() =
+    default;
+
+bool EmbedderExternalTextureSourceVulkan::IsValid() const {
+  return is_valid_;
+}
+
+// |TextureSourceVK|
+impeller::vk::Image EmbedderExternalTextureSourceVulkan::GetImage() const {
+  return texture_image_;
+}
+
+// |TextureSourceVK|
+impeller::vk::ImageView EmbedderExternalTextureSourceVulkan::GetImageView()
+    const {
+  return texture_image_view_.get();
+}
+
+// |TextureSourceVK|
+impeller::vk::ImageView
+EmbedderExternalTextureSourceVulkan::GetRenderTargetView() const {
+  return texture_image_view_.get();
+}
+
+// |TextureSourceVK|
+bool EmbedderExternalTextureSourceVulkan::IsSwapchainImage() const {
+  return is_swapchain_image_;
+}
+
+// |TextureSourceVK|
+std::shared_ptr<impeller::YUVConversionVK>
+EmbedderExternalTextureSourceVulkan::GetYUVConversion() const {
+  return needs_yuv_conversion_ ? yuv_conversion_ : nullptr;
+}
+
+}  // namespace flutter