Vulkan: Shader path for texture-to-texture copy

This change implements glCopy[Sub]TextureCHROMIUM in GPU.  As with the
previous change implementing glCopyTex[Sub]Image2D, it currently only
selects the shader path if the texture is already defined.

Bug: angleproject:2958
Change-Id: Ia1b5625f92e6c9f91807c9b601e5c34d2d5e5c30
Reviewed-on: https://chromium-review.googlesource.com/c/1392394
Commit-Queue: Shahbaz Youssefi <[email protected]>
Reviewed-by: Yuly Novikov <[email protected]>

Author: ShabbyX

include/platform/FeaturesVk.h

@@ -57,6 +57,11 @@ struct FeaturesVk
     // Whether the VkDevice supports the VK_KHR_incremental_present extension, on which the
     // EGL_KHR_swap_buffers_with_damage extension can be layered.
     bool supportsIncrementalPresent = false;
+
+    // Whether texture copies on cube map targets should be done on GPU.  This is a workaround for
+    // Intel drivers on windows that have an issue with creating single-layer views on cube map
+    // textures.
+    bool forceCpuPathForCubeMapCopy = false;
 };
 
 }  // namespace angle

scripts/run_code_generation_hashes.json

@@ -102,7 +102,7 @@
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ImageClear.frag":
     "98d490413d20118e92dd2b160c1dfc6e",
   "Vulkan internal shader programs:src/libANGLE/renderer/vulkan/shaders/src/ImageCopy.frag":
-    "096ccb0e3c25067ddd0347556a12d7d6",
+    "9b9fd690321f53163221f1ebba9f006d",
   "Vulkan mandatory format support table:src/libANGLE/renderer/angle_format.py":
     "b18ca0fe4835114a4a2f54977b19e798",
   "Vulkan mandatory format support table:src/libANGLE/renderer/vulkan/gen_vk_mandatory_format_support_table.py":

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -825,6 +825,9 @@ void RendererVk::initFeatures(const std::vector<VkExtensionProperties> &deviceEx
 #ifdef ANGLE_PLATFORM_WINDOWS
     // http://anglebug.com/2838
     mFeatures.extraCopyBufferRegion = IsIntel(mPhysicalDeviceProperties.vendorID);
+
+    // http://anglebug.com/3055
+    mFeatures.forceCpuPathForCubeMapCopy = IsIntel(mPhysicalDeviceProperties.vendorID);
 #endif
 
     angle::PlatformMethods *platform = ANGLEPlatformCurrent();

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -27,6 +27,16 @@ constexpr size_t kStagingBufferSize = 1024 * 16;
 
 constexpr VkFormatFeatureFlags kBlitFeatureFlags =
     VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
+
+bool CanCopyWithDraw(RendererVk *renderer,
+                     const vk::Format &srcFormat,
+                     const vk::Format &destFormat)
+{
+    return renderer->hasTextureFormatFeatureBits(srcFormat.vkTextureFormat,
+                                                 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) &&
+           renderer->hasTextureFormatFeatureBits(destFormat.vkTextureFormat,
+                                                 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
+}
 }  // anonymous namespace
 
 // StagingStorage implementation.
@@ -575,21 +585,25 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
     const vk::Format &destFormat = renderer->getFormat(internalFormat.sizedInternalFormat);
 
     // TODO(syoussefi): Support draw path for when !mImage.valid().  http://anglebug.com/2958
-    bool canDraw = mImage.valid() &&
-                   renderer->hasTextureFormatFeatureBits(srcFormat.vkTextureFormat,
-                                                         VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) &&
-                   renderer->hasTextureFormatFeatureBits(destFormat.vkTextureFormat,
-                                                         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT);
+    bool canDraw = mImage.valid() && CanCopyWithDraw(renderer, srcFormat, destFormat);
+    bool forceCpuPath =
+        mImage.getLayerCount() > 1 && renderer->getFeatures().forceCpuPathForCubeMapCopy;
 
     // If it's possible to perform the copy with a draw call, do that.
-    if (canDraw)
+    if (canDraw && !forceCpuPath)
     {
-        ANGLE_TRY(ensureImageInitialized(contextVk));
+        RenderTargetVk *colorReadRT = framebufferVk->getColorReadRenderTarget();
+        bool isViewportFlipY        = contextVk->isViewportFlipEnabledForDrawFBO();
+
+        // Layer count can only be 1 as the source is a framebuffer.
+        ASSERT(index.getLayerCount() == 1);
 
-        return copySubImageImplWithDraw(contextVk, index, modifiedDestOffset,
-                                        gl::Offset(clippedSourceArea.x, clippedSourceArea.y, 0),
-                                        gl::Extents(destArea.width, destArea.height, 1),
-                                        framebufferVk);
+        ANGLE_TRY(copySubImageImplWithDraw(
+            contextVk, index, modifiedDestOffset, 0, clippedSourceArea, isViewportFlipY, false,
+            false, false, &colorReadRT->getImage(), colorReadRT->getReadImageView()));
+
+        framebufferVk->getFramebuffer()->addReadDependency(&mImage);
+        return angle::Result::Continue;
     }
 
     // Do a CPU readback that does the conversion, and then stage the change to the pixel buffer.
@@ -603,51 +617,6 @@ angle::Result TextureVk::copySubImageImpl(const gl::Context *context,
     return angle::Result::Continue;
 }
 
-angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
-                                                  const gl::ImageIndex &index,
-                                                  const gl::Offset &destOffset,
-                                                  const gl::Offset &srcOffset,
-                                                  const gl::Extents &extents,
-                                                  FramebufferVk *source)
-{
-    UtilsVk::CopyImageParameters params;
-    params.srcOffset[0]  = srcOffset.x;
-    params.srcOffset[1]  = srcOffset.y;
-    params.srcExtents[0] = extents.width;
-    params.srcExtents[1] = extents.height;
-    params.destOffset[0] = destOffset.x;
-    params.destOffset[1] = destOffset.y;
-    params.srcMip        = 0;
-    params.srcHeight     = source->getReadImageExtents().height;
-    params.flipY         = contextVk->isViewportFlipEnabledForDrawFBO();
-
-    uint32_t level      = index.getLevelIndex();
-    uint32_t baseLayer  = index.hasLayer() ? index.getLayerIndex() : 0;
-    uint32_t layerCount = index.getLayerCount();
-
-    // TODO(syoussefi): currently this is only called from copy[Sub]Image,
-    // where layer count can only be 1, and source's level and layer are both 0.
-    // Once this code is expanded to cover copy[Sub]Texture, it should be
-    // adapted to get single-layer/level image views of the source as well.
-    // http://anglebug.com/2958
-    ASSERT(layerCount == 1);
-    vk::ImageHelper *srcImage = &source->getColorReadRenderTarget()->getImage();
-    vk::ImageView *srcView    = source->getColorReadRenderTarget()->getReadImageView();
-
-    for (uint32_t i = 0; i < layerCount; ++i)
-    {
-        vk::ImageView *destView;
-        ANGLE_TRY(getLayerLevelDrawImageView(contextVk, baseLayer + i, level, &destView));
-
-        ANGLE_TRY(contextVk->getRenderer()->getUtils().copyImage(contextVk, &mImage, destView,
-                                                                 srcImage, srcView, params));
-    }
-
-    source->getFramebuffer()->addReadDependency(&mImage);
-
-    return angle::Result::Continue;
-}
-
 angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
                                             const gl::ImageIndex &index,
                                             const gl::Offset &destOffset,
