Emulate RGB textures using BGRX IOSurfaces.

extensions/EGL_ANGLE_iosurface_client_buffer.txt

@@ -21,7 +21,7 @@ Status
     Draft
 
 Version
-    Version 2, Apr 1, 2019
+    Version 3, Aug 13, 2019
 
 Number
 
@@ -96,6 +96,7 @@ Additions to Chapter 3 of the EGL 1.4 Specification (EGL Functions and Errors)
     GL_UNSIGNED_BYTE           GL_RED
     GL_UNSIGNED_SHORT          GL_R16UI
     GL_UNSIGNED_BYTE           GL_RG
+    GL_UNSIGNED_BYTE           GL_RGB
     GL_UNSIGNED_BYTE           GL_BGRA_EXT
     GL_HALF_FLOAT              GL_RGBA
     ---------------------------------------------------------------------------
@@ -110,9 +111,14 @@ Additions to Chapter 3 of the EGL 1.4 Specification (EGL Functions and Errors)
 
 Issues
 
-    There are no issues, please move on.
+    1. Can RGB formats be supported?
+
+    RESOLVED: Support for RGB internal formats is added in version 3. Surfaces
+    with an RGB format will ensure that the alpha channel of the IOSurface is
+    reset to 1.0 when it is used.
 
 Revision History
 
     Version 1, 2017/12/06 - first draft.
     Version 2, 2019/04/01 - Allow MakeCurrent.
+    Version 3, 2019/08/13 - Allow RGB internal formats

src/libANGLE/ImageIndex.cpp

@@ -128,6 +128,18 @@ TextureTarget ImageIndex::getTarget() const
     return TextureTypeToTarget(mType, mLayerIndex);
 }
 
+gl::TextureTarget ImageIndex::getTargetOrFirstCubeFace() const
+{
+    if (isEntireLevelCubeMap())
+    {
+        return gl::kCubeMapTextureTargetMin;
+    }
+    else
+    {
+        return getTarget();
+    }
+}
+
 GLint ImageIndex::cubeMapFaceIndex() const
 {
     ASSERT(mType == TextureType::CubeMap);

src/libANGLE/ImageIndex.h

@@ -40,6 +40,8 @@ class ImageIndex
     // map.
     TextureTarget getTarget() const;
 
+    TextureTarget getTargetOrFirstCubeFace() const;
+
     bool isLayered() const;
     bool isEntireLevelCubeMap() const;
 

src/libANGLE/renderer/gl/BlitGL.cpp

@@ -926,6 +926,30 @@ angle::Result BlitGL::clearFramebuffer(FramebufferGL *source)
     return angle::Result::Continue;
 }
 
+angle::Result BlitGL::clearRenderableTextureAlphaToOne(GLuint texture,
+                                                       gl::TextureTarget target,
+                                                       size_t level)
+{
+    // Clearing the alpha of 3D textures is not supported/needed yet.
+    ASSERT(nativegl::UseTexImage2D(TextureTargetToType(target)));
+
+    ANGLE_TRY(initializeResources());
+
+    mStateManager->setClearColor(gl::ColorF(0.0f, 0.0f, 0.0f, 1.0f));
+    mStateManager->setColorMask(false, false, false, true);
+    mStateManager->setScissorTestEnabled(false);
+
+    mStateManager->bindFramebuffer(GL_FRAMEBUFFER, mScratchFBO);
+    mFunctions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, ToGLenum(target),
+                                     texture, static_cast<GLint>(level));
+    mFunctions->clear(GL_COLOR_BUFFER_BIT);
+
+    // Unbind the texture from the the scratch framebuffer
+    mFunctions->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0);
+
+    return angle::Result::Continue;
+}
+
 angle::Result BlitGL::initializeResources()
 {
     for (size_t i = 0; i < ArraySize(mScratchTextures); i++)

src/libANGLE/renderer/gl/BlitGL.h

@@ -126,6 +126,10 @@ class BlitGL : angle::NonCopyable
 
     angle::Result clearFramebuffer(FramebufferGL *source);
 
+    angle::Result clearRenderableTextureAlphaToOne(GLuint texture,
+                                                   gl::TextureTarget target,
+                                                   size_t level);
+
     angle::Result initializeResources();
 
   private:

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -73,7 +73,7 @@ FramebufferImpl *ContextGL::createFramebuffer(const gl::FramebufferState &data)
     GLuint fbo = 0;
     funcs->genFramebuffers(1, &fbo);
 
-    return new FramebufferGL(data, fbo, false);
+    return new FramebufferGL(data, fbo, false, false);
 }
 
 TextureImpl *ContextGL::createTexture(const gl::TextureState &state)

