Metal: Implement EGL_ANGLE_iosurface_client_buffer.

scripts/code_generation_hashes/Metal_format_table.json

@@ -2,9 +2,9 @@
   "src/libANGLE/renderer/angle_format.py":
     "32ba71942c0fd00e6807104f1bb80a3c",
   "src/libANGLE/renderer/metal/gen_mtl_format_table.py":
-    "b6468446dd1da3e44ac9dd11690b5bf1",
+    "780f56abea19db610d2b829ba817fdc6",
   "src/libANGLE/renderer/metal/mtl_format_map.json":
-    "223e0b729f5df7d91af382fa3af32254",
+    "7aad5b3ed806e0d932cbbfe6d3b8a834",
   "src/libANGLE/renderer/metal/mtl_format_table_autogen.mm":
-    "d924184394625032e8a3e97c8b936a5f"
+    "efd031ead828c19f5476413b2b743087"
 }
\ No newline at end of file

src/libANGLE/renderer/metal/DisplayMtl.h

@@ -93,6 +93,11 @@ class DisplayMtl : public DisplayImpl
 
     bool isValidNativeWindow(EGLNativeWindowType window) const override;
 
+    egl::Error validateClientBuffer(const egl::Config *configuration,
+                                    EGLenum buftype,
+                                    EGLClientBuffer clientBuffer,
+                                    const egl::AttributeMap &attribs) const override;
+
     egl::ConfigSet generateConfigs() override;
 
     std::string getRendererDescription() const;

src/libANGLE/renderer/metal/DisplayMtl.mm