@@ -661,6 +630,28 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
 {
     RendererVk *renderer = contextVk->getRenderer();
 
+    ANGLE_TRY(source->ensureImageInitialized(contextVk));
+
+    const vk::Format &sourceVkFormat = source->getImage().getFormat();
+    const vk::Format &destVkFormat   = renderer->getFormat(destFormat.sizedInternalFormat);
+
+    // TODO(syoussefi): Support draw path for when !mImage.valid().  http://anglebug.com/2958
+    bool canDraw = mImage.valid() && CanCopyWithDraw(renderer, sourceVkFormat, destVkFormat);
+    bool forceCpuPath =
+        mImage.getLayerCount() > 1 && renderer->getFeatures().forceCpuPathForCubeMapCopy;
+
+    // If it's possible to perform the copy with a draw call, do that.
+    if (canDraw && !forceCpuPath)
+    {
+        ANGLE_TRY(copySubImageImplWithDraw(contextVk, index, destOffset, sourceLevel, sourceArea,
+                                           false, unpackFlipY, unpackPremultiplyAlpha,
+                                           unpackUnmultiplyAlpha, &source->getImage(),
+                                           &source->getReadImageView()));
+
+        source->getImage().addReadDependency(&mImage);
+        return angle::Result::Continue;
+    }
+
     if (sourceLevel != 0)
     {
         WARN() << "glCopyTextureCHROMIUM with sourceLevel != 0 not implemented.";
@@ -671,9 +662,6 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
     uint8_t *sourceData = nullptr;
     ANGLE_TRY(source->copyImageDataToBuffer(contextVk, sourceLevel, 1, sourceArea, &sourceData));
 
-    const vk::Format &sourceVkFormat = source->getImage().getFormat();
-    const vk::Format &destVkFormat   = renderer->getFormat(destFormat.sizedInternalFormat);
-
     const angle::Format &sourceTextureFormat = sourceVkFormat.textureFormat();
     const angle::Format &destTextureFormat   = destVkFormat.textureFormat();
     size_t destinationAllocationSize =
@@ -716,6 +704,53 @@ angle::Result TextureVk::copySubTextureImpl(ContextVk *contextVk,
     return angle::Result::Continue;
 }
 
+angle::Result TextureVk::copySubImageImplWithDraw(ContextVk *contextVk,
+                                                  const gl::ImageIndex &index,
+                                                  const gl::Offset &destOffset,
+                                                  size_t sourceLevel,
+                                                  const gl::Rectangle &sourceArea,
+                                                  bool isSrcFlipY,
+                                                  bool unpackFlipY,
+                                                  bool unpackPremultiplyAlpha,
+                                                  bool unpackUnmultiplyAlpha,
+                                                  vk::ImageHelper *srcImage,
+                                                  const vk::ImageView *srcView)
+{
+    ANGLE_TRY(ensureImageInitialized(contextVk));
+
+    UtilsVk &utilsVk = contextVk->getRenderer()->getUtils();
+
+    UtilsVk::CopyImageParameters params;
+    params.srcOffset[0]        = sourceArea.x;
+    params.srcOffset[1]        = sourceArea.y;
+    params.srcExtents[0]       = sourceArea.width;
+    params.srcExtents[1]       = sourceArea.height;
+    params.destOffset[0]       = destOffset.x;
+    params.destOffset[1]       = destOffset.y;
+    params.srcMip              = sourceLevel;
+    params.srcHeight           = srcImage->getExtents().height;
+    params.srcPremultiplyAlpha = unpackPremultiplyAlpha && !unpackUnmultiplyAlpha;
+    params.srcUnmultiplyAlpha  = unpackUnmultiplyAlpha && !unpackPremultiplyAlpha;
+    params.srcFlipY            = isSrcFlipY;
+    params.destFlipY           = unpackFlipY;
+
+    uint32_t level      = index.getLevelIndex();
+    uint32_t baseLayer  = index.hasLayer() ? index.getLayerIndex() : 0;
+    uint32_t layerCount = index.getLayerCount();
+
+    for (uint32_t layerIndex = 0; layerIndex < layerCount; ++layerIndex)
+    {
+        params.srcLayer = layerIndex;
+
+        vk::ImageView *destView;
+        ANGLE_TRY(getLayerLevelDrawImageView(contextVk, baseLayer + layerIndex, level, &destView));
+
+        ANGLE_TRY(utilsVk.copyImage(contextVk, &mImage, destView, srcImage, srcView, params));
+    }
+
+    return angle::Result::Continue;
+}
+
 angle::Result TextureVk::setStorage(const gl::Context *context,
                                     gl::TextureType type,
                                     size_t levels,

src/libANGLE/renderer/vulkan/TextureVk.h

@@ -244,13 +244,6 @@ class TextureVk : public TextureImpl
                                    const gl::InternalFormat &internalFormat,
                                    gl::Framebuffer *source);
 
-    angle::Result copySubImageImplWithDraw(ContextVk *contextVk,
-                                           const gl::ImageIndex &index,
-                                           const gl::Offset &destOffset,
-                                           const gl::Offset &srcOffset,
-                                           const gl::Extents &extents,
-                                           FramebufferVk *source);
-
     angle::Result copySubTextureImpl(ContextVk *contextVk,
                                      const gl::ImageIndex &index,
                                      const gl::Offset &destOffset,
@@ -262,6 +255,18 @@ class TextureVk : public TextureImpl
                                      bool unpackUnmultiplyAlpha,
                                      TextureVk *source);
 
+    angle::Result copySubImageImplWithDraw(ContextVk *contextVk,
+                                           const gl::ImageIndex &index,
+                                           const gl::Offset &destOffset,
+                                           size_t sourceLevel,
+                                           const gl::Rectangle &sourceArea,
+                                           bool isSrcFlipY,
+                                           bool unpackFlipY,
+                                           bool unpackPremultiplyAlpha,
+                                           bool unpackUnmultiplyAlpha,
+                                           vk::ImageHelper *srcImage,
+                                           const vk::ImageView *srcView);
+
     angle::Result initImage(ContextVk *contextVk,
                             const vk::Format &format,
                             const gl::Extents &extents,

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -133,6 +133,23 @@ uint32_t GetImageCopyFlags(const vk::Format &srcFormat, const vk::Format &destFo
 
     return flags;
 }
+
+uint32_t GetFormatDefaultChannelMask(const vk::Format &format)
+{
+    uint32_t mask = 0;
+
+    const angle::Format &angleFormat   = format.angleFormat();
+    const angle::Format &textureFormat = format.textureFormat();
+
+    // Red can never be introduced due to format emulation (except for luma which is handled
+    // especially)
+    ASSERT(((angleFormat.redBits > 0) == (textureFormat.redBits > 0)) || angleFormat.isLUMA());
+    mask |= angleFormat.greenBits == 0 && textureFormat.greenBits > 0 ? 2 : 0;
+    mask |= angleFormat.blueBits == 0 && textureFormat.blueBits > 0 ? 4 : 0;
+    mask |= angleFormat.alphaBits == 0 && textureFormat.alphaBits > 0 ? 8 : 0;
+
+    return mask;
+}
 }  // namespace
 
 UtilsVk::UtilsVk() = default;
@@ -547,7 +564,7 @@ angle::Result UtilsVk::convertVertexBuffer(vk::Context *context,
 
 angle::Result UtilsVk::startRenderPass(vk::Context *context,
                                        vk::ImageHelper *image,
-                                       vk::ImageView *imageView,
+                                       const vk::ImageView *imageView,
                                        const vk::RenderPassDesc &renderPassDesc,
                                        const gl::Rectangle &renderArea,
                                        vk::CommandBuffer **commandBufferOut)
@@ -633,9 +650,9 @@ angle::Result UtilsVk::clearImage(ContextVk *contextVk,
 
 angle::Result UtilsVk::copyImage(vk::Context *context,
                                  vk::ImageHelper *dest,
-                                 vk::ImageView *destView,
+                                 const vk::ImageView *destView,
                                  vk::ImageHelper *src,
-                                 vk::ImageView *srcView,
+                                 const vk::ImageView *srcView,
                                  const CopyImageParameters &params)
 {
     RendererVk *renderer = context->getRenderer();
@@ -646,24 +663,36 @@ angle::Result UtilsVk::copyImage(vk::Context *context,
     const vk::Format &destFormat = dest->getFormat();
 
     ImageCopyShaderParams shaderParams;
-    shaderParams.flipY            = params.flipY;
+    shaderParams.flipY            = params.srcFlipY || params.destFlipY;
+    shaderParams.premultiplyAlpha = params.srcPremultiplyAlpha;
+    shaderParams.unmultiplyAlpha  = params.srcUnmultiplyAlpha;
     shaderParams.destHasLuminance = destFormat.angleFormat().luminanceBits > 0;
     shaderParams.destIsAlpha =
         destFormat.angleFormat().isLUMA() && destFormat.angleFormat().alphaBits > 0;
-    shaderParams.srcMip        = params.srcMip;
-    shaderParams.srcOffset[0]  = params.srcOffset[0];
-    shaderParams.srcOffset[1]  = params.srcOffset[1];
-    shaderParams.destOffset[0] = params.destOffset[0];
-    shaderParams.destOffset[1] = params.destOffset[1];
-
-    if (params.flipY)
+    shaderParams.destDefaultChannelsMask = GetFormatDefaultChannelMask(destFormat);
+    shaderParams.srcMip                  = params.srcMip;
+    shaderParams.srcLayer                = params.srcLayer;
+    shaderParams.srcOffset[0]            = params.srcOffset[0];
+    shaderParams.srcOffset[1]            = params.srcOffset[1];
+    shaderParams.destOffset[0]           = params.destOffset[0];
+    shaderParams.destOffset[1]           = params.destOffset[1];
+
+    ASSERT(!(params.srcFlipY && params.destFlipY));
+    if (params.srcFlipY)
     {
         // If viewport is flipped, the shader expects srcOffset[1] to have the
         // last row's index instead of the first's.
-        shaderParams.srcOffset[1] = params.srcHeight - shaderParams.srcOffset[1] - 1;
+        shaderParams.srcOffset[1] = params.srcHeight - params.srcOffset[1] - 1;
+    }
+    else if (params.destFlipY)
+    {
+        // If image is flipped during copy, the shader uses the same code path as above,
+        // with srcOffset being set to the last row's index instead of the first's.
+        shaderParams.srcOffset[1] = params.srcOffset[1] + params.srcExtents[1] - 1;
     }
 
     uint32_t flags = GetImageCopyFlags(srcFormat, destFormat);
+    flags |= src->getLayerCount() > 1 ? ImageCopy_frag::kSrcIsArray : 0;
 
     VkDescriptorSet descriptorSet;
     vk::SharedDescriptorPoolBinding descriptorPoolBinding;