vulkan: disable vulkan and gl interop for bgra8888 textures.

Vulkan and GL inerop doesn't works with bgra8888 texture format for some
GL implementations, so use pixels copy for it.

Bug: 1104509,angleproject:4831
Change-Id: I60d0bbeb3354abc57473087a1b9e32ca2933e0ad
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2291981
Commit-Queue: Peng Huang <penghuang@chromium.org>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#787937}

gpu/command_buffer/service/external_vk_image_backing.cc

@@ -119,6 +119,33 @@ class ScopedDedicatedMemoryObject {
   GLuint id_;
 };
 
+bool UseSeparateGLTexture(SharedContextState* context_state,
+                          viz::ResourceFormat format) {
+  if (!context_state->support_vulkan_external_object())
+    return true;
+
+  if (format != viz::ResourceFormat::BGRA_8888)
+    return false;
+
+  const auto* version_info = context_state->real_context()->GetVersionInfo();
+  const auto& ext = gl::g_current_gl_driver->ext;
+  if (!ext.b_GL_EXT_texture_format_BGRA8888)
+    return true;
+
+  if (!version_info->is_angle)
+    return false;
+
+  // If ANGLE is using vulkan, there is no problem for importing BGRA8888
+  // textures.
+  if (version_info->is_angle_vulkan)
+    return false;
+
+  // ANGLE claims GL_EXT_texture_format_BGRA8888, but glTexStorageMem2DEXT
+  // doesn't work correctly.
+  // TODO(crbug.com/angleproject/4831): fix ANGLE and return false.
+  return true;
+}
+
 }  // namespace
 
 // static
