Revert "Vulkan: readPixels improvement - use DynamicBuffer"

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -31,8 +31,6 @@ namespace rx
 
 namespace
 {
-constexpr size_t kMinReadPixelsBufferSize = 128000;
-
 const gl::InternalFormat &GetReadAttachmentInfo(const gl::Context *context,
                                                 RenderTargetVk *renderTarget)
 {
@@ -61,10 +59,8 @@ FramebufferVk::FramebufferVk(const gl::FramebufferState &state)
       mRenderPassDesc(),
       mFramebuffer(),
       mActiveColorComponents(0),
-      mMaskedClearDescriptorSet(VK_NULL_HANDLE),
-      mReadPixelsBuffer(VK_BUFFER_USAGE_TRANSFER_DST_BIT, kMinReadPixelsBufferSize)
+      mMaskedClearDescriptorSet(VK_NULL_HANDLE)
 {
-    mReadPixelsBuffer.init(1);
 }
 
 FramebufferVk::FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk *backbuffer)
@@ -73,10 +69,8 @@ FramebufferVk::FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk
       mRenderPassDesc(),
       mFramebuffer(),
       mActiveColorComponents(0),
-      mMaskedClearDescriptorSet(VK_NULL_HANDLE),
-      mReadPixelsBuffer(VK_BUFFER_USAGE_TRANSFER_DST_BIT, kMinReadPixelsBufferSize)
+      mMaskedClearDescriptorSet(VK_NULL_HANDLE)
 {
-    mReadPixelsBuffer.init(1);
 }
 
 FramebufferVk::~FramebufferVk()
@@ -85,13 +79,10 @@ FramebufferVk::~FramebufferVk()
 
 void FramebufferVk::destroy(const gl::Context *context)
 {
-    ContextVk *contextVk = vk::GetImpl(context);
-    RendererVk *renderer = contextVk->getRenderer();
+    RendererVk *renderer = vk::GetImpl(context)->getRenderer();
     renderer->releaseResource(*this, &mFramebuffer);
     renderer->releaseResource(*this, &mMaskedClearUniformBuffer.buffer);
     renderer->releaseResource(*this, &mMaskedClearUniformBuffer.memory);
-
-    mReadPixelsBuffer.destroy(contextVk->getDevice());
 }
 
 gl::Error FramebufferVk::discard(const gl::Context *context,
@@ -296,10 +287,8 @@ gl::Error FramebufferVk::readPixels(const gl::Context *context,
     }
 
     const gl::State &glState = context->getGLState();
-    RendererVk *renderer     = vk::GetImpl(context)->getRenderer();
-
-    vk::CommandBuffer *commandBuffer = nullptr;
-    ANGLE_TRY(beginWriteResource(renderer, &commandBuffer));
+    RenderTargetVk *renderTarget = getColorReadRenderTarget();
+    ASSERT(renderTarget);
 
     const gl::PixelPackState &packState       = context->getGLState().getPackState();
     const gl::InternalFormat &sizedFormatInfo = gl::GetInternalFormatInfo(format, type);
@@ -316,18 +305,17 @@ gl::Error FramebufferVk::readPixels(const gl::Context *context,
                        (clippedArea.y - area.y) * outputPitch;
 
     PackPixelsParams params;
-    params.area        = clippedArea;
+    params.area        = area;
     params.format      = format;
     params.type        = type;
     params.outputPitch = outputPitch;
     params.packBuffer  = glState.getTargetBuffer(gl::BufferBinding::PixelPack);
     params.pack        = glState.getPackState();
 
-    ANGLE_TRY(ReadPixelsFromRenderTarget(context, clippedArea, params, mReadPixelsBuffer,
-                                         getColorReadRenderTarget(), commandBuffer,
-                                         reinterpret_cast<uint8_t *>(pixels) + outputSkipBytes));
-    mReadPixelsBuffer.releaseRetainedBuffers(renderer);
-    return gl::NoError();
+    vk::CommandBuffer *commandBuffer = nullptr;
+    ANGLE_TRY(beginWriteResource(vk::GetImpl(context)->getRenderer(), &commandBuffer));
+    return ReadPixelsFromRenderTarget(context, clippedArea, params, renderTarget, commandBuffer,
+                                      reinterpret_cast<uint8_t *>(pixels) + outputSkipBytes);
 }
 
 RenderTargetVk *FramebufferVk::getColorReadRenderTarget()
@@ -814,52 +802,48 @@ void FramebufferVk::updateActiveColorMasks(size_t colorIndex, bool r, bool g, bo
 gl::Error ReadPixelsFromRenderTarget(const gl::Context *context,
                                      const gl::Rectangle &area,
                                      const PackPixelsParams &packPixelsParams,
-                                     vk::DynamicBuffer &dynamicBuffer,
                                      RenderTargetVk *renderTarget,
                                      vk::CommandBuffer *commandBuffer,
                                      void *pixels)
 {
-    RendererVk *renderer = vk::GetImpl(context)->getRenderer();
+    ContextVk *contextVk = vk::GetImpl(context);
+    RendererVk *renderer = contextVk->getRenderer();
+    VkDevice device      = renderer->getDevice();
+
+    vk::ImageHelper stagingImage;
+    ANGLE_TRY(stagingImage.init2DStaging(
+        device, renderer->getMemoryProperties(), renderTarget->image->getFormat(),
+        gl::Extents(area.width, area.height, 1), vk::StagingUsage::Read));
+
+    stagingImage.changeLayoutWithStages(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL,
+                                        VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                                        VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
+
+    vk::ImageHelper::Copy(renderTarget->image, &stagingImage, gl::Offset(area.x, area.y, 0),
+                          gl::Offset(), gl::Extents(area.width, area.height, 1),
+                          VK_IMAGE_ASPECT_COLOR_BIT, commandBuffer);
 
-    vk::ImageHelper *renderTargetImage = renderTarget->image;
-    const angle::Format &angleFormat   = renderTargetImage->getFormat().textureFormat();
-    VkBuffer bufferHandle              = VK_NULL_HANDLE;
-    uint8_t *readPixelBuffer           = nullptr;
-    bool newBufferAllocated            = false;
-    uint32_t stagingOffset             = 0;
-    size_t allocationSize              = area.width * angleFormat.pixelBytes * area.height;
-
-    dynamicBuffer.allocate(renderer, allocationSize, &readPixelBuffer, &bufferHandle,
-                           &stagingOffset, &newBufferAllocated);
-
-    VkBufferImageCopy region;
-    region.bufferImageHeight               = area.height;
-    region.bufferOffset                    = static_cast<VkDeviceSize>(stagingOffset);
-    region.bufferRowLength                 = area.width;
-    region.imageExtent.width               = area.width;
-    region.imageExtent.height              = area.height;
-    region.imageExtent.depth               = 1;
-    region.imageOffset.x                   = area.x;
-    region.imageOffset.y                   = area.y;
-    region.imageOffset.z                   = 0;
-    region.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
-    region.imageSubresource.baseArrayLayer = 0;
-    region.imageSubresource.layerCount     = 1;
-    region.imageSubresource.mipLevel       = 0;
-
-    renderTargetImage->changeLayoutWithStages(
-        VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-        VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, commandBuffer);
-
-    commandBuffer->copyImageToBuffer(renderTargetImage->getImage(),
-                                     renderTargetImage->getCurrentLayout(), bufferHandle, 1,
-                                     &region);
     // Triggers a full finish.
     // TODO(jmadill): Don't block on asynchronous readback.
     ANGLE_TRY(renderer->finish(context));
 
-    PackPixels(packPixelsParams, angleFormat, area.width * angleFormat.pixelBytes, readPixelBuffer,
-               reinterpret_cast<uint8_t *>(pixels));
+    // TODO(jmadill): parameters
+    uint8_t *mapPointer = nullptr;
+    ANGLE_TRY(stagingImage.getDeviceMemory().map(device, 0, stagingImage.getAllocatedMemorySize(),
+                                                 0, &mapPointer));
+
+    const angle::Format &angleFormat = renderTarget->image->getFormat().textureFormat();
+
+    // Get the staging image pitch and use it to pack the pixels later.
+    VkSubresourceLayout subresourceLayout;
+    stagingImage.getImage().getSubresourceLayout(device, VK_IMAGE_ASPECT_COLOR_BIT, 0, 0,
+                                                 &subresourceLayout);
+
+    PackPixels(packPixelsParams, angleFormat, static_cast<int>(subresourceLayout.rowPitch),
+               mapPointer, reinterpret_cast<uint8_t *>(pixels));
+
+    stagingImage.getDeviceMemory().unmap(device);
+    renderer->releaseObject(renderer->getCurrentQueueSerial(), &stagingImage);
 
     return vk::NoError();
 }

src/libANGLE/renderer/vulkan/FramebufferVk.h

@@ -12,7 +12,6 @@
 
 #include "libANGLE/renderer/FramebufferImpl.h"
 #include "libANGLE/renderer/RenderTargetCache.h"
-#include "libANGLE/renderer/vulkan/BufferVk.h"
 #include "libANGLE/renderer/vulkan/CommandGraph.h"
 #include "libANGLE/renderer/vulkan/vk_cache_utils.h"
 
@@ -119,14 +118,11 @@ class FramebufferVk : public FramebufferImpl, public vk::CommandGraphResource
     // For use in masked clear.
     vk::BufferAndMemory mMaskedClearUniformBuffer;
     VkDescriptorSet mMaskedClearDescriptorSet;
-
-    vk::DynamicBuffer mReadPixelsBuffer;
 };
 
 gl::Error ReadPixelsFromRenderTarget(const gl::Context *context,
                                      const gl::Rectangle &area,
                                      const PackPixelsParams &packPixelsParams,
-                                     vk::DynamicBuffer &dynamicBuffer,
                                      RenderTargetVk *renderTarget,
                                      vk::CommandBuffer *commandBuffer,
                                      void *pixels);

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -205,8 +205,8 @@ gl::Error PixelBuffer::stageSubresourceUpdateFromRenderTarget(const gl::Context
         ANGLE_TRY(context->getScratchBuffer(bufferSize, &memoryBuffer));
 
         // Read into the scratch buffer
-        ANGLE_TRY(ReadPixelsFromRenderTarget(context, sourceArea, params, mStagingBuffer,
-                                             renderTarget, commandBuffer, memoryBuffer->data()));
+        ANGLE_TRY(ReadPixelsFromRenderTarget(context, sourceArea, params, renderTarget,
+                                             commandBuffer, memoryBuffer->data()));
 
         // Load from scratch buffer to our pixel buffer
         loadFunction.loadFunction(sourceArea.width, sourceArea.height, 1, memoryBuffer->data(),
@@ -215,8 +215,8 @@ gl::Error PixelBuffer::stageSubresourceUpdateFromRenderTarget(const gl::Context
     else
     {
         // We read directly from the framebuffer into our pixel buffer.
-        ANGLE_TRY(ReadPixelsFromRenderTarget(context, sourceArea, params, mStagingBuffer,
-                                             renderTarget, commandBuffer, stagingPointer));
+        ANGLE_TRY(ReadPixelsFromRenderTarget(context, sourceArea, params, renderTarget,
+                                             commandBuffer, stagingPointer));
     }
 
     // 3- enqueue the destination image subresource update