src/libANGLE/renderer/gl/FramebufferGL.cpp

@@ -218,12 +218,28 @@ bool RequiresMultiviewClear(const FramebufferState &state, bool scissorTestEnabl
     return false;
 }
 
+bool IsEmulatedAlphaChannelTextureAttachment(const FramebufferAttachment *attachment)
+{
+    if (!attachment || attachment->type() != GL_TEXTURE)
+    {
+        return false;
+    }
+
+    const Texture *texture     = attachment->getTexture();
+    const TextureGL *textureGL = GetImplAs<TextureGL>(texture);
+    return textureGL->hasEmulatedAlphaChannel(attachment->getTextureImageIndex());
+}
+
 }  // namespace
 
-FramebufferGL::FramebufferGL(const gl::FramebufferState &data, GLuint id, bool isDefault)
+FramebufferGL::FramebufferGL(const gl::FramebufferState &data,
+                             GLuint id,
+                             bool isDefault,
+                             bool emulatedAlpha)
     : FramebufferImpl(data),
       mFramebufferID(id),
       mIsDefault(isDefault),
+      mHasEmulatedAlphaAttachment(emulatedAlpha),
       mAppliedEnabledDrawBuffers(1)
 {}
 
@@ -1104,6 +1120,16 @@ angle::Result FramebufferGL::syncState(const gl::Context *context,
                     {
                         attachment = newAttachment;
                     }
+
+                    // Hiding an alpha channel is only supported when it's the first attachment
+                    // currently. Assert that these emulated textures are not bound to a framebuffer
+                    // using MRT.
+                    if (index == 0)
+                    {
+                        mHasEmulatedAlphaAttachment =
+                            IsEmulatedAlphaChannelTextureAttachment(attachment);
+                    }
+                    ASSERT(index == 0 || !IsEmulatedAlphaChannelTextureAttachment(attachment));
                 }
                 break;
             }
@@ -1129,6 +1155,11 @@ bool FramebufferGL::isDefault() const
     return mIsDefault;
 }
 