@@ -166,8 +166,7 @@ SurfaceImpl *DisplayMtl::createWindowSurface(const egl::SurfaceState &state,
 SurfaceImpl *DisplayMtl::createPbufferSurface(const egl::SurfaceState &state,
                                               const egl::AttributeMap &attribs)
 {
-    UNIMPLEMENTED();
-    return static_cast<SurfaceImpl *>(0);
+    return new PBufferSurfaceMtl(this, state, attribs);
 }
 
 SurfaceImpl *DisplayMtl::createPbufferFromClientBuffer(const egl::SurfaceState &state,
@@ -175,8 +174,15 @@ SurfaceImpl *DisplayMtl::createPbufferFromClientBuffer(const egl::SurfaceState &
                                                        EGLClientBuffer clientBuffer,
                                                        const egl::AttributeMap &attribs)
 {
-    UNIMPLEMENTED();
-    return static_cast<SurfaceImpl *>(0);
+    switch (buftype)
+    {
+        case EGL_IOSURFACE_ANGLE:
+            return new IOSurfaceSurfaceMtl(this, state, clientBuffer, attribs);
+            break;
+        default:
+            UNREACHABLE();
+    }
+    return nullptr;
 }
 
 SurfaceImpl *DisplayMtl::createPixmapSurface(const egl::SurfaceState &state,
@@ -249,6 +255,7 @@ egl::Error DisplayMtl::makeCurrent(egl::Surface *drawSurface,
 void DisplayMtl::generateExtensions(egl::DisplayExtensions *outExtensions) const
 {
     outExtensions->flexibleSurfaceCompatibility = true;
+    outExtensions->iosurfaceClientBuffer        = true;
 }
 
 void DisplayMtl::generateCaps(egl::Caps *outCaps) const {}
@@ -278,9 +285,10 @@ egl::ConfigSet DisplayMtl::generateConfigs()
     config.transparentType = EGL_NONE;
 
     // Pbuffer
-    config.maxPBufferWidth  = 4096;
-    config.maxPBufferHeight = 4096;
-    config.maxPBufferPixels = 4096 * 4096;
+    config.bindToTextureTarget = EGL_TEXTURE_2D;
+    config.maxPBufferWidth     = 4096;
+    config.maxPBufferHeight    = 4096;
+    config.maxPBufferPixels    = 4096 * 4096;
 
     // Caveat
     config.configCaveat = EGL_NONE;
@@ -290,9 +298,9 @@ egl::ConfigSet DisplayMtl::generateConfigs()
     config.samples           = 0;
     config.level             = 0;
     config.bindToTextureRGB  = EGL_FALSE;
-    config.bindToTextureRGBA = EGL_FALSE;
+    config.bindToTextureRGBA = EGL_TRUE;
 
-    config.surfaceType = EGL_WINDOW_BIT;
+    config.surfaceType = EGL_WINDOW_BIT | EGL_PBUFFER_BIT;
 
 #if TARGET_OS_OSX || TARGET_OS_MACCATALYST
     config.minSwapInterval = 0;
@@ -360,6 +368,26 @@ bool DisplayMtl::isValidNativeWindow(EGLNativeWindowType window) const
     }
 }
 
+egl::Error DisplayMtl::validateClientBuffer(const egl::Config *configuration,
+                                            EGLenum buftype,
+                                            EGLClientBuffer clientBuffer,
+                                            const egl::AttributeMap &attribs) const
+{
+    switch (buftype)
+    {
+        case EGL_IOSURFACE_ANGLE:
+            if (!IOSurfaceSurfaceMtl::ValidateAttributes(clientBuffer, attribs))
+            {
+                return egl::EglBadAttribute();
+            }
+            break;
+        default:
+            UNREACHABLE();
+            return egl::EglBadAttribute();
+    }
+    return egl::NoError();
+}
+
 std::string DisplayMtl::getRendererDescription() const
 {
     ANGLE_MTL_OBJC_SCOPE

src/libANGLE/renderer/metal/SurfaceMtl.h

@@ -158,6 +158,79 @@ class WindowSurfaceMtl : public SurfaceMtl
     CGSize mCurrentKnownDrawableSize;
 };
 
+// Offscreen surface, base class of PBuffer, IOSurface.
+class OffscreenSurfaceMtl : public SurfaceMtl
+{
+  public:
+    OffscreenSurfaceMtl(DisplayMtl *display,
+                        const egl::SurfaceState &state,
+                        const egl::AttributeMap &attribs);
+    ~OffscreenSurfaceMtl() override;
+
+    void destroy(const egl::Display *display) override;
+
+    egl::Error swap(const gl::Context *context) override;
+
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
+
+    angle::Result getAttachmentRenderTarget(const gl::Context *context,
+                                            GLenum binding,
+                                            const gl::ImageIndex &imageIndex,
+                                            GLsizei samples,
+                                            FramebufferAttachmentRenderTarget **rtOut) override;
+
+  protected:
+    angle::Result ensureTexturesSizeCorrect(const gl::Context *context);
+
+    gl::Extents mSize;
+};
+
+// PBuffer surface
+class PBufferSurfaceMtl : public OffscreenSurfaceMtl
+{
+  public:
+    PBufferSurfaceMtl(DisplayMtl *display,
+                      const egl::SurfaceState &state,
+                      const egl::AttributeMap &attribs);
+
+    void setFixedWidth(EGLint width) override;
+    void setFixedHeight(EGLint height) override;
+};
+
+// Offscreen created from IOSurface
+class IOSurfaceSurfaceMtl : public OffscreenSurfaceMtl
+{
+  public:
+    IOSurfaceSurfaceMtl(DisplayMtl *display,
+                        const egl::SurfaceState &state,
+                        EGLClientBuffer buffer,
+                        const egl::AttributeMap &attribs);
+    ~IOSurfaceSurfaceMtl() override;
+
+    egl::Error bindTexImage(const gl::Context *context,
+                            gl::Texture *texture,
+                            EGLint buffer) override;
+    egl::Error releaseTexImage(const gl::Context *context, EGLint buffer) override;
+
+    angle::Result getAttachmentRenderTarget(const gl::Context *context,
+                                            GLenum binding,
+                                            const gl::ImageIndex &imageIndex,
+                                            GLsizei samples,
+                                            FramebufferAttachmentRenderTarget **rtOut) override;
+
+    static bool ValidateAttributes(EGLClientBuffer buffer, const egl::AttributeMap &attribs);
+
+  private:
+    angle::Result ensureColorTextureCreated(const gl::Context *context);
+
+    IOSurfaceRef mIOSurface;
+    NSUInteger mIOSurfacePlane;
+    int mIOSurfaceFormatIdx;
+};
+
 }  // namespace rx
 
 #endif /* LIBANGLE_RENDERER_METAL_SURFACEMTL_H_ */

src/libANGLE/renderer/metal/TextureMtl.mm

@@ -14,9 +14,11 @@
 #include "common/MemoryBuffer.h"
 #include "common/debug.h"
 #include "common/mathutil.h"
+#include "libANGLE/Surface.h"
 #include "libANGLE/renderer/metal/ContextMtl.h"
 #include "libANGLE/renderer/metal/DisplayMtl.h"
 #include "libANGLE/renderer/metal/FrameBufferMtl.h"
+#include "libANGLE/renderer/metal/SurfaceMtl.h"
 #include "libANGLE/renderer/metal/mtl_common.h"
 #include "libANGLE/renderer/metal/mtl_format_utils.h"
 #include "libANGLE/renderer/metal/mtl_utils.h"
@@ -732,16 +734,32 @@ angle::Result TextureMtl::setBaseLevel(const gl::Context *context, GLuint baseLe
 
 angle::Result TextureMtl::bindTexImage(const gl::Context *context, egl::Surface *surface)
 {
-    UNIMPLEMENTED();
+    releaseTexture(true);
 
-    return angle::Result::Stop;
+    auto pBuffer     = GetImplAs<OffscreenSurfaceMtl>(surface);
+    mNativeTexture   = pBuffer->getColorTexture();
+    mFormat          = pBuffer->getColorFormat();
+    gl::Extents size = mNativeTexture->size();
+    mIsPow2          = gl::isPow2(size.width) && gl::isPow2(size.height) && gl::isPow2(size.depth);
+    ANGLE_TRY(ensureSamplerStateCreated(context));
+
+    ASSERT(mState.getType() == gl::TextureType::_2D);
+    mLayeredRenderTargets.resize(1);
+    mLayeredRenderTargets[0].set(mNativeTexture, 0, 0, mFormat);
+    mLayeredTextureViews.resize(1);
+    mLayeredTextureViews[0] = mNativeTexture;
+
+    // Tell context to rebind textures
+    ContextMtl *contextMtl = mtl::GetImpl(context);
+    contextMtl->invalidateCurrentTextures();
+
+    return angle::Result::Continue;
 }
 
 angle::Result TextureMtl::releaseTexImage(const gl::Context *context)
 {
-    UNIMPLEMENTED();
-
-    return angle::Result::Stop;
+    releaseTexture(true);
+    return angle::Result::Continue;
 }
 
 angle::Result TextureMtl::getAttachmentRenderTarget(const gl::Context *context,

src/libANGLE/renderer/metal/gen_mtl_format_table.py

@@ -160,7 +160,7 @@ def gen_image_map_switch_string(image_table):
     angle_override = image_table["override"]
     mac_override = image_table["override_mac"]
     ios_override = image_table["override_ios"]
-    mac_fallbacks = image_table["fallbacks_mac"]
+    mac_fallbacks = image_table["d24s8_fallbacks_mac"]
     angle_to_mtl = image_table["map"]
     mac_specific_map = image_table["map_mac"]
     ios_specific_map = image_table["map_ios"]

src/libANGLE/renderer/metal/mtl_format_map.json

@@ -18,7 +18,8 @@
             "B8G8R8A8_UNORM_SRGB": "MTLPixelFormatBGRA8Unorm_sRGB",
             "D32_FLOAT": "MTLPixelFormatDepth32Float",
             "S8_UINT": "MTLPixelFormatStencil8",
-            "D32_FLOAT_S8X24_UINT": "MTLPixelFormatDepth32Float_Stencil8"
+            "D32_FLOAT_S8X24_UINT": "MTLPixelFormatDepth32Float_Stencil8",
+            "B10G10R10A2_UNORM": "MTLPixelFormatBGR10A2Unorm"
         },
         "map_ios": {
             "R5G6B5_UNORM": "MTLPixelFormatB5G6R5Unorm",
@@ -85,14 +86,8 @@
             "R5G5B5A1_UNORM": "R8G8B8A8_UNORM",
             "R4G4B4A4_UNORM": "R8G8B8A8_UNORM"
         },
-        "fallbacks_mac": {
-            "B8G8R8A8_UNORM": "R8G8B8A8_UNORM",
-            "D24_UNORM_S8_UINT": "D32_FLOAT_S8X24_UINT",
-            "R8_UNORM": "NONE",
-            "R16_FLOAT": "NONE",
-            "R32_FLOAT": "NONE",
-            "R16G16B16A16_FLOAT": "NONE",
-            "R32G32B32A32_FLOAT": "NONE"
+        "d24s8_fallbacks_mac": {
+            "D24_UNORM_S8_UINT": "D32_FLOAT_S8X24_UINT"
         }
     },
     "vertex": {

src/libANGLE/renderer/metal/mtl_format_utils.mm

@@ -34,6 +34,7 @@ bool OverrideTextureCaps(const DisplayMtl *display, angle::FormatID formatId, gl
         case angle::FormatID::R8G8B8A8_UNORM_SRGB:
         case angle::FormatID::B8G8R8A8_UNORM:
         case angle::FormatID::B8G8R8A8_UNORM_SRGB:
+        case angle::FormatID::B10G10R10A2_UNORM:
         // NOTE: even though iOS devices don't support filtering depth textures, we still report as
         // supported here in order for the OES_depth_texture extension to be enabled.
         // During draw call, the filter modes will be converted to nearest.
@@ -214,6 +215,7 @@ bool Format::FormatRenderable(MTLPixelFormat format)
         case MTLPixelFormatDepth32Float:
         case MTLPixelFormatStencil8:
         case MTLPixelFormatDepth32Float_Stencil8:
+        case MTLPixelFormatBGR10A2Unorm:
 #if TARGET_OS_OSX || TARGET_OS_MACCATALYST
         case MTLPixelFormatDepth16Unorm:
         case MTLPixelFormatDepth24Unorm_Stencil8:

src/libANGLE/renderer/metal/mtl_utils.h

@@ -28,10 +28,17 @@ namespace mtl
 
 NS_ASSUME_NONNULL_BEGIN
 
+// Initialize texture content to (0, 0, 0, 1)
 angle::Result InitializeTextureContents(const gl::Context *context,
                                         const TextureRef &texture,
                                         const Format &textureObjFormat,
                                         const gl::ImageIndex &index);
+// Same as above but using GPU clear operation instead of CPU.
+// - channelsToInit parameter controls which channels will get their content initialized.
+angle::Result InitializeTextureContentsGPU(const gl::Context *context,
+                                           const TextureRef &texture,
+                                           const gl::ImageIndex &index,
+                                           MTLColorWriteMask channelsToInit);
 
 MTLViewport GetViewport(const gl::Rectangle &rect, double znear = 0, double zfar = 1);
 MTLViewport GetViewportFlipY(const gl::Rectangle &rect,

src/libANGLE/renderer/metal/mtl_utils.mm

@@ -14,6 +14,8 @@
 
 #include "common/MemoryBuffer.h"
 #include "libANGLE/renderer/metal/ContextMtl.h"
+#include "libANGLE/renderer/metal/DisplayMtl.h"
+#include "libANGLE/renderer/metal/mtl_render_utils.h"
 
 namespace rx
 {
@@ -77,6 +79,47 @@ angle::Result InitializeTextureContents(const gl::Context *context,
     return angle::Result::Continue;
 }
 
+angle::Result InitializeTextureContentsGPU(const gl::Context *context,
+                                           const TextureRef &texture,
+                                           const gl::ImageIndex &index,
+                                           MTLColorWriteMask channelsToInit)
+{
+    ContextMtl *contextMtl = mtl::GetImpl(context);
+    // Use clear render command
+
+    // temporarily enable color channels requested via channelsToInit. Some emulated format has some
+    // channels write mask disabled when the texture is created.
+    MTLColorWriteMask oldMask = texture->getColorWritableMask();
+    texture->setColorWritableMask(channelsToInit);
+
+    RenderCommandEncoder *encoder;
+    if (channelsToInit == MTLColorWriteMaskAll)
+    {
+        // If all channels will be initialized, use clear loadOp.
+        Optional<MTLClearColor> blackColor = MTLClearColorMake(0, 0, 0, 1);
+        encoder = contextMtl->getRenderCommandEncoder(texture, index, blackColor);
+    }
+    else
+    {
+        // If there are some channels don't need to be initialized, we must use clearWithDraw.
+        encoder = contextMtl->getRenderCommandEncoder(texture, index);
+
+        ClearRectParams clearParams;
+        clearParams.clearColor = {.alpha = 1};
+        clearParams.clearArea  = gl::Rectangle(0, 0, texture->width(), texture->height());
+
+        ANGLE_TRY(
+            contextMtl->getDisplay()->getUtils().clearWithDraw(context, encoder, clearParams));
+    }
+    ANGLE_UNUSED_VARIABLE(encoder);
+    contextMtl->endEncoding(true);
+
+    // Restore texture's intended write mask
+    texture->setColorWritableMask(oldMask);
+
+    return angle::Result::Continue;
+}
+
 MTLViewport GetViewport(const gl::Rectangle &rect, double znear, double zfar)
 {
     MTLViewport re;

src/tests/egl_tests/EGLIOSurfaceClientBufferTest.cpp

@@ -211,6 +211,10 @@ class IOSurfaceClientBufferTest : public ANGLETest
         EXPECT_EGL_TRUE(result);
         EXPECT_EGL_SUCCESS();
 
+        // IOSurface client buffer's rendering doesn't automatically finish after
+        // eglReleaseTexImage(). Need to explicitly call glFinish().
+        glFinish();
+
         IOSurfaceLock(ioSurface.get(), kIOSurfaceLockReadOnly, nullptr);
         std::array<T, dataSize> iosurfaceData;
         memcpy(iosurfaceData.data(), IOSurfaceGetBaseAddress(ioSurface.get()),
@@ -294,6 +298,11 @@ class IOSurfaceClientBufferTest : public ANGLETest
 
     void doBlitTest(bool ioSurfaceIsSource, int width, int height)
     {
+        if (!hasBlitExt())
+        {
+            return;
+        }
+
         // Create IOSurface and bind it to a texture.
         ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(width, height, 'BGRA', 4);
         EGLSurface pbuffer;
@@ -361,6 +370,10 @@ class IOSurfaceClientBufferTest : public ANGLETest
     }
 
     bool hasIOSurfaceExt() const { return IsEGLDisplayExtensionEnabled(mDisplay, kIOSurfaceExt); }
+    bool hasBlitExt() const
+    {
+        return IsEGLDisplayExtensionEnabled(mDisplay, "ANGLE_framebuffer_blit");
+    }
 
     EGLConfig mConfig;
     EGLDisplay mDisplay;
@@ -465,6 +478,9 @@ TEST_P(IOSurfaceClientBufferTest, RenderToR16IOSurface)
 {
     ANGLE_SKIP_TEST_IF(!hasIOSurfaceExt());
 
+    // This test only works on ES3 since it requires an integer texture.
+    ANGLE_SKIP_TEST_IF(getClientMajorVersion() < 3);
+
     // TODO(http://anglebug.com/4369)
     ANGLE_SKIP_TEST_IF(isSwiftshader());
 
@@ -990,4 +1006,5 @@ ANGLE_INSTANTIATE_TEST(IOSurfaceClientBufferTest,
                        ES2_OPENGL(),
                        ES3_OPENGL(),
                        ES2_VULKAN_SWIFTSHADER(),
-                       ES3_VULKAN_SWIFTSHADER());
+                       ES3_VULKAN_SWIFTSHADER(),
+                       ES2_METAL());