WIP: external-texture: add kFlutterDesktopGpuSurfaceTexture support

Signed-off-by: Hidenori Matsubayashi <[email protected]>

Author: HidenoriMatsubayashi

cmake/build.cmake

@@ -146,6 +146,7 @@ set(ELINUX_COMMON_SRC
   "src/flutter/shell/platform/linux_embedded/task_runner.cc"
   "src/flutter/shell/platform/linux_embedded/system_utils.cc"
   "src/flutter/shell/platform/linux_embedded/logger.cc"
+  "src/flutter/shell/platform/linux_embedded/external_texture_d3d.cc"
   "src/flutter/shell/platform/linux_embedded/external_texture_pixelbuffer.cc"
   "src/flutter/shell/platform/linux_embedded/external_texture_egl_image.cc"
   "src/flutter/shell/platform/linux_embedded/vsync_waiter.cc"

src/flutter/shell/platform/linux_embedded/external_texture_d3d.cc

@@ -0,0 +1,114 @@
+// 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/linux_embedded/external_texture_d3d.h"
+
+#include "flutter/shell/platform/embedder/embedder_struct_macros.h"
+#include "flutter/shell/platform/linux_embedded/logger.h"
+
+namespace flutter {
+
+ExternalTextureD3d::ExternalTextureD3d(
+    const FlutterDesktopGpuSurfaceTextureCallback texture_callback,
+    void* user_data,
+    const ELinuxRenderSurfaceTarget* surface_manager,
+    const GlProcs& gl_procs)
+    : texture_callback_(texture_callback),
+      user_data_(user_data),
+      surface_manager_(surface_manager),
+      gl_(gl_procs) {}
+
+ExternalTextureD3d::~ExternalTextureD3d() {
+  ReleaseImage();
+
+  if (gl_texture_ != 0) {
+    gl_.glDeleteTextures(1, &gl_texture_);
+  }
+}
+
+bool ExternalTextureD3d::PopulateTexture(size_t width,
+                                         size_t height,
+                                         FlutterOpenGLTexture* opengl_texture) {
+  const FlutterDesktopGpuSurfaceDescriptor* descriptor =
+      texture_callback_(width, height, user_data_);
+
+  if (!CreateOrUpdateTexture(descriptor)) {
+    return false;
+  }
+
+  // Populate the texture object used by the engine.
+  opengl_texture->target = GL_TEXTURE_2D;
+  opengl_texture->name = gl_texture_;
+  opengl_texture->format = GL_RGBA8_OES;
+  opengl_texture->destruction_callback = nullptr;
+  opengl_texture->user_data = nullptr;
+  opengl_texture->width = SAFE_ACCESS(descriptor, visible_width, 0);
+  opengl_texture->height = SAFE_ACCESS(descriptor, visible_height, 0);
+
+  return true;
+}
+
+void ExternalTextureD3d::ReleaseImage() {
+  if (egl_surface_ != EGL_NO_SURFACE) {
+    eglReleaseTexImage(surface_manager_->EglDisplay(), egl_surface_,
+                       EGL_BACK_BUFFER);
+    eglDestroySurface(surface_manager_->EglDisplay(), egl_surface_);
+    egl_surface_ = EGL_NO_SURFACE;
+  }
+}
+
+bool ExternalTextureD3d::CreateOrUpdateTexture(
+    const FlutterDesktopGpuSurfaceDescriptor* descriptor) {
+  if (descriptor == nullptr ||
+      SAFE_ACCESS(descriptor, handle, nullptr) == nullptr) {
+    ReleaseImage();
+    return false;
+  }
+
+  if (gl_texture_ == 0) {
+    gl_.glGenTextures(1, &gl_texture_);
+
+    gl_.glBindTexture(GL_TEXTURE_2D, gl_texture_);
+    gl_.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    gl_.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    gl_.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    gl_.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else {
+    gl_.glBindTexture(GL_TEXTURE_2D, gl_texture_);
+  }
+
+  auto handle = SAFE_ACCESS(descriptor, handle, nullptr);
+  if (handle != last_surface_handle_) {
+    ReleaseImage();
+
+    EGLint attributes[] = {
+        EGL_WIDTH,
+        static_cast<EGLint>(SAFE_ACCESS(descriptor, width, 0)),
+        EGL_HEIGHT,
+        static_cast<EGLint>(SAFE_ACCESS(descriptor, height, 0)),
+        EGL_TEXTURE_TARGET,
+        EGL_TEXTURE_2D,
+        EGL_TEXTURE_FORMAT,
+        EGL_TEXTURE_RGBA,  // always EGL_TEXTURE_RGBA
+        EGL_NONE};
+
+    egl_surface_ = surface_manager_->CreateSurfaceFromHandle(
+        EGL_OPENVG_IMAGE, handle, attributes);
+
+    if (egl_surface_ == EGL_NO_SURFACE ||
+        eglBindTexImage(surface_manager_->EglDisplay(), egl_surface_,
+                        EGL_BACK_BUFFER) == EGL_FALSE) {
+      ELINUX_LOG(ERROR) << "Binding D3D surface failed.";
+    }
+    last_surface_handle_ = handle;
+  }
+
+  auto release_callback = SAFE_ACCESS(descriptor, release_callback, nullptr);
+  if (release_callback) {
+    release_callback(SAFE_ACCESS(descriptor, release_context, nullptr));
+  }
+  return egl_surface_ != EGL_NO_SURFACE;
+}
+
+}  // namespace flutter

src/flutter/shell/platform/linux_embedded/external_texture_d3d.h

@@ -0,0 +1,50 @@
+// 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.
+
+#ifndef FLUTTER_SHELL_PLATFORM_LINUX_EMBEDDED_EXTERNAL_TEXTURE_D3D_H_
+#define FLUTTER_SHELL_PLATFORM_LINUX_EMBEDDED_EXTERNAL_TEXTURE_D3D_H_
+
+#include "flutter/shell/platform/common/public/flutter_texture_registrar.h"
+
+#include "flutter/shell/platform/linux_embedded/external_texture.h"
+
+#include "flutter/shell/platform/linux_embedded/window_binding_handler.h"
+
+namespace flutter {
+
+// An external texture that is backed by a DXGI surface.
+class ExternalTextureD3d : public ExternalTexture {
+ public:
+  ExternalTextureD3d(
+      const FlutterDesktopGpuSurfaceTextureCallback texture_callback,
+      void* user_data,
+      const ELinuxRenderSurfaceTarget* surface_manager,
+      const GlProcs& gl_procs);
+  virtual ~ExternalTextureD3d();
+
+  // |ExternalTexture|
+  bool PopulateTexture(size_t width,
+                       size_t height,
+                       FlutterOpenGLTexture* opengl_texture) override;
+
+ private:
+  // Creates or updates the backing texture and associates it with the provided
+  // surface.
+  bool CreateOrUpdateTexture(
+      const FlutterDesktopGpuSurfaceDescriptor* descriptor);
+  // Detaches the previously attached surface, if any.
+  void ReleaseImage();
+
+  const FlutterDesktopGpuSurfaceTextureCallback texture_callback_;
+  void* const user_data_;
+  const ELinuxRenderSurfaceTarget* surface_manager_;
+  const GlProcs& gl_;
+  GLuint gl_texture_ = 0;
+  EGLSurface egl_surface_ = EGL_NO_SURFACE;
+  void* last_surface_handle_ = nullptr;
+};
+
+}  // namespace flutter
+
+#endif  // FLUTTER_SHELL_PLATFORM_LINUX_EMBEDDED_EXTERNAL_TEXTURE_D3D_H_

src/flutter/shell/platform/linux_embedded/flutter_elinux_engine.cc

@@ -160,8 +160,8 @@ FlutterELinuxEngine::FlutterELinuxEngine(const FlutterProjectBundle& project)
       std::make_unique<IncomingMessageDispatcher>(messenger_.get());
 
   FlutterELinuxTextureRegistrar::ResolveGlFunctions(gl_procs_);
-  texture_registrar_ =
-      std::make_unique<FlutterELinuxTextureRegistrar>(this, gl_procs_);
+  texture_registrar_ = std::make_unique<FlutterELinuxTextureRegistrar>(
+      this, view_->GetRenderSurfaceTarget(), gl_procs_);
 
   vsync_waiter_ = std::make_unique<VsyncWaiter>();
 }

src/flutter/shell/platform/linux_embedded/flutter_elinux_texture_registrar.cc

@@ -5,9 +5,9 @@
 #include "flutter/shell/platform/linux_embedded/flutter_elinux_texture_registrar.h"
 
 #include <iostream>
-#include <mutex>
 
 #include "flutter/shell/platform/embedder/embedder_struct_macros.h"
+#include "flutter/shell/platform/linux_embedded/external_texture_d3d.h"
 #include "flutter/shell/platform/linux_embedded/external_texture_egl_image.h"
 #include "flutter/shell/platform/linux_embedded/external_texture_pixelbuffer.h"
 #include "flutter/shell/platform/linux_embedded/flutter_elinux_engine.h"
@@ -21,8 +21,9 @@ namespace flutter {
 
 FlutterELinuxTextureRegistrar::FlutterELinuxTextureRegistrar(
     FlutterELinuxEngine* engine,
+    const ELinuxRenderSurfaceTarget* surface_manager,
     const GlProcs& gl_procs)
-    : engine_(engine), gl_procs_(gl_procs) {}
+    : engine_(engine), surface_manager_(surface_manager), gl_procs_(gl_procs) {}
 
 int64_t FlutterELinuxTextureRegistrar::RegisterTexture(
     const FlutterDesktopTextureInfo* texture_info) {
@@ -49,8 +50,15 @@ int64_t FlutterELinuxTextureRegistrar::RegisterTexture(
         texture_info->egl_image_config.callback,
         texture_info->egl_image_config.user_data, gl_procs_));
   } else if (texture_info->type == kFlutterDesktopGpuSurfaceTexture) {
-    std::cerr << "GpuSurfaceTexture is not yet supported." << std::endl;
-    return kInvalidTexture;
+    if (!texture_info->gpu_surface_config.callback) {
+      std::cerr << "Invalid gpu surface texture callback." << std::endl;
+      return kInvalidTexture;
+    }
+
+    return EmplaceTexture(std::make_unique<flutter::ExternalTextureD3d>(
+        texture_info->gpu_surface_config.callback,
+        texture_info->gpu_surface_config.user_data, surface_manager_,
+        gl_procs_));
   }
 
   std::cerr << "Attempted to register texture of unsupport type." << std::endl;

src/flutter/shell/platform/linux_embedded/flutter_elinux_texture_registrar.h

@@ -11,6 +11,7 @@
 
 #include "flutter/shell/platform/common/public/flutter_texture_registrar.h"
 #include "flutter/shell/platform/linux_embedded/external_texture.h"
+#include "flutter/shell/platform/linux_embedded/window_binding_handler.h"
 
 namespace flutter {
 
@@ -20,8 +21,10 @@ class FlutterELinuxEngine;
 // Thread safety: All member methods are thread safe.
 class FlutterELinuxTextureRegistrar {
  public:
-  explicit FlutterELinuxTextureRegistrar(FlutterELinuxEngine* engine,
-                                         const GlProcs& gl_procs);
+  explicit FlutterELinuxTextureRegistrar(
+      FlutterELinuxEngine* engine,
+      const ELinuxRenderSurfaceTarget* surface_manager,
+      const GlProcs& gl_procs);
 
   // Registers a texture described by the given |texture_info| object.
   // Returns the non-zero, positive texture id or -1 on error.
@@ -48,6 +51,7 @@ class FlutterELinuxTextureRegistrar {
 
  private:
   FlutterELinuxEngine* engine_ = nullptr;
+  const ELinuxRenderSurfaceTarget* surface_manager_;
   const GlProcs& gl_procs_;
 
   // All registered textures, keyed by their IDs.

src/flutter/shell/platform/linux_embedded/surface/context_egl.cc

@@ -187,4 +187,11 @@ EGLint ContextEgl::GetAttrib(EGLint attribute) {
   return value;
 }
 
+EGLSurface ContextEgl::CreateSurfaceFromHandle(EGLenum handle_type,
+                                               EGLClientBuffer handle,
+                                               const EGLint* attributes) const {
+  return eglCreatePbufferFromClientBuffer(environment_->Display(), handle_type,
+                                          handle, config_, attributes);
+}
+
 }  // namespace flutter

src/flutter/shell/platform/linux_embedded/surface/context_egl.h

@@ -36,6 +36,12 @@ class ContextEgl {
 
   EGLint GetAttrib(EGLint attribute);
 
+  EGLDisplay Display() const { return environment_->Display(); }
+
+  EGLSurface CreateSurfaceFromHandle(EGLenum handle_type,
+                                     EGLClientBuffer handle,
+                                     const EGLint* attributes) const;
+
  protected:
   std::unique_ptr<EnvironmentEgl> environment_;
   EGLConfig config_;

src/flutter/shell/platform/linux_embedded/surface/surface_gl.h

@@ -39,6 +39,16 @@ class SurfaceGl final : public SurfaceBase, public SurfaceGlDelegate {
 
   // |SurfaceGlDelegate|
   void* GlProcResolver(const char* name) const override;
+
+  // Gets a EGL display.
+  EGLDisplay EglDisplay() const { return context_->Display(); }
+
+  // Creates a EGLSurface for external GPU texture views.
+  EGLSurface CreateSurfaceFromHandle(EGLenum handle_type,
+                                     EGLClientBuffer handle,
+                                     const EGLint* attributes) const {
+    return context_->CreateSurfaceFromHandle(handle_type, handle, attributes);
+  }
 };
 
 }  // namespace flutter