Changeset 282627 in webkit

Timestamp:

Sep 16, 2021, 6:59:06 PM (5 years ago)

Author:

Kyle Piddington

Message:

webgl/2.0.y/conformance/extensions/webgl-compressed-texture-s3tc-srgb.html fails on Intel+AMD Metal
​https://bugs.webkit.org/show_bug.cgi?id=229941

Zero-initialize compressed textures explicitly, as they aren't implicitly initalized in Metal.
Reviewed by Kenneth Russell <​kbr@chromium.org>.

Source/ThirdParty/ANGLE:

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

(rx::mtl::GetCompressedBufferForTextureWithFormat):
(rx::mtl::InitializeCompressedTextureContents):
(rx::mtl::InitializeTextureContents):

LayoutTests:

• TestExpectations:

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/TestExpectations (modified) (1 diff)
• Source/ThirdParty/ANGLE/ChangeLog (modified) (1 diff)
• Source/ThirdParty/ANGLE/src/libANGLE/renderer/metal/mtl_utils.mm (modified) (3 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2021-09-16  Kyle Piddington  <kpiddington@apple.com>
+
+        webgl/2.0.y/conformance/extensions/webgl-compressed-texture-s3tc-srgb.html fails on Intel+AMD Metal
+        https://bugs.webkit.org/show_bug.cgi?id=229941
+
+        Zero-initialize compressed textures explicitly, as they aren't implicitly initalized in Metal.
+        Reviewed by Kenneth Russell <kbr@chromium.org>.
+
+        * TestExpectations:
+
 2021-09-16  Cameron McCormack  <heycam@apple.com>
 

trunk/LayoutTests/TestExpectations

@@ -3697 +3697 @@
 webgl/2.0.y/conformance2/vertex_arrays/vertex-array-object.html [ Pass ]
 webgl/1.0.x/conformance/extensions/oes-vertex-array-object.html [ Pass ]
+
+# Explicitly turn on conformance test until all of webgl/2.0.y is enabled
+webgl/2.0.y/conformance/extensions/webgl-compressed-texture-s3tc-srgb.html [ Pass ]
 
 # WebGL 1.0.3 and 2.0.0 tests where behavior is obsolete and WebKit contains implementation

trunk/Source/ThirdParty/ANGLE/ChangeLog

@@ +1 @@
+2021-09-16  Kyle Piddington  <kpiddington@apple.com>
+
+        webgl/2.0.y/conformance/extensions/webgl-compressed-texture-s3tc-srgb.html fails on Intel+AMD Metal
+        https://bugs.webkit.org/show_bug.cgi?id=229941
+
+        Zero-initialize compressed textures explicitly, as they aren't implicitly initalized in Metal.
+        Reviewed by Kenneth Russell <kbr@chromium.org>.
+
+        * src/libANGLE/renderer/metal/mtl_utils.h:
+        * src/libANGLE/renderer/metal/mtl_utils.mm:
+        (rx::mtl::GetCompressedBufferForTextureWithFormat):
+        (rx::mtl::InitializeCompressedTextureContents):
+        (rx::mtl::InitializeTextureContents):
+
 2021-08-31  Kimmo Kinnunen  <kkinnunen@apple.com>
 

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

@@ -104 +104 @@
 }
 
+bool GetCompressedBufferSizeAndRowLengthForTextureWithFormat(const TextureRef &texture,
+                                                             const Format &textureObjFormat,
+                                                             const ImageNativeIndex &index,
+                                                             size_t *bytesPerRowOut,
+                                                             size_t *bytesPerImageOut)
+{
+    gl::Extents size = texture->size(index);
+    GLuint bufferSizeInBytes;
+    uint32_t bufferRowLength;
+    if (!textureObjFormat.intendedInternalFormat().computeCompressedImageSize(size,
+                                                                              &bufferSizeInBytes))
+    {
+        return false;
+    }
+    if (!textureObjFormat.intendedInternalFormat().computeBufferRowLength(size.width,
+                                                                          &bufferRowLength))
+    {
+        return false;
+    }
+    *bytesPerImageOut = bufferSizeInBytes;
+    *bytesPerRowOut   = bufferRowLength;
+    return true;
+}
+
+static angle::Result InitializeCompressedTextureContents(const gl::Context *context,
+                                                         const TextureRef &texture,
+                                                         const Format &textureObjFormat,
+                                                         const ImageNativeIndex &index,
+                                                         const uint layer,
+                                                         const uint startDepth)
+{
+    assert(textureObjFormat.actualAngleFormat().isBlock);
+    size_t bytesPerRow   = 0;
+    size_t bytesPerImage = 0;
+
+    if (!GetCompressedBufferSizeAndRowLengthForTextureWithFormat(texture, textureObjFormat, index,
+                                                                 &bytesPerRow, &bytesPerImage))
+    {
+        return angle::Result::Stop;
+    }
+    ContextMtl *contextMtl = mtl::GetImpl(context);
+    gl::Extents extents    = texture->size(index);
+    if (texture->isCPUAccessible())
+    {
+        angle::MemoryBuffer buffer;
+        if (!buffer.resize(bytesPerImage))
+        {
+            return angle::Result::Stop;
+        }
+        buffer.fill(0);
+        for (NSUInteger d = 0; d < static_cast<NSUInteger>(extents.depth); ++d)
+        {
+            auto mtlTextureRegion     = MTLRegionMake2D(0, 0, extents.width, extents.height);
+            mtlTextureRegion.origin.z = d + startDepth;
+            texture->replaceRegion(contextMtl, mtlTextureRegion, index.getNativeLevel(), layer,
+                                   buffer.data(), bytesPerRow, 0);
+        }
+    }
+    else
+    {
+        mtl::BufferRef zeroBuffer;
+        ANGLE_TRY(mtl::Buffer::MakeBuffer(contextMtl, bytesPerImage, nullptr, &zeroBuffer));
+        mtl::BlitCommandEncoder *blitEncoder = contextMtl->getBlitCommandEncoder();
+        for (NSUInteger d = 0; d < static_cast<NSUInteger>(extents.depth); ++d)
+        {
+            auto blitOrigin = MTLOriginMake(0, 0, d + startDepth);
+            blitEncoder->copyBufferToTexture(zeroBuffer, 0, bytesPerRow, 0,
+                                             MTLSizeMake(extents.width, extents.height, 1), texture,
+                                             layer, index.getNativeLevel(), blitOrigin, 0);
+        }
+
+        blitEncoder->endEncoding();
+    }
+    return angle::Result::Continue;
+}
+
 angle::Result InitializeTextureContents(const gl::Context *context,
                                         const TextureRef &texture,
@@ -119 +195 @@
     forceGPUInitialization = true;
 #endif // TARGET_OS_SIMULATOR
-    
+
     // 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:
-    if (!textureObjFormat.valid() || actualAngleFormat.isBlock || actualAngleFormat.depthBits > 0 ||
+    // TODO: (kpiddington) update InitializeTextureContents with an upstreamed version that handles
+    // depth/stencil textures.
+    if (!textureObjFormat.valid() || actualAngleFormat.depthBits > 0 ||
         actualAngleFormat.stencilBits > 0)
     {
-        // If dst format is compressed, ignore.
+        // Depth or stencil textures need an updated path.
         return angle::Result::Continue;
     }
@@ -151 +229 @@
                 break;
         }
+    }
+
+    if (actualAngleFormat.isBlock)
+    {
+        return InitializeCompressedTextureContents(context, texture, textureObjFormat, index, layer,
+                                                   startDepth);
     }