+bool FramebufferGL::hasEmulatedAlphaChannelTextureAttachment() const
+{
+    return mHasEmulatedAlphaAttachment;
+}
+
 void FramebufferGL::syncClearState(const gl::Context *context, GLbitfield mask)
 {
     const FunctionsGL *functions = GetFunctionsGL(context);

src/libANGLE/renderer/gl/FramebufferGL.h

@@ -23,7 +23,7 @@ class StateManagerGL;
 class FramebufferGL : public FramebufferImpl
 {
   public:
-    FramebufferGL(const gl::FramebufferState &data, GLuint id, bool isDefault);
+    FramebufferGL(const gl::FramebufferState &data, GLuint id, bool isDefault, bool emulatedAlpha);
     ~FramebufferGL() override;
 
     void destroy(const gl::Context *context) override;
@@ -88,6 +88,8 @@ class FramebufferGL : public FramebufferImpl
     GLuint getFramebufferID() const;
     bool isDefault() const;
 
+    bool hasEmulatedAlphaChannelTextureAttachment() const;
+
   private:
     void syncClearState(const gl::Context *context, GLbitfield mask);
     void syncClearBufferState(const gl::Context *context, GLenum buffer, GLint drawBuffer);
@@ -130,6 +132,8 @@ class FramebufferGL : public FramebufferImpl
     GLuint mFramebufferID;
     bool mIsDefault;
 
+    bool mHasEmulatedAlphaAttachment;
+
     gl::DrawBufferMask mAppliedEnabledDrawBuffers;
 };
 }  // namespace rx

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -1489,15 +1489,6 @@ void StateManagerGL::syncState(const gl::Context *context,
 {
     const gl::State &state = context->getState();
 
-    // Changing the draw framebuffer binding sometimes requires resetting srgb blending.
-    if (glDirtyBits[gl::State::DIRTY_BIT_DRAW_FRAMEBUFFER_BINDING])
-    {
-        if (mFunctions->standard == STANDARD_GL_DESKTOP)
-        {
-            mLocalDirtyBits.set(gl::State::DIRTY_BIT_FRAMEBUFFER_SRGB);
-        }
-    }
-
     const gl::State::DirtyBits glAndLocalDirtyBits = (glDirtyBits | mLocalDirtyBits) & bitMask;
     if (!glAndLocalDirtyBits.any())
     {
@@ -1549,9 +1540,13 @@ void StateManagerGL::syncState(const gl::Context *context,
             }
             case gl::State::DIRTY_BIT_COLOR_MASK:
             {
+                gl::Framebuffer *framebuffer = state.getDrawFramebuffer();
+                FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer);
+
                 const auto &blendState = state.getBlendState();
-                setColorMask(blendState.colorMaskRed, blendState.colorMaskGreen,
-                             blendState.colorMaskBlue, blendState.colorMaskAlpha);
+                setColorMaskForFramebuffer(blendState.colorMaskRed, blendState.colorMaskGreen,
+                                           blendState.colorMaskBlue, blendState.colorMaskAlpha,
+                                           framebufferGL);
                 break;
             }
             case gl::State::DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED:
@@ -1697,6 +1692,16 @@ void StateManagerGL::syncState(const gl::Context *context,
                 {
                     updateMultiviewBaseViewLayerIndexUniform(program, framebufferGL->getState());
                 }
+
+                // Changing the draw framebuffer binding sometimes requires resetting srgb blending.
+                if (mFunctions->standard == STANDARD_GL_DESKTOP)
+                {
+                    iter.setLaterBit(gl::State::DIRTY_BIT_FRAMEBUFFER_SRGB);
+                }
+
+                // If the framebuffer is emulating RGB on top of RGBA, the color mask has to be
+                // updated
+                iter.setLaterBit(gl::State::DIRTY_BIT_COLOR_MASK);
                 break;
             }
             case gl::State::DIRTY_BIT_RENDERBUFFER_BINDING:
@@ -1888,6 +1893,20 @@ void StateManagerGL::setFramebufferSRGBEnabledForFramebuffer(const gl::Context *
     }
 }
 
+void StateManagerGL::setColorMaskForFramebuffer(bool red,
+                                                bool green,
+                                                bool blue,
+                                                bool alpha,
+                                                const FramebufferGL *framebuffer)
+{
+    bool modifiedAlphaMask = alpha;
+    if (framebuffer->hasEmulatedAlphaChannelTextureAttachment())
+    {
+        modifiedAlphaMask = false;
+    }
+    setColorMask(red, green, blue, modifiedAlphaMask);
+}
+
 void StateManagerGL::setDitherEnabled(bool enabled)
 {
     if (mDitherEnabled != enabled)

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -136,6 +136,11 @@ class StateManagerGL final : angle::NonCopyable
     void setFramebufferSRGBEnabledForFramebuffer(const gl::Context *context,
                                                  bool enabled,
                                                  const FramebufferGL *framebuffer);
+    void setColorMaskForFramebuffer(bool red,
+                                    bool green,
+                                    bool blue,
+                                    bool alpha,
+                                    const FramebufferGL *framebuffer);
 
     void setDitherEnabled(bool enabled);
 

src/libANGLE/renderer/gl/SurfaceGL.cpp

@@ -25,7 +25,7 @@ SurfaceGL::~SurfaceGL() {}
 FramebufferImpl *SurfaceGL::createDefaultFramebuffer(const gl::Context *context,
                                                      const gl::FramebufferState &data)
 {
-    return new FramebufferGL(data, 0, true);
+    return new FramebufferGL(data, 0, true, false);
 }
 
 egl::Error SurfaceGL::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc)
@@ -46,4 +46,9 @@ angle::Result SurfaceGL::initializeContents(const gl::Context *context,
     return angle::Result::Continue;
 }
 
+bool SurfaceGL::hasEmulatedAlphaChannel() const
+{
+    return false;
+}
+
 }  // namespace rx

src/libANGLE/renderer/gl/SurfaceGL.h

