Changeset 276190 in webkit

Timestamp:

Apr 16, 2021, 7:06:15 PM (5 years ago)

Author:

commit-queue@webkit.org

Message:

Metal-ANGLE: Shared memory texture tests failing in iOS Simulator
​https://bugs.webkit.org/show_bug.cgi?id=222685

Patch by Kyle Piddington <Kyle Piddington> on 2021-04-16
Reviewed by Dean Jackson.

Simulator-only path drives filling textures via Blit encoders instead of mapped memory.
This workaround fixes dropped texture writes when using replaceRegion

• src/libANGLE/renderer/metal/TextureMtl.mm:
• src/libANGLE/renderer/metal/mtl_utils.mm:

(rx::mtl::InitializeTextureContents):

Location:

trunk/Source/ThirdParty/ANGLE

Files:

• ChangeLog (modified) (1 diff)
• src/libANGLE/renderer/metal/TextureMtl.mm (modified) (6 diffs)
• src/libANGLE/renderer/metal/mtl_utils.mm (modified) (3 diffs)

trunk/Source/ThirdParty/ANGLE/ChangeLog

@@ +1 @@
+2021-04-16  Kyle Piddington  <kpiddington@apple.com>
+
+        Metal-ANGLE: Shared memory texture tests failing in iOS Simulator
+        https://bugs.webkit.org/show_bug.cgi?id=222685
+
+        Reviewed by Dean Jackson.
+
+        Simulator-only path drives filling textures via Blit encoders instead of mapped memory.
+        This workaround fixes dropped texture writes when using replaceRegion
+
+        * src/libANGLE/renderer/metal/TextureMtl.mm:
+        * src/libANGLE/renderer/metal/mtl_utils.mm:
+        (rx::mtl::InitializeTextureContents):
+
 2021-04-15  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/ThirdParty/ANGLE/src/libANGLE/renderer/metal/TextureMtl.mm

@@ -175 +175 @@
 }
 
+
+#if TARGET_OS_SIMULATOR
+void CopyTextureData(const MTLSize &regionSize,
+                             size_t srcRowPitch,
+                             size_t src2DImageSize,
+                             const uint8_t *psrc,
+                             size_t destRowPitch,
+                             size_t dest2DImageSize,
+                             uint8_t *pdst)
+{
+    {
+        size_t rowCopySize = std::min(srcRowPitch, destRowPitch);
+        for (NSUInteger d = 0; d < regionSize.depth; ++d)
+        {
+            for (NSUInteger r = 0; r < regionSize.height; ++r)
+            {
+                const uint8_t *pCopySrc = psrc + d * src2DImageSize + r * srcRowPitch;
+                uint8_t *pCopyDst       = pdst + d * dest2DImageSize + r * destRowPitch;
+                memcpy(pCopyDst, pCopySrc, rowCopySize);
+            }
+        }
+    }
+}
+#endif
+
 void ConvertDepthStencilData(const MTLSize &regionSize,
                              const angle::Format &srcAngleFormat,
@@ -266 +291 @@
     return angle::Result::Continue;
 }
+
+#if TARGET_OS_SIMULATOR
+angle::Result CopyTextureContentsToStagingBuffer(
+    ContextMtl *contextMtl,
+    const angle::Format &textureAngleFormat,
+    const MTLSize &regionSize,
+    const uint8_t *data,
+    size_t bytesPerRow,
+    size_t bytesPer2DImage,
+    size_t *bufferRowPitchOut,
+    size_t *buffer2DImageSizeOut,
+    mtl::BufferRef *bufferOut)
+{
+    size_t stagingBufferRowPitch    = regionSize.width * textureAngleFormat.pixelBytes;
+    size_t stagingBuffer2DImageSize = stagingBufferRowPitch * regionSize.height;
+    size_t stagingBufferSize        = stagingBuffer2DImageSize * regionSize.depth;
+    mtl::BufferRef stagingBuffer;
+    ANGLE_TRY(mtl::Buffer::MakeBuffer(contextMtl, stagingBufferSize, nullptr, &stagingBuffer));
+
+    uint8_t *pdst = stagingBuffer->map(contextMtl);
+
+    CopyTextureData(regionSize, bytesPerRow, bytesPer2DImage,
+                    data, stagingBufferRowPitch, stagingBuffer2DImageSize, pdst);
+
+    stagingBuffer->unmap(contextMtl);
+
+    *bufferOut            = stagingBuffer;
+    *bufferRowPitchOut    = stagingBufferRowPitch;
+    *buffer2DImageSizeOut = stagingBuffer2DImageSize;
+
+    return angle::Result::Continue;
+}
+#endif
 
 angle::Result UploadDepthStencilTextureContentsWithStagingBuffer(
@@ -379 +437 @@
 }
 
