Add EmbedderSurface for Vulkan, init skia contexts, correct API callbacks, init proctable, and init GPUSurfaceVulkan with callback delegate

Author: bdero

shell/gpu/gpu_surface_vulkan.cc

@@ -8,14 +8,18 @@
 
 namespace flutter {
 
-GPUSurfaceVulkan::GPUSurfaceVulkan(const sk_sp<GrDirectContext>& skia_context,
-                                   GPUSurfaceVulkanDelegate* delegate)
-    : skia_context_(skia_context), delegate_(delegate), weak_factory_(this) {}
+GPUSurfaceVulkan::GPUSurfaceVulkan(GPUSurfaceVulkanDelegate* delegate,
+                                   const sk_sp<GrDirectContext>& skia_context,
+                                   bool render_to_surface)
+    : delegate_(delegate),
+      skia_context_(skia_context),
+      render_to_surface_(render_to_surface),
+      weak_factory_(this) {}
 
 GPUSurfaceVulkan::~GPUSurfaceVulkan() = default;
 
 bool GPUSurfaceVulkan::IsValid() {
-  return image_ != nullptr;
+  return skia_context_ != nullptr;
 }
 
 std::unique_ptr<SurfaceFrame> GPUSurfaceVulkan::AcquireFrame(
@@ -64,12 +68,10 @@ SkMatrix GPUSurfaceVulkan::GetRootTransformation() const {
 }
 
 GrDirectContext* GPUSurfaceVulkan::GetContext() {
-  return skia_context_;
+  return skia_context_.get();
 }
 
 sk_sp<SkSurface> GPUSurfaceVulkan::AcquireSurfaceFromVulkanImage(
-    VkImage image) {
-
-}
+    VkImage image) {}
 
 }  // namespace flutter

shell/gpu/gpu_surface_vulkan.h