@@ -26,6 +26,8 @@ class SurfaceGL : public SurfaceImpl
 
     angle::Result initializeContents(const gl::Context *context,
                                      const gl::ImageIndex &imageIndex) override;
+
+    virtual bool hasEmulatedAlphaChannel() const;
 };
 
 }  // namespace rx

src/libANGLE/renderer/gl/TextureGL.h

@@ -47,11 +47,16 @@ struct LevelInfoGL
     // Information about luminance alpha texture workarounds in the core profile.
     LUMAWorkaroundGL lumaWorkaround;
 
+    // If this texture level hides the fact that it has an alpha channel by setting the sampler
+    // parameters to always sample 1.0.
+    bool emulatedAlphaChannel;
+
     LevelInfoGL();
     LevelInfoGL(GLenum sourceFormat,
                 GLenum nativeInternalFormat,
                 bool depthStencilWorkaround,
-                const LUMAWorkaroundGL &lumaWorkaround);
+                const LUMAWorkaroundGL &lumaWorkaround,
+                bool emulatedAlphaChannel);
 };
 
 class TextureGL : public TextureImpl
@@ -199,6 +204,7 @@ class TextureGL : public TextureImpl
     void setSwizzle(const gl::Context *context, GLint swizzle[4]);
 
     GLenum getNativeInternalFormat(const gl::ImageIndex &index) const;
+    bool hasEmulatedAlphaChannel(const gl::ImageIndex &index) const;
 
   private:
     void setImageHelper(const gl::Context *context,

src/libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h

@@ -64,13 +64,19 @@ class IOSurfaceSurfaceCGL : public SurfaceGL
     FramebufferImpl *createDefaultFramebuffer(const gl::Context *context,
                                               const gl::FramebufferState &state) override;
 
+    bool hasEmulatedAlphaChannel() const override;
+
   private:
+    angle::Result initializeAlphaChannel(const gl::Context *context, GLuint texture);
+
     CGLContextObj mCGLContext;
     IOSurfaceRef mIOSurface;
     int mWidth;
     int mHeight;
     int mPlane;
     int mFormatIndex;
+
+    bool mAlphaInitialized;
 };
 
 }  // namespace rx

src/libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.mm

@@ -9,11 +9,13 @@
 
 #include "libANGLE/renderer/gl/cgl/IOSurfaceSurfaceCGL.h"
 
+#import <Cocoa/Cocoa.h>
 #include <IOSurface/IOSurface.h>
 #include <OpenGL/CGLIOSurface.h>
 
 #include "common/debug.h"
 #include "libANGLE/AttributeMap.h"
+#include "libANGLE/renderer/gl/BlitGL.h"
 #include "libANGLE/renderer/gl/FramebufferGL.h"
 #include "libANGLE/renderer/gl/FunctionsGL.h"
 #include "libANGLE/renderer/gl/RendererGL.h"