+#if TARGET_OS_SIMULATOR
+angle::Result UploadTextureContentsWithStagingBuffer(
+    ContextMtl *contextMtl,
+    const angle::Format &textureAngleFormat,
+    MTLRegion region,
+    const mtl::MipmapNativeLevel &mipmapLevel,
+    uint32_t slice,
+    const uint8_t *data,
+    size_t bytesPerRow,
+    size_t bytesPer2DImage,
+    const mtl::TextureRef &texture)
+{
+    ASSERT(texture && texture->valid());
+    
+    angle::FormatID stagingBufferFormatID = textureAngleFormat.id;
+    const angle::Format &angleStagingFormat = angle::Format::Get(stagingBufferFormatID);
+    
+
+    size_t stagingBufferRowPitch;
+    size_t stagingBuffer2DImageSize;
+    mtl::BufferRef stagingBuffer;
+
+    // Copy depth data to staging depth buffer
+    ANGLE_TRY(CopyTextureContentsToStagingBuffer(contextMtl, angleStagingFormat, region.size, data, bytesPerRow, bytesPer2DImage, &stagingBufferRowPitch, &stagingBuffer2DImageSize, &stagingBuffer));
+    mtl::BlitCommandEncoder *encoder = contextMtl->getBlitCommandEncoder();
+
+    encoder->copyBufferToTexture(stagingBuffer, 0, stagingBufferRowPitch,
+                                 stagingBuffer2DImageSize, region.size, texture, slice,
+                                 mipmapLevel, region.origin, 0);
+    
+
+    return angle::Result::Continue;
+}
+#endif
+
 angle::Result UploadTextureContents(const gl::Context *context,
                                     const angle::Format &textureAngleFormat,
@@ -391 +484 @@
     ASSERT(texture && texture->valid());
     ContextMtl *contextMtl = mtl::GetImpl(context);
-
+#if TARGET_OS_SIMULATOR
+    if (!textureAngleFormat.depthBits && !textureAngleFormat.stencilBits)
+    {
+        ANGLE_TRY(UploadTextureContentsWithStagingBuffer(contextMtl,textureAngleFormat,region,mipmapLevel,slice,data,bytesPerRow,bytesPer2DImage,texture));
+        return angle::Result::Continue;
+    }
+#else
     if (texture->isCPUAccessible())
     {
@@ -400 +499 @@
         return angle::Result::Continue;
     }
-
+#endif
     ASSERT(textureAngleFormat.depthBits || textureAngleFormat.stencilBits);
 
@@ -418 +517 @@
 
     return angle::Result::Continue;
+    
 }
 

trunk/Source/ThirdParty/ANGLE/src/libANGLE/renderer/metal/mtl_utils.mm

@@ -114 +114 @@
     const angle::Format &actualAngleFormat           = textureObjFormat.actualAngleFormat();
     const gl::InternalFormat &intendedInternalFormat = textureObjFormat.intendedInternalFormat();
-
+    bool forceGPUInitialization = false;
+#if TARGET_OS_SIMULATOR
+    forceGPUInitialization = true;
+#endif
     // This function is called in many places to initialize the content of a texture.
     // So it's better we do the sanity check here instead of let the callers do it themselves:
@@ -149 +152 @@
 
     if (texture->isCPUAccessible() && index.getType() != gl::TextureType::_2DMultisample &&
-        index.getType() != gl::TextureType::_2DMultisampleArray)
+        index.getType() != gl::TextureType::_2DMultisampleArray && forceGPUInitialization == false)
     {
         const angle::Format &dstFormat = angle::Format::Get(textureObjFormat.actualFormatId);
@@ -199 +202 @@
         }
     }  // if (texture->isCPUAccessible())
+
     else
     {