@@ -138,7 +165,6 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::Create(
 
   auto* device_queue = context_state->vk_context_provider()->GetDeviceQueue();
   VkFormat vk_format = ToVkFormat(format);
-
   constexpr auto kUsageNeedsColorAttachment =
       SHARED_IMAGE_USAGE_GLES2 | SHARED_IMAGE_USAGE_RASTER |
       SHARED_IMAGE_USAGE_OOP_RASTERIZATION | SHARED_IMAGE_USAGE_WEBGPU;
@@ -169,11 +195,12 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::Create(
   VkImageCreateFlags vk_flags = 0;
 
   // In protected mode mark the image as protected, except when the image needs
-  // GLES2, but not Raster usage. ANGLE currenctly doesn't support protected
+  // GLES2, but not Raster usage. ANGLE currently doesn't support protected
   // images. Some clients request GLES2 and Raster usage (e.g. see
   // GpuMemoryBufferVideoFramePool). In that case still allocate protected
   // image, which ensures that image can still usable, but it may not work in
   // some scenarios (e.g. when the video frame is used in WebGL).
+  // TODO(https://crbug.com/angleproject/4833)
   if (vulkan_implementation->enforce_protected_memory() &&
       (!(usage & SHARED_IMAGE_USAGE_GLES2) ||
        (usage & SHARED_IMAGE_USAGE_RASTER))) {
@@ -192,9 +219,11 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::Create(
   if (!image)
     return nullptr;
 
+  bool use_separate_gl_texture = UseSeparateGLTexture(context_state, format);
   auto backing = std::make_unique<ExternalVkImageBacking>(
       util::PassKey<ExternalVkImageBacking>(), mailbox, format, size,
-      color_space, usage, context_state, std::move(image), command_pool);
+      color_space, usage, context_state, std::move(image), command_pool,
+      use_separate_gl_texture);
 
   if (!pixel_data.empty()) {
     size_t stride = BitsPerPixel(format) / 8 * size.width();
@@ -233,9 +262,12 @@ std::unique_ptr<ExternalVkImageBacking> ExternalVkImageBacking::CreateFromGMB(
       return nullptr;
     }
 
+    bool use_separate_gl_texture =
+        UseSeparateGLTexture(context_state, resource_format);
     auto backing = std::make_unique<ExternalVkImageBacking>(
         util::PassKey<ExternalVkImageBacking>(), mailbox, resource_format, size,
-        color_space, usage, context_state, std::move(image), command_pool);
+        color_space, usage, context_state, std::move(image), command_pool,
+        use_separate_gl_texture);
     backing->SetCleared();
     return backing;
   }
@@ -270,7 +302,8 @@ ExternalVkImageBacking::ExternalVkImageBacking(
     uint32_t usage,
     SharedContextState* context_state,
     std::unique_ptr<VulkanImage> image,
-    VulkanCommandPool* command_pool)
+    VulkanCommandPool* command_pool,
+    bool use_separate_gl_texture)
     : ClearTrackingSharedImageBacking(mailbox,
                                       format,
                                       size,
@@ -283,7 +316,8 @@ ExternalVkImageBacking::ExternalVkImageBacking(
       backend_texture_(size.width(),
                        size.height(),
                        CreateGrVkImageInfo(image_.get())),
-      command_pool_(command_pool) {}
+      command_pool_(command_pool),
+      use_separate_gl_texture_(use_separate_gl_texture) {}
 
 ExternalVkImageBacking::~ExternalVkImageBacking() {
   GrVkImageInfo image_info;
@@ -477,22 +511,6 @@ GLuint ExternalVkImageBacking::ProduceGLTextureInternal() {
   }
 
   GLuint internal_format = viz::TextureStorageFormat(format());
-  bool is_bgra8 = (internal_format == GL_BGRA8_EXT);
-  if (is_bgra8) {
-    const auto& ext = gl::g_current_gl_driver->ext;
-    if (!ext.b_GL_EXT_texture_format_BGRA8888) {
-      bool support_swizzle = ext.b_GL_ARB_texture_swizzle ||
-                             ext.b_GL_EXT_texture_swizzle ||
-                             gl::g_current_gl_version->IsAtLeastGL(3, 3) ||
-                             gl::g_current_gl_version->IsAtLeastGLES(3, 0);
-      if (!support_swizzle) {
-        LOG(ERROR) << "BGRA_88888 is not supported.";
-        return 0;
-      }
-      internal_format = GL_RGBA8;
-    }
-  }
-
   GLuint texture_service_id = 0;
   api->glGenTexturesFn(1, &texture_service_id);
   gl::ScopedTextureBinder scoped_texture_binder(GL_TEXTURE_2D,
@@ -512,11 +530,6 @@ GLuint ExternalVkImageBacking::ProduceGLTextureInternal() {
                                 memory_object->id(), 0);
   }
 
-  if (is_bgra8 && internal_format == GL_RGBA8) {
-    api->glTexParameteriFn(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
-    api->glTexParameteriFn(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
-  }
-
   return texture_service_id;
 }
 

gpu/command_buffer/service/external_vk_image_backing.h

@@ -65,7 +65,8 @@ class ExternalVkImageBacking final : public ClearTrackingSharedImageBacking {
                          uint32_t usage,
                          SharedContextState* context_state,
                          std::unique_ptr<VulkanImage> image,
-                         VulkanCommandPool* command_pool);
+                         VulkanCommandPool* command_pool,
+                         bool use_separate_gl_texture);
 
   ~ExternalVkImageBacking() override;
 
@@ -91,6 +92,7 @@ class ExternalVkImageBacking final : public ClearTrackingSharedImageBacking {
         ->GetDeviceQueue()
         ->GetVulkanDevice();
   }
+  bool use_separate_gl_texture() const { return use_separate_gl_texture_; }
   bool need_synchronization() const {
     if (usage() & SHARED_IMAGE_USAGE_WEBGPU) {
       return true;
@@ -101,10 +103,6 @@ class ExternalVkImageBacking final : public ClearTrackingSharedImageBacking {
     }
     return false;
   }
-  bool use_separate_gl_texture() const {
-    return !context_state()->support_vulkan_external_object();
-  }
-
   uint32_t reads_in_progress() const { return reads_in_progress_; }
   uint32_t gl_reads_in_progress() const { return gl_reads_in_progress_; }
 
@@ -185,6 +183,7 @@ class ExternalVkImageBacking final : public ClearTrackingSharedImageBacking {
   std::unique_ptr<VulkanImage> image_;
   GrBackendTexture backend_texture_;
   VulkanCommandPool* const command_pool_;
+  const bool use_separate_gl_texture_;
 
   SemaphoreHandle write_semaphore_handle_;
   std::vector<SemaphoreHandle> read_semaphore_handles_;

ui/gl/gl_gl_api_implementation.cc

@@ -352,6 +352,18 @@ void RealGLApi::glTexStorage2DEXTFn(GLenum target,
                                  height);
 }
 
+void RealGLApi::glTexStorageMem2DEXTFn(GLenum target,
+                                       GLsizei levels,
+                                       GLenum internalformat,
+                                       GLsizei width,
+                                       GLsizei height,
+                                       GLuint memory,
+                                       GLuint64 offset) {
+  internalformat = GetInternalFormat(version_.get(), internalformat);
+  GLApiBase::glTexStorageMem2DEXTFn(target, levels, internalformat, width,
+                                    height, memory, offset);
+}
+
 void RealGLApi::glRenderbufferStorageEXTFn(GLenum target,
                                            GLenum internalformat,
                                            GLsizei width,

ui/gl/gl_gl_api_implementation.h

@@ -81,6 +81,14 @@ class GL_EXPORT RealGLApi : public GLApiBase {
                            GLsizei width,
                            GLsizei height) override;
 
+  void glTexStorageMem2DEXTFn(GLenum target,
+                              GLsizei levels,
+                              GLenum internalformat,
+                              GLsizei width,
+                              GLsizei height,
+                              GLuint memory,
+                              GLuint64 offset) override;
+
   void glRenderbufferStorageEXTFn(GLenum target,
                                   GLenum internalformat,
                                   GLsizei width,

ui/gl/gl_version_info.cc

@@ -29,19 +29,7 @@ namespace gl {
 
 GLVersionInfo::GLVersionInfo(const char* version_str,
                              const char* renderer_str,
-                             const gfx::ExtensionSet& extensions)
-    : is_es(false),
-      is_angle(false),
-      is_d3d(false),
-      is_mesa(false),
-      is_swiftshader(false),
-      is_angle_swiftshader(false),
-      major_version(0),
-      minor_version(0),
-      is_es2(false),
-      is_es3(false),
-      is_desktop_core_profile(false),
-      is_es3_capable(false) {
+                             const gfx::ExtensionSet& extensions) {
   Initialize(version_str, renderer_str, extensions);
 }
 
@@ -60,6 +48,7 @@ void GLVersionInfo::Initialize(const char* version_str,
     if (is_angle) {
       is_angle_swiftshader =
           renderer_string.find("SwiftShader Device") != std::string::npos;
+      is_angle_vulkan = renderer_string.find("Vulkan") != std::string::npos;
     }
 
     is_swiftshader = base::StartsWith(renderer_str, "Google SwiftShader",

ui/gl/gl_version_info.h

@@ -60,18 +60,19 @@ struct GL_EXPORT GLVersionInfo {
     return !is_angle && !is_swiftshader && (is_es3 || is_desktop_core_profile);
   }
 
-  bool is_es;
-  bool is_angle;
-  bool is_d3d;
-  bool is_mesa;
-  bool is_swiftshader;
-  bool is_angle_swiftshader;
-  unsigned major_version;
-  unsigned minor_version;
-  bool is_es2;
-  bool is_es3;
-  bool is_desktop_core_profile;
-  bool is_es3_capable;
+  bool is_es = false;
+  bool is_angle = false;
+  bool is_d3d = false;
+  bool is_mesa = false;
+  bool is_swiftshader = false;
+  bool is_angle_swiftshader = false;
+  bool is_angle_vulkan = false;
+  unsigned major_version = 0;
+  unsigned minor_version = 0;
+  bool is_es2 = false;
+  bool is_es3 = false;
+  bool is_desktop_core_profile = false;
+  bool is_es3_capable = false;
   std::string driver_vendor;
   std::string driver_version;