@@ -44,6 +46,7 @@ static const IOSurfaceFormatInfo kIOSurfaceFormats[] = {
     {GL_RED,      GL_UNSIGNED_BYTE,  1, GL_RED,  GL_RED,  GL_UNSIGNED_BYTE           },
     {GL_R16UI,    GL_UNSIGNED_SHORT, 2, GL_RED,  GL_RED,  GL_UNSIGNED_SHORT          },
     {GL_RG,       GL_UNSIGNED_BYTE,  2, GL_RG,   GL_RG,   GL_UNSIGNED_BYTE           },
+    {GL_RGB,      GL_UNSIGNED_BYTE,  4, GL_BGRA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
     {GL_BGRA_EXT, GL_UNSIGNED_BYTE,  4, GL_BGRA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV},
     {GL_RGBA,     GL_HALF_FLOAT,     8, GL_RGBA, GL_RGBA, GL_HALF_FLOAT              },
 };
@@ -74,7 +77,8 @@ IOSurfaceSurfaceCGL::IOSurfaceSurfaceCGL(const egl::SurfaceState &state,
       mWidth(0),
       mHeight(0),
       mPlane(0),
-      mFormatIndex(-1)
+      mFormatIndex(-1),
+      mAlphaInitialized(false)
 {
     // Keep reference to the IOSurface so it doesn't get deleted while the pbuffer exists.
     mIOSurface = reinterpret_cast<IOSurfaceRef>(buffer);
@@ -89,6 +93,8 @@ IOSurfaceSurfaceCGL::IOSurfaceSurfaceCGL(const egl::SurfaceState &state,
     EGLAttrib type           = attribs.get(EGL_TEXTURE_TYPE_ANGLE);
     mFormatIndex             = FindIOSurfaceFormatIndex(internalFormat, type);
     ASSERT(mFormatIndex >= 0);
+
+    mAlphaInitialized = !hasEmulatedAlphaChannel();
 }
 
 IOSurfaceSurfaceCGL::~IOSurfaceSurfaceCGL()
@@ -148,13 +154,18 @@ egl::Error IOSurfaceSurfaceCGL::bindTexImage(const gl::Context *context,
     stateManager->bindTexture(gl::TextureType::Rectangle, textureID);
 
     const auto &format = kIOSurfaceFormats[mFormatIndex];
-    auto error = CGLTexImageIOSurface2D(mCGLContext, GL_TEXTURE_RECTANGLE, format.nativeFormat,
-                                        mWidth, mHeight, format.nativeInternalFormat,
-                                        format.nativeType, mIOSurface, mPlane);
+    CGLError error = CGLTexImageIOSurface2D(mCGLContext, GL_TEXTURE_RECTANGLE, format.nativeFormat,
+                                            mWidth, mHeight, format.nativeInternalFormat,
+                                            format.nativeType, mIOSurface, mPlane);
 
     if (error != kCGLNoError)
     {
-        return egl::EglContextLost();
+        return egl::EglContextLost() << "CGLTexImageIOSurface2D failed: " << CGLErrorString(error);
+    }
+
+    if (IsError(initializeAlphaChannel(context, textureID)))
+    {
+        return egl::EglContextLost() << "Failed to initialize IOSurface alpha channel.";
     }
 
     return egl::NoError();
@@ -247,8 +258,9 @@ class IOSurfaceFramebuffer : public FramebufferGL
     IOSurfaceFramebuffer(const gl::FramebufferState &data,
                          GLuint id,
                          GLuint textureId,
-                         bool isDefault)
-        : FramebufferGL(data, id, isDefault), mTextureId(textureId)
+                         bool isDefault,
+                         bool emulatedAlpha)
+        : FramebufferGL(data, id, isDefault, emulatedAlpha), mTextureId(textureId)
     {}
     void destroy(const gl::Context *context) override
     {
@@ -273,8 +285,17 @@ FramebufferImpl *IOSurfaceSurfaceCGL::createDefaultFramebuffer(const gl::Context
     CGLError error = CGLTexImageIOSurface2D(mCGLContext, GL_TEXTURE_RECTANGLE, format.nativeFormat,
                                             mWidth, mHeight, format.nativeInternalFormat,
                                             format.nativeType, mIOSurface, mPlane);
+    if (error != kCGLNoError)
+    {
+        ERR() << "CGLTexImageIOSurface2D failed: " << CGLErrorString(error);
+    }
     ASSERT(error == kCGLNoError);
 
+    if (IsError(initializeAlphaChannel(context, texture)))
+    {
+        ERR() << "Failed to initialize IOSurface alpha channel.";
+    }
+
     GLuint framebuffer = 0;
     functions->genFramebuffers(1, &framebuffer);
     stateManager->bindFramebuffer(GL_FRAMEBUFFER, framebuffer);
@@ -282,7 +303,27 @@ FramebufferImpl *IOSurfaceSurfaceCGL::createDefaultFramebuffer(const gl::Context
     functions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE,
                                     texture, 0);
 
-    return new IOSurfaceFramebuffer(state, framebuffer, texture, true);
+    return new IOSurfaceFramebuffer(state, framebuffer, texture, true, hasEmulatedAlphaChannel());
+}
+
+angle::Result IOSurfaceSurfaceCGL::initializeAlphaChannel(const gl::Context *context,
+                                                          GLuint texture)
+{
+    if (mAlphaInitialized)
+    {
+        return angle::Result::Continue;
+    }
+
+    BlitGL *blitter = GetBlitGL(context);
+    ANGLE_TRY(blitter->clearRenderableTextureAlphaToOne(texture, gl::TextureTarget::Rectangle, 0));
+    mAlphaInitialized = true;
+    return angle::Result::Continue;
+}
+
+bool IOSurfaceSurfaceCGL::hasEmulatedAlphaChannel() const
+{
+    const auto &format = kIOSurfaceFormats[mFormatIndex];
+    return format.internalFormat == GL_RGB;
 }
 
 }  // namespace rx

src/libANGLE/renderer/gl/cgl/PbufferSurfaceCGL.mm

@@ -137,7 +137,7 @@ FramebufferImpl *PbufferSurfaceCGL::createDefaultFramebuffer(const gl::Context *
     functions->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                                        mDSRenderbuffer);
 
-    return new FramebufferGL(state, framebuffer, true);
+    return new FramebufferGL(state, framebuffer, true, false);
 }
 
 }  // namespace rx

src/libANGLE/renderer/gl/cgl/WindowSurfaceCGL.mm

@@ -331,7 +331,7 @@ FramebufferImpl *WindowSurfaceCGL::createDefaultFramebuffer(const gl::Context *c
     functions->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER,
                                        mDSRenderbuffer);
 
-    return new FramebufferGL(state, framebuffer, true);
+    return new FramebufferGL(state, framebuffer, true, false);
 }
 
 }  // namespace rx

