kc3-lang/angle/src/libANGLE/renderer/vulkan/VkImageImageSiblingVk.cpp

• Show log

  Commit

• Hash : bd7915fd
  Author :
  Date : 2022-04-04T10:02:29
  

  Use provided format as intended format for EGLImage from VkImage
  
  The problem is because VkImage is created with R8G8B8A8 format,
  and then imported into ANGLE as EGLImage with GL_RGB format,
  however ANGLE doesn't set intended format correctly (ANGLE uses
  R8G8B8A8 instead of R8G8B8X8). So when clients use glReadPixels()
  to get pixels, the alpha channel is filled with incorrect value.
  
  Bug: chromium:1312490
  Change-Id: Ief5b87ec5eb03c9cb37f10b2c20b5caf3013262d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3569481
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Peng Huang <penghuang@chromium.org>
  

Download

• src/libANGLE/renderer/vulkan/VkImageImageSiblingVk.cpp

• //
  // Copyright 2021 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // VkImageImageSiblingVk.cpp: Implements VkImageImageSiblingVk.
  
  #include "libANGLE/renderer/vulkan/VkImageImageSiblingVk.h"
  
  #include "libANGLE/Display.h"
  #include "libANGLE/renderer/vulkan/DisplayVk.h"
  #include "libANGLE/renderer/vulkan/RendererVk.h"
  
  namespace rx
  {
  
  VkImageImageSiblingVk::VkImageImageSiblingVk(EGLClientBuffer buffer,
                                               const egl::AttributeMap &attribs)
  {
      mVkImage.setHandle(*reinterpret_cast<VkImage *>(buffer));
  
      ASSERT(attribs.contains(EGL_VULKAN_IMAGE_CREATE_INFO_HI_ANGLE));
      ASSERT(attribs.contains(EGL_VULKAN_IMAGE_CREATE_INFO_LO_ANGLE));
      uint64_t hi = static_cast<uint64_t>(attribs.get(EGL_VULKAN_IMAGE_CREATE_INFO_HI_ANGLE));
      uint64_t lo = static_cast<uint64_t>(attribs.get(EGL_VULKAN_IMAGE_CREATE_INFO_LO_ANGLE));
      const VkImageCreateInfo *info =
          reinterpret_cast<const VkImageCreateInfo *>((hi << 32) | (lo & 0xffffffff));
      ASSERT(info->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
      mVkImageInfo = *info;
      // TODO(penghuang): support extensions.
      mVkImageInfo.pNext = nullptr;
      mInternalFormat = static_cast<GLenum>(attribs.get(EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_NONE));
  }
  
  VkImageImageSiblingVk::~VkImageImageSiblingVk() = default;
  
  egl::Error VkImageImageSiblingVk::initialize(const egl::Display *display)
  {
      DisplayVk *displayVk = vk::GetImpl(display);
      return angle::ToEGL(initImpl(displayVk), displayVk, EGL_BAD_PARAMETER);
  }
  
  angle::Result VkImageImageSiblingVk::initImpl(DisplayVk *displayVk)
  {
      RendererVk *renderer = displayVk->getRenderer();
  
      const angle::FormatID formatID = vk::GetFormatIDFromVkFormat(mVkImageInfo.format);
      ANGLE_VK_CHECK(displayVk, formatID != angle::FormatID::NONE, VK_ERROR_FORMAT_NOT_SUPPORTED);
  
      const vk::Format &vkFormat = renderer->getFormat(formatID);
      const vk::ImageAccess imageAccess =
          isRenderable(nullptr) ? vk::ImageAccess::Renderable : vk::ImageAccess::SampleOnly;
      const angle::FormatID actualImageFormatID = vkFormat.getActualImageFormatID(imageAccess);
      const angle::Format &format               = angle::Format::Get(actualImageFormatID);
  
      angle::FormatID intendedFormatID;
      if (mInternalFormat != GL_NONE)
      {
          // If EGL_TEXTURE_INTERNAL_FORMAT_ANGLE is provided for eglCreateImageKHR(),
          // the provided format will be used for mFormat and intendedFormat.
          intendedFormatID = angle::Format::InternalFormatToID(mInternalFormat);
          GLenum type      = gl::GetSizedInternalFormatInfo(format.glInternalFormat).type;
          mFormat          = gl::Format(mInternalFormat, type);
      }
      else
      {
          intendedFormatID = vkFormat.getIntendedFormatID();
          mFormat          = gl::Format(format.glInternalFormat);
      }
  
      // Create the image
      mImage                              = new vk::ImageHelper();
      constexpr bool kIsRobustInitEnabled = false;
      mImage->init2DWeakReference(displayVk, mVkImage.release(), getSize(), false, intendedFormatID,
                                  actualImageFormatID, 1, kIsRobustInitEnabled);
  
      return angle::Result::Continue;
  }
  
  void VkImageImageSiblingVk::onDestroy(const egl::Display *display)
  {
      ASSERT(mImage == nullptr);
  }
  
  gl::Format VkImageImageSiblingVk::getFormat() const
  {
      return mFormat;
  }
  
  bool VkImageImageSiblingVk::isRenderable(const gl::Context *context) const
  {
      return mVkImageInfo.usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
  }
  
  bool VkImageImageSiblingVk::isTexturable(const gl::Context *context) const
  {
      return mVkImageInfo.usage & VK_IMAGE_USAGE_SAMPLED_BIT;
  }
  
  bool VkImageImageSiblingVk::isYUV() const
  {
      return false;
  }
  
  bool VkImageImageSiblingVk::hasProtectedContent() const
  {
      return false;
  }
  
  gl::Extents VkImageImageSiblingVk::getSize() const
  {
      return gl::Extents(mVkImageInfo.extent.width, mVkImageInfo.extent.height,
                         mVkImageInfo.extent.depth);
  }
  
  size_t VkImageImageSiblingVk::getSamples() const
  {
      return 0;
  }
  
  // ExternalImageSiblingVk interface
  vk::ImageHelper *VkImageImageSiblingVk::getImage() const
  {
      return mImage;
  }
  
  void VkImageImageSiblingVk::release(RendererVk *renderer)
  {
      if (mImage != nullptr)
      {
          // TODO: Handle the case where the EGLImage is used in two contexts not in the same share
          // group.  https://issuetracker.google.com/169868803
          mImage->releaseImageAndViewGarbage(renderer);
          mImage->resetImageWeakReference();
          mImage->destroy(renderer);
          SafeDelete(mImage);
      }
  }
  
  }  // namespace rx
  

Download