@@ -18,7 +18,6 @@
 
 namespace flutter {
 
-
 //------------------------------------------------------------------------------
 /// @brief  A GPU surface backed by VkImages provided by a
 ///         GPUSurfaceVulkanDelegate.
@@ -29,8 +28,9 @@ class GPUSurfaceVulkan : public Surface {
   /// @brief      Create a GPUSurfaceVulkan while letting it reuse an existing
   ///             GrDirectContext.
   ///
-  GPUSurfaceVulkan(const sk_sp<GrDirectContext>& context,
-                   GPUSurfaceVulkanDelegate* delegate);
+  GPUSurfaceVulkan(GPUSurfaceVulkanDelegate* delegate,
+                   const sk_sp<GrDirectContext>& context,
+                   bool render_to_surface);
 
   ~GPUSurfaceVulkan() override;
 
@@ -52,11 +52,12 @@ class GPUSurfaceVulkan : public Surface {
   GrDirectContext* GetContext() override;
 
  private:
-  sk_sp<GrDirectContext> skia_context_;
   GPUSurfaceVulkanDelegate* delegate_;
+  sk_sp<GrDirectContext> skia_context_;
+  bool render_to_surface_;
 
-  std::vector<std::unique_ptr<VulkanBackbuffer>> backbuffers_;
-  std::vector<sk_sp<SkSurface>> surfaces_;
+  std::unique_ptr<vulkan::VulkanBackbuffer> backbuffer_;
+  sk_sp<SkSurface> surface_;
   size_t current_backbuffer_index_;
 
   fml::WeakPtrFactory<GPUSurfaceVulkan> weak_factory_;

shell/gpu/gpu_surface_vulkan_delegate.h

@@ -31,7 +31,7 @@ class GPUSurfaceVulkanDelegate {
 
   /// @brief  Obtain a reference to the Vulkan implementation's proc table.
   ///
-  virtual fml::RefPtr<vulkan::VulkanProcTable> vk() = 0;
+  virtual const vulkan::VulkanProcTable& vk() = 0;
 
   /// @brief  Called by the engine to fetch a VkImage for writing the next
   ///         frame.

shell/platform/embedder/BUILD.gn

@@ -104,13 +104,6 @@ template("embedder_source_set") {
       deps += [ "//flutter/shell/platform/darwin/graphics" ]
     }
 
-    if (embedder_enable_gl) {
-      sources += [
-        "embedder_surface_vulkan.cc",
-        "embedder_surface_vulkan.h",
-      ]
-    }
-
     public_deps = [ ":embedder_headers" ]
 
     public_configs += [

shell/platform/embedder/embedder.cc

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "shell/gpu/gpu_surface_vulkan_delegate.h"
+#include "shell/platform/embedder/embedder_surface_vulkan.h"
 #define FML_USED_ON_EMBEDDER
 #define RAPIDJSON_HAS_STDSTRING 1
 
@@ -170,7 +172,7 @@ static void* DefaultGLProcResolver(const char* name) {
       fml::NativeLibrary::CreateForCurrentProcess();
 #elif OS_WIN  // OS_LINUX
       fml::NativeLibrary::Create("opengl32.dll");
-#endif        // OS_WIN
+#endif  // OS_WIN
   return static_cast<void*>(
       const_cast<uint8_t*>(proc_library->ResolveSymbol(name)));
 }
@@ -381,11 +383,51 @@ InferVulkanPlatformViewCreationCallback(
   }
 
 #ifdef SHELL_ENABLE_VULKAN
+  std::function<void*(VkInstance, const char*)>
+      vulkan_get_instance_proc_address =
+          [ptr = config->vulkan.get_instance_proc_address_callback, user_data](
+              VkInstance instance, const char* proc_name) -> void* {
+    ptr(user_data, instance, proc_name);
+  };
+
+  auto vulkan_get_next_image =
+      [ptr = config->vulkan.get_next_image_callback,
+       user_data](const SkISize& frame_size) -> VkImage {
+    FlutterFrameInfo frame_info = {
+        .struct_size = sizeof(FlutterFrameInfo),
+        .size = {static_cast<uint32_t>(frame_size.width()),
+                 static_cast<uint32_t>(frame_size.height())},
+    };
+
+    FlutterVulkanImage vulkan_image = ptr(user_data, &frame_info);
+    return static_cast<VkImage>(vulkan_image.image);
+  };
+
+  auto vulkan_present_image_callback =
+      [ptr = config->vulkan.present_image_callback,
+       user_data](VkImage image) -> bool {
+    FlutterVulkanImage image_desc = {
+        .struct_size = sizeof(FlutterVulkanImage),
+        .image = image,
+        .user_data = user_data,
+    };
+    return ptr(user_data, &image_desc);
+  };
+
+  flutter::EmbedderSurfaceVulkan::VulkanDispatchTable vulkan_dispatch_table = {
+      .get_instance_proc_address = vulkan_get_instance_proc_address,
+      .get_next_image = vulkan_get_next_image,
+      .present_image = vulkan_present_image_callback,
+  };
+
   std::shared_ptr<flutter::EmbedderExternalViewEmbedder> view_embedder =
       std::move(external_view_embedder);
 
   std::unique_ptr<flutter::EmbedderSurfaceVulkan> embedder_surface =
-      std::make_unique<flutter::EmbedderSurfaceVulkan>(view_embedder);
+      std::make_unique<flutter::EmbedderSurfaceVulkan>(
+          config->vulkan.device, config->vulkan.physical_device,
+          config->vulkan.instance, config->vulkan.queue_family_index,
+          config->vulkan.queue, vulkan_dispatch_table, view_embedder);
 
   return fml::MakeCopyable(
       [embedder_surface = std::move(embedder_surface), platform_dispatch_table,
@@ -647,7 +689,7 @@ static sk_sp<SkSurface> MakeSkSurfaceFromBackingStore(
     GrDirectContext* context,
     const FlutterBackingStoreConfig& config,
     const FlutterVulkanBackingStore* vulkan) {
-  assert(false); // TODO(bdero)
+  assert(false);  // TODO(bdero)
   return nullptr;
 }
 

shell/platform/embedder/embedder.h

@@ -543,19 +543,19 @@ typedef struct {
 } FlutterMetalRendererConfig;
 
 /// Alias for VkInstance.
-typedef const uint64_t* FlutterVulkanInstanceHandle;
+typedef void* FlutterVulkanInstanceHandle;
 
 /// Alias for VkPhysicalDevice.
-typedef const uint64_t* FlutterVulkanPhysicalDeviceHandle;
+typedef void* FlutterVulkanPhysicalDeviceHandle;
 
 /// Alias for VkDevice.
-typedef const uint64_t* FlutterVulkanDeviceHandle;
+typedef void* FlutterVulkanDeviceHandle;
 
 /// Alias for VkQueue.
-typedef const uint64_t* FlutterVulkanQueueHandle;
+typedef void* FlutterVulkanQueueHandle;
 
 /// Alias for VkImage.
-typedef const uint64_t* FlutterVulkanImageHandle;
+typedef void* FlutterVulkanImageHandle;
 
 typedef struct {
   /// The size of this struct. Must be sizeof(FlutterVulkanImage).
@@ -567,8 +567,8 @@ typedef struct {
   /// back to the embedder in the destruction callback below. Embedder resources
   /// may be associated with this baton.
   void* user_data;
-  /// The callback invoked by the engine when it no longer needs this backing
-  /// store.
+  /// Only called when releasing custom compositor backing stores. The callback
+  /// invoked by the engine when it no longer needs this backing store.
   VoidCallback destruction_callback;
 } FlutterVulkanImage;
 

shell/platform/embedder/embedder_surface_vulkan.cc

@@ -0,0 +1,134 @@
+// 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_surface_vulkan.h"
+
+#include "flutter/shell/common/shell_io_manager.h"
+#include "include/gpu/GrDirectContext.h"
+#include "include/gpu/vk/GrVkBackendContext.h"
+#include "shell/gpu/gpu_surface_vulkan.h"
+#include "shell/gpu/gpu_surface_vulkan_delegate.h"
+
+namespace flutter {
+
+EmbedderSurfaceVulkan::EmbedderSurfaceVulkan(
+    VkInstance instance,
+    VkPhysicalDevice physical_device,
+    VkDevice device,
+    uint32_t queue_family_index,
+    VkQueue queue,
+    VulkanDispatchTable vulkan_dispatch_table,
+    std::shared_ptr<EmbedderExternalViewEmbedder> external_view_embedder)
+    : vk_(vulkan_dispatch_table.get_instance_proc_address),
+      device_(vk_, physical_device, device, queue_family_index, queue),
+      vulkan_dispatch_table_(vulkan_dispatch_table),
+      external_view_embedder_(external_view_embedder) {
+  // Make sure all required members of the dispatch table are checked.
+  if (!vulkan_dispatch_table_.get_instance_proc_address ||
+      !vulkan_dispatch_table_.get_next_image ||
+      !vulkan_dispatch_table_.present_image) {
+    return;
+  }
+
+  vk_.SetupInstanceProcAddresses(instance);
+  vk_.SetupDeviceProcAddresses(device);
+  if (!vk_.IsValid()) {
+    FML_LOG(ERROR) << "VulkanProcTable invalid.";
+    return;
+  }
+
+  main_context_ = CreateGrContext(instance, ContextType::kRender);
+  // TODO(bdero): Add a second (optional) queue+family index to the Embedder API
+  //             to allow embedders to specify a dedicated transfer queue for
+  //             use by the resource context. Queue families with graphics
+  //             capability can always be used for memory transferring, but it
+  //             would be adventageous to use a dedicated transter queue here.
+  resource_context_ = CreateGrContext(instance, ContextType::kResource);
+
+  valid_ = main_context_ && resource_context_;
+}
+
+EmbedderSurfaceVulkan::~EmbedderSurfaceVulkan() = default;
+
+// |GPUSurfaceVulkanDelegate|
+const vulkan::VulkanProcTable& EmbedderSurfaceVulkan::vk() {
+    return vk_;
+}
+
+// |GPUSurfaceVulkanDelegate|
+VkImage EmbedderSurfaceVulkan::AcquireImage(const SkISize& size) {
+    return vulkan_dispatch_table_.get_next_image(size);
+}
+
+// |GPUSurfaceVulkanDelegate|
+bool EmbedderSurfaceVulkan::PresentImage(VkImage image) {
+    return vulkan_dispatch_table_.present_image(image);
+}
+
+// |EmbedderSurface|
+bool EmbedderSurfaceVulkan::IsValid() const {
+  return valid_;
+}
+
+// |EmbedderSurface|
+std::unique_ptr<Surface> EmbedderSurfaceVulkan::CreateGPUSurface() {
+  const bool render_to_surface = !external_view_embedder_;
+  return std::make_unique<GPUSurfaceVulkan>(this, main_context_,
+                                            render_to_surface);
+}
+
+// |EmbedderSurface|
+sk_sp<GrDirectContext> EmbedderSurfaceVulkan::CreateResourceContext() const {
+  return resource_context_;
+}
+
+sk_sp<GrDirectContext> EmbedderSurfaceVulkan::CreateGrContext(
+    VkInstance instance,
+    ContextType context_type) const {
+  uint32_t skia_features = 0;
+  if (!device_.GetPhysicalDeviceFeaturesSkia(&skia_features)) {
+    FML_LOG(ERROR) << "Failed to get physical device features.";
+
+    return nullptr;
+  }
+
+  auto get_proc = vk_.CreateSkiaGetProc();
+  if (get_proc == nullptr) {
+    FML_LOG(ERROR) << "Failed to create Vulkan getProc for Skia.";
+    return nullptr;
+  }
+
+  GrVkBackendContext backend_context = {
+      .fInstance = instance,
+      .fPhysicalDevice = device_.GetPhysicalDeviceHandle(),
+      .fDevice = device_.GetHandle(),
+      .fQueue = device_.GetQueueHandle(),
+      .fGraphicsQueueIndex = device_.GetGraphicsQueueIndex(),
+      .fMinAPIVersion = VK_MAKE_VERSION(1, 0, 0),
+      .fMaxAPIVersion = VK_MAKE_VERSION(1, 0, 0),
+      .fFeatures = skia_features,
+      .fGetProc = get_proc,
+      .fOwnsInstanceAndDevice = false,
+  };
+  // TODO(bdero): Activate MEMORY_REQUIREMENTS_2 if available because VMA (the
+  //              allocator used by Skia) knows how to take advantage of these
+  //              features.
+  /*
+    const char* device_extensions[] = {
+        VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
+    };
+    GrVkExtensions vk_extensions;
+    vk_extensions.init(backend_context.fGetProc, backend_context.fInstance,
+                       backend_context.fPhysicalDevice, 0, nullptr,
+                       countof(device_extensions), device_extensions);
+    backend_context.fVkExtensions = &vk_extensions;
+  */
+
+  GrContextOptions options =
+      MakeDefaultContextOptions(context_type, GrBackendApi::kVulkan);
+  options.fReduceOpsTaskSplitting = GrContextOptions::Enable::kNo;
+  return GrDirectContext::MakeVulkan(backend_context, options);
+}
+
+}  // namespace flutter