src/libANGLE/renderer/gl/egl/ozone/DisplayOzone.cpp

@@ -317,7 +317,7 @@ GLuint DisplayOzone::Buffer::createGLFB(const gl::Context *context)
 FramebufferGL *DisplayOzone::Buffer::framebufferGL(const gl::Context *context,
                                                    const gl::FramebufferState &state)
 {
-    return new FramebufferGL(state, createGLFB(context), true);
+    return new FramebufferGL(state, createGLFB(context), true, false);
 }
 
 void DisplayOzone::Buffer::present(const gl::Context *context)

src/libANGLE/renderer/gl/wgl/D3DTextureSurfaceWGL.cpp

@@ -498,7 +498,7 @@ FramebufferImpl *D3DTextureSurfaceWGL::createDefaultFramebuffer(const gl::Contex
                                            mDepthStencilRenderbufferID);
     }
 
-    return new FramebufferGL(data, framebufferID, true);
+    return new FramebufferGL(data, framebufferID, true, false);
 }
 
 HDC D3DTextureSurfaceWGL::getDC() const

src/libANGLE/renderer/gl/wgl/DXGISwapChainWindowSurfaceWGL.cpp

@@ -296,7 +296,7 @@ FramebufferImpl *DXGISwapChainWindowSurfaceWGL::createDefaultFramebuffer(
         }
     }
 
-    return new FramebufferGL(data, framebufferID, true);
+    return new FramebufferGL(data, framebufferID, true, false);
 }
 
 HDC DXGISwapChainWindowSurfaceWGL::getDC() const

src/tests/egl_tests/EGLIOSurfaceClientBufferTest.cpp

@@ -331,6 +331,24 @@ TEST_P(IOSurfaceClientBufferTest, ReadFromBGRA8888IOSurface)
     doSampleTest(ioSurface, GL_BGRA_EXT, GL_UNSIGNED_BYTE, &color, sizeof(color), R | G | B | A);
 }
 
+// Test using BGRX8888 IOSurfaces for rendering
+TEST_P(IOSurfaceClientBufferTest, RenderToBGRX8888IOSurface)
+{
+    ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(1, 1, 'BGRA', 4);
+
+    GLColor color(3, 2, 1, 255);
+    doClearTest(ioSurface, GL_RGB, GL_UNSIGNED_BYTE, &color, sizeof(color));
+}
+
+// Test reading from BGRX8888 IOSurfaces
+TEST_P(IOSurfaceClientBufferTest, ReadFromBGRX8888IOSurface)
+{
+    ScopedIOSurfaceRef ioSurface = CreateSinglePlaneIOSurface(1, 1, 'BGRA', 4);
+
+    GLColor color(3, 2, 1, 4);
+    doSampleTest(ioSurface, GL_RGB, GL_UNSIGNED_BYTE, &color, sizeof(color), R | G | B);
+}
+
 // Test using RG88 IOSurfaces for rendering
 TEST_P(IOSurfaceClientBufferTest, RenderToRG88IOSurface)
 {