diff --git a/extensions/EGL_ANGLE_iosurface_client_buffer.txt b/extensions/EGL_ANGLE_iosurface_client_buffer.txt
new file mode 100644
index 0000000..692f721
--- /dev/null
+++ b/extensions/EGL_ANGLE_iosurface_client_buffer.txt
@@ -0,0 +1,122 @@
+Name
+
+    ANGLE_iosurface_client_buffer
+
+Name Strings
+
+    EGL_ANGLE_iosurface_client_buffer
+
+Contributors
+
+    Corentin Wallez
+    Geoff Lang
+
+Contacts
+
+    Corentin Wallez, Google Inc. (cwallez 'at' google.com)
+
+Status
+
+    Draft
+
+Version
+
+    Version 1, Dec 6, 2017
+
+Number
+
+    EGL Extension #??
+
+Dependencies
+
+    This extension is written against the wording of the EGL 1.4
+    Specification.
+
+Overview
+
+    This extension allows creating EGL surfaces from IOSurface objects.
+
+New Types
+
+    None
+
+New Procedures and Functions
+
+    None
+
+New Tokens
+
+    Accepted in the <buftype> parameter of eglCreatePbufferFromClientBuffer:
+
+        EGL_IOSURFACE_ANGLE            0x3454
+        EGL_IOSURFACE_PLANE_ANGLE      0x345A
+        EGL_TEXTURE_RECTANGLE_ANGLE    0x345B
+        EGL_TEXTURE_TYPE_ANGLE         0x345C
+        EGL_TEXTURE_INTERNAL_FORMAT_ANGLE 0x345D
+
+Additions to Chapter 3 of the EGL 1.4 Specification (EGL Functions and Errors)
+
+    Replace the last sentence of paragraph 1 of Section 3.5.3 with the
+    following text.
+    "Currently, the only client API resources which may be bound in this
+    fashion are OpenVG VGImage objects and IOSurface objects."
+
+    Replace the third paragraph of Section 3.5.3 with the following text.
+    "<buftype> specifies the type of buffer to be bound. The only allowed values
+    of <buftype> are EGL_OPENVG_IMAGE and EGL_IOSURFACE_ANGLE".
+
+    Append the following text to the fourth paragraph of Section 3.5.3.
+    "When <buftype> is EGL_IOSURFACE_ANGLE, <buffer> must be a valid IOSurface
+    object case into the type EGLClientBuffer."
+
+    Append to the end of Section 3.5.3.
+    "When <buftype> is EGL_IOSURFACE_ANGLE, <attrib_list> must contain all the
+    following attributes otherwise EGL_BAD_PARAMETER is generated. The
+    attributes must satisfy the following constraints otherwise
+    EGL_BAD_ATTRIBUTE is generated:
+      - EGL_TEXTURE_TYPE_ANGLE, and EGL_TEXTURE_INTERNAL_FORMAT_ANGLE followed
+    by OpenGL enums for texture types, and texture internal format
+    respectively.
+      - EGL_TEXTURE_FORMAT with a value of EGL_TEXTURE_RGBA
+      - EGL_WIDTH with a value between 1 and the width of <buffer>.
+      - EGL_HEIGHT with a value between 1 and the height of <buffer>.
+      - EGL_TEXTURE_TARGET with a value of EGL_TEXTURE_RECTANGLE_ANGLE
+      - EGL_IOSURFACE_PLANE_ANGLE with a value between 0 and the number of
+    planes of <buffer> (exclusive).
+
+    In addition the EGL_TEXTURE_TYPE_ANGLE and
+    EGL_TEXTURE_INTERNAL_FORMAT_ANGLE attributes must be one of the
+    combinations listed in table egl.iosurface.formats or an
+    EGL_BAD_PARAMETER is generated. The combination must also be a valid
+    combinations for glTexImage2D or EGL_BAD_PARAMETER is generated."
+
+    ---------------------------------------------------------------------------
+    Texture Type               Texture Internal Format
+    ---------------------------------------------------------------------------
+    GL_UNSIGNED_BYTE           GL_RED
+    GL_UNSIGNED_SHORT          GL_R16UI
+    GL_UNSIGNED_BYTE           GL_RG
+    GL_UNSIGNED_BYTE           GL_BGRA_EXT
+    GL_HALF_FLOAT              GL_RGBA
+    ---------------------------------------------------------------------------
+    Table egl.iosurface.formats - Valid combinations of format, type and
+    internal format for IOSurface-backed pbuffers.
+    ---------------------------------------------------------------------------
+
+    Append to the end of Section 3.5.3.
+    "When a pbuffer is created with type EGL_IOSURFACE_ANGLE, the contents
+    of the associcated IOSurface object are undefined while the pbuffer is
+    bound to a client texture."
+
+    Append to the list of errors generated by eglMakeCurrent in Section 3.7.3:
+    "  - If either draw or read are pbuffers created with
+    eglCreatePbufferFromClientBuffer with <buftype> set to EGL_IOSURFACE_ANGLE,
+    an EGL_BAD_SURFACE is generated."
+
+Issues
+
+    There are no issues, please move on.
+
+Revision History
+
+    Version 1, 2017/12/06 - first draft.
diff --git a/src/OpenGL/common/Image.cpp b/src/OpenGL/common/Image.cpp
index 8da7cd3..9c2645d 100644
--- a/src/OpenGL/common/Image.cpp
+++ b/src/OpenGL/common/Image.cpp
@@ -24,6 +24,11 @@
 #include <string.h>
 #include <algorithm>
 
+#if defined(__APPLE__)
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOSurface/IOSurface.h>
+#endif
+
 namespace gl
 {
 	sw::Format ConvertReadFormatType(GLenum format, GLenum type)
@@ -1205,6 +1210,195 @@
 		return new ImageImplementation(width, height, internalformat, multiSampleDepth, lockable);
 	}
 
+	int ClientBuffer::getWidth() const
+	{
+		return width;
+	}
+
+	int ClientBuffer::getHeight() const
+	{
+		return height;
+	}
+
+	sw::Format ClientBuffer::getFormat() const
+	{
+		return format;
+	}
+
+	int ClientBuffer::pitchP() const
+	{
+#if defined(__APPLE__)
+		if(buffer)
+		{
+			IOSurfaceRef ioSurface = reinterpret_cast<IOSurfaceRef>(buffer);
+			int pitchB = static_cast<int>(IOSurfaceGetBytesPerRowOfPlane(ioSurface, plane));
+			int bytesPerPixel = sw::Surface::bytes(format);
+			ASSERT((pitchB % bytesPerPixel) == 0);
+			return pitchB / bytesPerPixel;
+		}
+
+		return 0;
+#else
+		return sw::Surface::pitchP(width, 0, format, false);
+#endif
+	}
+
+	void ClientBuffer::retain()
+	{
+#if defined(__APPLE__)
+		if(buffer)
+		{
+			CFRetain(reinterpret_cast<IOSurfaceRef>(buffer));
+		}
+#endif
+	}
+
+	void ClientBuffer::release()
+	{
+#if defined(__APPLE__)
+		if(buffer)
+		{
+			CFRelease(reinterpret_cast<IOSurfaceRef>(buffer));
+			buffer = nullptr;
+		}
+#endif
+	}
+
+	void* ClientBuffer::lock(int x, int y, int z)
+	{
+#if defined(__APPLE__)
+		if(buffer)
+		{
+			IOSurfaceRef ioSurface = reinterpret_cast<IOSurfaceRef>(buffer);
+			IOSurfaceLock(ioSurface, 0, nullptr);
+			void* pixels = IOSurfaceGetBaseAddressOfPlane(ioSurface, plane);
+			int bytes = sw::Surface::bytes(format);
+			int pitchB = static_cast<int>(IOSurfaceGetBytesPerRowOfPlane(ioSurface, plane));
+			int sliceB = static_cast<int>(IOSurfaceGetHeightOfPlane(ioSurface, plane)) * pitchB;
+			return (unsigned char*)pixels + x * bytes + y * pitchB + z * sliceB;
+		}
+
+		return nullptr;
+#else
+		int bytes = sw::Surface::bytes(format);
+		int pitchB = sw::Surface::pitchB(width, 0, format, false);
+		int sliceB = height * pitchB;
+		return (unsigned char*)buffer + x * bytes + y * pitchB + z * sliceB;
+#endif
+	}
+
+	void ClientBuffer::unlock()
+	{
+#if defined(__APPLE__)
+		if(buffer)
+		{
+			IOSurfaceRef ioSurface = reinterpret_cast<IOSurfaceRef>(buffer);
+			IOSurfaceUnlock(ioSurface, 0, nullptr);
+		}
+#endif
+	}
+
+	class ClientBufferImage : public egl::Image
+	{
+	public:
+		explicit ClientBufferImage(const ClientBuffer& clientBuffer) :
+			egl::Image(clientBuffer.getWidth(),
+				clientBuffer.getHeight(),
+				getClientBufferInternalFormat(clientBuffer.getFormat()),
+				clientBuffer.pitchP()),
+			clientBuffer(clientBuffer)
+		{
+			shared = false;
+			this->clientBuffer.retain();
+		}
+
+	private:
+		ClientBuffer clientBuffer;
+
+		~ClientBufferImage() override
+		{
+			sync();   // Wait for any threads that use this image to finish.
+
+			clientBuffer.release();
+		}
+
+		static GLint getClientBufferInternalFormat(sw::Format format)
+		{
+			switch(format)
+			{
+			case sw::FORMAT_R8:            return GL_R8;
+			case sw::FORMAT_G8R8:          return GL_RG8;
+			case sw::FORMAT_A8R8G8B8:      return GL_BGRA8_EXT;
+			case sw::FORMAT_R16UI:         return GL_R16UI;
+			case sw::FORMAT_A16B16G16R16F: return GL_RGBA16F;
+			default:                       return GL_NONE;
+			}
+		}
+
+		void *lockInternal(int x, int y, int z, sw::Lock lock, sw::Accessor client) override
+		{
+			LOGLOCK("image=%p op=%s.swsurface lock=%d", this, __FUNCTION__, lock);
+
+			// Always do this for reference counting.
+			void *data = sw::Surface::lockInternal(x, y, z, lock, client);
+
+			if(x != 0 || y != 0 || z != 0)
+			{
+				LOGLOCK("badness: %s called with unsupported parms: image=%p x=%d y=%d z=%d", __FUNCTION__, this, x, y, z);
+			}
+
+			LOGLOCK("image=%p op=%s.ani lock=%d", this, __FUNCTION__, lock);
+
+			// Lock the ClientBuffer and use its address.
+			data = clientBuffer.lock(x, y, z);
+
+			if(lock == sw::LOCK_UNLOCKED)
+			{
+				// We're never going to get a corresponding unlock, so unlock
+				// immediately. This keeps the reference counts sane.
+				clientBuffer.unlock();
+			}
+
+			return data;
+		}
+
+		void unlockInternal() override
+		{
+			LOGLOCK("image=%p op=%s.ani", this, __FUNCTION__);
+			clientBuffer.unlock();
+
+			LOGLOCK("image=%p op=%s.swsurface", this, __FUNCTION__);
+			sw::Surface::unlockInternal();
+		}
+
+		void *lock(int x, int y, int z, sw::Lock lock) override
+		{
+			LOGLOCK("image=%p op=%s lock=%d", this, __FUNCTION__, lock);
+			(void)sw::Surface::lockExternal(x, y, z, lock, sw::PUBLIC);
+
+			return clientBuffer.lock(x, y, z);
+		}
+
+		void unlock() override
+		{
+			LOGLOCK("image=%p op=%s.ani", this, __FUNCTION__);
+			clientBuffer.unlock();
+
+			LOGLOCK("image=%p op=%s.swsurface", this, __FUNCTION__);
+			sw::Surface::unlockExternal();
+		}
+
+		void release() override
+		{
+			Image::release();
+		}
+	};
+
+	Image *Image::create(const egl::ClientBuffer& clientBuffer)
+	{
+		return new ClientBufferImage(clientBuffer);
+	}
+
 	Image::~Image()
 	{
 		// sync() must be called in the destructor of the most derived class to ensure their vtable isn't destroyed
diff --git a/src/OpenGL/common/Image.hpp b/src/OpenGL/common/Image.hpp
index 3b984b9..5e924c0 100644
--- a/src/OpenGL/common/Image.hpp
+++ b/src/OpenGL/common/Image.hpp
@@ -63,6 +63,30 @@
 namespace egl
 {
 
+class ClientBuffer
+{
+public:
+	ClientBuffer(int width, int height, sw::Format format, void* buffer, size_t plane)
+		: width(width), height(height), format(format), buffer(buffer), plane(plane)
+	{}
+
+	int getWidth() const;
+	int getHeight() const;
+	sw::Format getFormat() const;
+	int pitchP() const;
+	void retain();
+	void release();
+	void* lock(int x, int y, int z);
+	void unlock();
+
+private:
+	int width;
+	int height;
+	sw::Format format;
+	void* buffer;
+	size_t plane;
+};
+
 class [[clang::lto_visibility_public]] Image : public sw::Surface, public gl::Object
 {
 protected:
@@ -117,6 +141,9 @@
 	// Render target
 	static Image *create(GLsizei width, GLsizei height, GLint internalformat, int multiSampleDepth, bool lockable);
 
+	// Back buffer from client buffer
+	static Image *create(const egl::ClientBuffer& clientBuffer);
+
 	GLsizei getWidth() const
 	{
 		return width;
diff --git a/src/OpenGL/common/Surface.hpp b/src/OpenGL/common/Surface.hpp
index 493d676..c9e1973 100644
--- a/src/OpenGL/common/Surface.hpp
+++ b/src/OpenGL/common/Surface.hpp
@@ -42,6 +42,7 @@
 
 	virtual EGLint getWidth() const = 0;
 	virtual EGLint getHeight() const = 0;
+	virtual EGLenum getTextureTarget() const = 0;
 
 	virtual void setBoundTexture(egl::Texture *texture) = 0;
 };
diff --git a/src/OpenGL/libEGL/BUILD.gn b/src/OpenGL/libEGL/BUILD.gn
index 24727cf..c9ea43b 100644
--- a/src/OpenGL/libEGL/BUILD.gn
+++ b/src/OpenGL/libEGL/BUILD.gn
@@ -67,6 +67,8 @@
     libs = [
       "Quartz.framework",
       "Cocoa.framework",
+      "CoreFoundation.framework",
+      "IOSurface.framework",
     ]
     ldflags = [ "-Wl,-install_name,@rpath/libswiftshader_libEGL.dylib" ]
   } else if (is_win) {
diff --git a/src/OpenGL/libEGL/Display.cpp b/src/OpenGL/libEGL/Display.cpp
index 0e58125..a5c87b9 100644
--- a/src/OpenGL/libEGL/Display.cpp
+++ b/src/OpenGL/libEGL/Display.cpp
@@ -34,6 +34,8 @@
 #include "Main/libX11.hpp"
 #elif defined(__APPLE__)
 #include "OSXUtils.hpp"
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOSurface/IOSurface.h>
 #endif
 
 #include <algorithm>
@@ -338,11 +340,13 @@
 	return success(surface);
 }
 
-EGLSurface Display::createPBufferSurface(EGLConfig config, const EGLint *attribList)
+EGLSurface Display::createPBufferSurface(EGLConfig config, const EGLint *attribList, EGLClientBuffer clientBuffer)
 {
-	EGLint width = 0, height = 0;
+	EGLint width = -1, height = -1, ioSurfacePlane = -1;
 	EGLenum textureFormat = EGL_NO_TEXTURE;
 	EGLenum textureTarget = EGL_NO_TEXTURE;
+	EGLenum clientBufferFormat = EGL_NO_TEXTURE;
+	EGLenum clientBufferType = EGL_NO_TEXTURE;
 	EGLBoolean largestPBuffer = EGL_FALSE;
 	const Config *configuration = mConfigSet.get(config);
 
@@ -373,11 +377,45 @@
 					return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
 				}
 				break;
+			case EGL_TEXTURE_INTERNAL_FORMAT_ANGLE:
+				switch(attribList[1])
+				{
+				case GL_RED:
+				case GL_R16UI:
+				case GL_RG:
+				case GL_BGRA_EXT:
+				case GL_RGBA:
+					clientBufferFormat = attribList[1];
+					break;
+				default:
+					return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+				}
+				break;
+			case EGL_TEXTURE_TYPE_ANGLE:
+				switch(attribList[1])
+				{
+				case GL_UNSIGNED_BYTE:
+				case GL_UNSIGNED_SHORT:
+				case GL_HALF_FLOAT:
+					clientBufferType = attribList[1];
+					break;
+				default:
+					return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+				}
+				break;
+			case EGL_IOSURFACE_PLANE_ANGLE:
+				if(attribList[1] < 0)
+				{
+					return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+				}
+				ioSurfacePlane = attribList[1];
+				break;
 			case EGL_TEXTURE_TARGET:
 				switch(attribList[1])
 				{
 				case EGL_NO_TEXTURE:
 				case EGL_TEXTURE_2D:
+				case EGL_TEXTURE_RECTANGLE_ANGLE:
 					textureTarget = attribList[1];
 					break;
 				default:
@@ -423,13 +461,92 @@
 		return error(EGL_BAD_MATCH, EGL_NO_SURFACE);
 	}
 
-	if((textureFormat == EGL_TEXTURE_RGB && configuration->mBindToTextureRGB != EGL_TRUE) ||
-	   (textureFormat == EGL_TEXTURE_RGBA && configuration->mBindToTextureRGBA != EGL_TRUE))
+	if(clientBuffer)
 	{
-		return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+		switch(clientBufferType)
+		{
+		case GL_UNSIGNED_BYTE:
+			switch(clientBufferFormat)
+			{
+			case GL_RED:
+			case GL_RG:
+			case GL_BGRA_EXT:
+				break;
+			case GL_R16UI:
+			case GL_RGBA:
+				return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+			default:
+				return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+			}
+			break;
+		case GL_UNSIGNED_SHORT:
+			switch(clientBufferFormat)
+			{
+			case GL_R16UI:
+				break;
+			case GL_RED:
+			case GL_RG:
+			case GL_BGRA_EXT:
+			case GL_RGBA:
+				return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+			default:
+				return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+			}
+			break;
+		case GL_HALF_FLOAT:
+			switch(clientBufferFormat)
+			{
+			case GL_RGBA:
+				break;
+			case GL_RED:
+			case GL_R16UI:
+			case GL_RG:
+			case GL_BGRA_EXT:
+				return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+			default:
+				return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+			}
+			break;
+		default:
+			return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+		}
+
+		if(ioSurfacePlane < 0)
+		{
+			return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+		}
+
+		if(textureFormat != EGL_TEXTURE_RGBA)
+		{
+			return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+		}
+
+		if(textureTarget != EGL_TEXTURE_RECTANGLE_ANGLE)
+		{
+			return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+		}
+
+#if defined(__APPLE__)
+		IOSurfaceRef ioSurface = reinterpret_cast<IOSurfaceRef>(clientBuffer);
+		size_t planeCount = IOSurfaceGetPlaneCount(ioSurface);
+		if((static_cast<size_t>(width) > IOSurfaceGetWidthOfPlane(ioSurface, ioSurfacePlane)) ||
+		   (static_cast<size_t>(height) > IOSurfaceGetHeightOfPlane(ioSurface, ioSurfacePlane)) ||
+		   ((planeCount != 0) && static_cast<size_t>(ioSurfacePlane) >= planeCount))
+		{
+			return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+		}
+#endif
+	}
+	else
+	{
+		if((textureFormat == EGL_TEXTURE_RGB && configuration->mBindToTextureRGB != EGL_TRUE) ||
+		   ((textureFormat == EGL_TEXTURE_RGBA && configuration->mBindToTextureRGBA != EGL_TRUE)))
+		{
+			return error(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
+		}
 	}
 
-	Surface *surface = new PBufferSurface(this, configuration, width, height, textureFormat, textureTarget, largestPBuffer);
+	Surface *surface = new PBufferSurface(this, configuration, width, height, textureFormat, textureTarget, clientBufferFormat, clientBufferType, largestPBuffer, clientBuffer, ioSurfacePlane);
 
 	if(!surface->initialize())
 	{
diff --git a/src/OpenGL/libEGL/Display.h b/src/OpenGL/libEGL/Display.h
index 5944d69..30f01b9 100644
--- a/src/OpenGL/libEGL/Display.h
+++ b/src/OpenGL/libEGL/Display.h
@@ -26,6 +26,15 @@
 
 #include <set>
 
+#ifndef EGL_ANGLE_iosurface_client_buffer
+#define EGL_ANGLE_iosurface_client_buffer 1
+#define EGL_IOSURFACE_ANGLE 0x3454
+#define EGL_IOSURFACE_PLANE_ANGLE 0x345A
+#define EGL_TEXTURE_RECTANGLE_ANGLE 0x345B
+#define EGL_TEXTURE_TYPE_ANGLE 0x345C
+#define EGL_TEXTURE_INTERNAL_FORMAT_ANGLE 0x345D
+#endif // EGL_ANGLE_iosurface_client_buffer
+
 namespace egl
 {
 	class Surface;
@@ -51,7 +60,7 @@
 		bool getConfigAttrib(EGLConfig config, EGLint attribute, EGLint *value);
 
 		EGLSurface createWindowSurface(EGLNativeWindowType window, EGLConfig config, const EGLint *attribList);
-		EGLSurface createPBufferSurface(EGLConfig config, const EGLint *attribList);
+		EGLSurface createPBufferSurface(EGLConfig config, const EGLint *attribList, EGLClientBuffer clientBuffer = nullptr);
 		EGLContext createContext(EGLConfig configHandle, const Context *shareContext, EGLint clientVersion);
 		EGLSyncKHR createSync(Context *context);
 
diff --git a/src/OpenGL/libEGL/Surface.cpp b/src/OpenGL/libEGL/Surface.cpp
index d373990..ead75a6 100644
--- a/src/OpenGL/libEGL/Surface.cpp
+++ b/src/OpenGL/libEGL/Surface.cpp
@@ -63,6 +63,10 @@
 	swapBehavior = EGL_BUFFER_PRESERVED;
 	textureFormat = EGL_NO_TEXTURE;
 	textureTarget = EGL_NO_TEXTURE;
+	clientBufferFormat = EGL_NO_TEXTURE;
+	clientBufferType = EGL_NO_TEXTURE;
+	clientBuffer = nullptr;
+	clientBufferPlane = -1;
 	swapInterval = -1;
 	setSwapInterval(1);
 }
@@ -78,7 +82,15 @@
 
 	if(libGLESv2)
 	{
-		backBuffer = libGLESv2->createBackBuffer(width, height, config->mRenderTargetFormat, config->mSamples);
+		if(clientBuffer)
+		{
+			backBuffer = libGLESv2->createBackBufferFromClientBuffer(
+				egl::ClientBuffer(width, height, getClientBufferFormat(), clientBuffer, clientBufferPlane));
+		}
+		else
+		{
+			backBuffer = libGLESv2->createBackBuffer(width, height, config->mRenderTargetFormat, config->mSamples);
+		}
 	}
 	else if(libGLES_CM)
 	{
@@ -222,6 +234,51 @@
 	return largestPBuffer;
 }
 
+sw::Format Surface::getClientBufferFormat() const
+{
+	switch(clientBufferType)
+	{
+	case GL_UNSIGNED_BYTE:
+		switch(clientBufferFormat)
+		{
+		case GL_RED:
+			return sw::FORMAT_R8;
+		case GL_RG:
+			return sw::FORMAT_G8R8;
+		case GL_BGRA_EXT:
+			return sw::FORMAT_A8R8G8B8;
+		default:
+			UNREACHABLE(clientBufferFormat);
+			break;
+		}
+		break;
+	case GL_UNSIGNED_SHORT:
+		switch(clientBufferFormat)
+		{
+		case GL_R16UI:
+			return sw::FORMAT_R16UI;
+		default:
+			UNREACHABLE(clientBufferFormat);
+			break;
+		}
+		break;
+	case GL_HALF_FLOAT:
+		switch(clientBufferFormat)
+		{
+		case GL_RGBA:
+			return sw::FORMAT_A16B16G16R16F;
+		default:
+			UNREACHABLE(clientBufferFormat);
+			break;
+		}
+	default:
+		UNREACHABLE(clientBufferType);
+		break;
+	}
+
+	return sw::FORMAT_NULL;
+}
+
 void Surface::setBoundTexture(egl::Texture *texture)
 {
 	this->texture = texture;
@@ -356,12 +413,21 @@
 	return Surface::initialize();
 }
 
-PBufferSurface::PBufferSurface(Display *display, const Config *config, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureType, EGLBoolean largestPBuffer)
+PBufferSurface::PBufferSurface(Display *display, const Config *config, EGLint width, EGLint height,
+                               EGLenum textureFormat, EGLenum textureTarget, EGLenum clientBufferFormat,
+                               EGLenum clientBufferType, EGLBoolean largestPBuffer, EGLClientBuffer clientBuffer,
+                               EGLint clientBufferPlane)
 	: Surface(display, config)
 {
 	this->width = width;
 	this->height = height;
 	this->largestPBuffer = largestPBuffer;
+	this->textureFormat = textureFormat;
+	this->textureTarget = textureTarget;
+	this->clientBufferFormat = clientBufferFormat;
+	this->clientBufferType = clientBufferType;
+	this->clientBuffer = clientBuffer;
+	this->clientBufferPlane = clientBufferPlane;
 }
 
 PBufferSurface::~PBufferSurface()
diff --git a/src/OpenGL/libEGL/Surface.hpp b/src/OpenGL/libEGL/Surface.hpp
index 2e9e26b..be43edb 100644
--- a/src/OpenGL/libEGL/Surface.hpp
+++ b/src/OpenGL/libEGL/Surface.hpp
@@ -48,11 +48,11 @@
 
 	EGLint getWidth() const override;
 	EGLint getHeight() const override;
+	EGLenum getTextureTarget() const override;
 	virtual EGLint getPixelAspectRatio() const;
 	virtual EGLenum getRenderBuffer() const;
 	virtual EGLenum getSwapBehavior() const;
 	virtual EGLenum getTextureFormat() const;
-	virtual EGLenum getTextureTarget() const;
 	virtual EGLBoolean getLargestPBuffer() const;
 	virtual EGLNativeWindowType getWindowHandle() const = 0;
 
@@ -61,6 +61,7 @@
 
 	virtual bool isWindowSurface() const { return false; }
 	virtual bool isPBufferSurface() const { return false; }
+	bool hasClientBuffer() const { return clientBuffer != nullptr; }
 
 protected:
 	Surface(const Display *display, const Config *config);
@@ -69,6 +70,8 @@
 
 	virtual void deleteResources();
 
+	sw::Format getClientBufferFormat() const;
+
 	const Display *const display;
 	Image *depthStencil;
 	Image *backBuffer;
@@ -77,8 +80,8 @@
 	bool reset(int backbufferWidth, int backbufferHeight);
 
 	const Config *const config;    // EGL config surface was created with
-	EGLint height;                 // Height of surface
 	EGLint width;                  // Width of surface
+	EGLint height;                 // Height of surface
 //  EGLint horizontalResolution;   // Horizontal dot pitch
 //  EGLint verticalResolution;     // Vertical dot pitch
 	EGLBoolean largestPBuffer;     // If true, create largest pbuffer possible
@@ -90,9 +93,13 @@
 	EGLenum swapBehavior;          // Buffer swap behavior
 	EGLenum textureFormat;         // Format of texture: RGB, RGBA, or no texture
 	EGLenum textureTarget;         // Type of texture: 2D or no texture
+	EGLenum clientBufferFormat;    // Format of the client buffer
+	EGLenum clientBufferType;      // Type of the client buffer
 //  EGLenum vgAlphaFormat;         // Alpha format for OpenVG
 //  EGLenum vgColorSpace;          // Color space for OpenVG
 	EGLint swapInterval;
+	EGLClientBuffer clientBuffer;
+	EGLint clientBufferPlane;
 };
 
 class WindowSurface : public Surface
@@ -120,7 +127,10 @@
 class PBufferSurface : public Surface
 {
 public:
-	PBufferSurface(Display *display, const egl::Config *config, EGLint width, EGLint height, EGLenum textureFormat, EGLenum textureTarget, EGLBoolean largestPBuffer);
+	PBufferSurface(Display *display, const egl::Config *config, EGLint width, EGLint height,
+	               EGLenum textureFormat, EGLenum textureTarget, EGLenum internalFormat,
+	               EGLenum textureType, EGLBoolean largestPBuffer, EGLClientBuffer clientBuffer,
+	               EGLint clientBufferPlane);
 	~PBufferSurface() override;
 
 	bool isPBufferSurface() const override { return true; }
diff --git a/src/OpenGL/libEGL/libEGL.cpp b/src/OpenGL/libEGL/libEGL.cpp
index 55ee224..74510df 100644
--- a/src/OpenGL/libEGL/libEGL.cpp
+++ b/src/OpenGL/libEGL/libEGL.cpp
@@ -204,6 +204,7 @@
 		               "EGL_KHR_fence_sync "
 		               "EGL_KHR_image_base "
 		               "EGL_KHR_surfaceless_context "
+		               "EGL_ANGLE_iosurface_client_buffer "
 		               "EGL_ANDROID_framebuffer_target "
 		               "EGL_ANDROID_recordable");
 	case EGL_VENDOR:
@@ -507,9 +508,25 @@
 	      "EGLConfig config = %p, const EGLint *attrib_list = %p)",
 	      dpy, buftype, buffer, config, attrib_list);
 
-	UNIMPLEMENTED();
+	switch(buftype)
+	{
+	case EGL_IOSURFACE_ANGLE:
+	{
+		egl::Display *display = egl::Display::get(dpy);
 
-	return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+		if(!validateConfig(display, config))
+		{
+			return EGL_NO_SURFACE;
+		}
+
+		return display->createPBufferSurface(config, attrib_list, buffer);
+	}
+	case EGL_OPENVG_IMAGE:
+		UNIMPLEMENTED();
+		return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+	default:
+		return error(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
+	};
 }
 
 EGLBoolean SurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
@@ -810,6 +827,13 @@
 		return EGL_FALSE;
 	}
 
+	if((draw != EGL_NO_SURFACE && drawSurface->hasClientBuffer()) ||
+	   (read != EGL_NO_SURFACE && readSurface->hasClientBuffer()))
+	{
+		// Make current is not supported on IOSurface pbuffers.
+		return error(EGL_BAD_SURFACE, EGL_FALSE);
+	}
+
 	if((draw != EGL_NO_SURFACE) ^ (read != EGL_NO_SURFACE))
 	{
 		return error(EGL_BAD_MATCH, EGL_FALSE);
diff --git a/src/OpenGL/libGLESv2/BUILD.gn b/src/OpenGL/libGLESv2/BUILD.gn
index b4383c9..82d3191 100644
--- a/src/OpenGL/libGLESv2/BUILD.gn
+++ b/src/OpenGL/libGLESv2/BUILD.gn
@@ -109,6 +109,10 @@
   if (is_win) {
     ldflags = [ "/DEF:" + rebase_path("libGLESv2.def", root_build_dir) ]
   } else if (is_mac) {
+    libs = [
+      "CoreFoundation.framework",
+      "IOSurface.framework",
+    ]
     ldflags = [ "-Wl,-install_name,@rpath/libswiftshader_libGLESv2.dylib" ]
   } else if (is_linux) {
     ldflags =
diff --git a/src/OpenGL/libGLESv2/Context.cpp b/src/OpenGL/libGLESv2/Context.cpp
index 6233e8f..5148e6b 100644
--- a/src/OpenGL/libGLESv2/Context.cpp
+++ b/src/OpenGL/libGLESv2/Context.cpp
@@ -4093,8 +4093,8 @@
 	{
 		GLenum readColorbufferType = readFramebuffer->getReadBufferType();
 		GLenum drawColorbufferType = drawFramebuffer->getColorbufferType(0);
-		const bool validReadType = readColorbufferType == GL_TEXTURE_2D || Framebuffer::IsRenderbuffer(readColorbufferType);
-		const bool validDrawType = drawColorbufferType == GL_TEXTURE_2D || Framebuffer::IsRenderbuffer(drawColorbufferType);
+		const bool validReadType = readColorbufferType == GL_TEXTURE_2D || readColorbufferType == GL_TEXTURE_RECTANGLE_ARB || Framebuffer::IsRenderbuffer(readColorbufferType);
+		const bool validDrawType = drawColorbufferType == GL_TEXTURE_2D || drawColorbufferType == GL_TEXTURE_RECTANGLE_ARB || Framebuffer::IsRenderbuffer(drawColorbufferType);
 		if(!validReadType || !validDrawType)
 		{
 			return error(GL_INVALID_OPERATION);
@@ -4145,8 +4145,10 @@
 			return error(GL_INVALID_OPERATION);
 		}
 
-		if((readRenderbuffer->getSamples() > 0) &&
-		   (readRenderbuffer->getFormat() != drawRenderbuffer->getFormat()))
+		// From the ANGLE_framebuffer_blit extension:
+		// "Calling BlitFramebufferANGLE will result in an INVALID_OPERATION error if <mask>
+		//  includes COLOR_BUFFER_BIT and the source and destination color formats to not match."
+		if((clientVersion < 3) && (readRenderbuffer->getSamples() > 0) && (readFormat != drawFormat))
 		{
 			return error(GL_INVALID_OPERATION);
 		}
@@ -4291,7 +4293,8 @@
 
 void Context::bindTexImage(gl::Surface *surface)
 {
-	es2::Texture2D *textureObject = getTexture2D();
+	bool isRect = (surface->getTextureTarget() == EGL_TEXTURE_RECTANGLE_ANGLE);
+	es2::Texture2D *textureObject = isRect ? getTexture2DRect() : getTexture2D();
 
 	if(textureObject)
 	{
diff --git a/src/OpenGL/libGLESv2/Texture.cpp b/src/OpenGL/libGLESv2/Texture.cpp
index dc0e807..ec96373 100644
--- a/src/OpenGL/libGLESv2/Texture.cpp
+++ b/src/OpenGL/libGLESv2/Texture.cpp
@@ -1900,6 +1900,18 @@
 	return egl::Image::create(width, height, internalformat, multiSampleDepth, false);
 }
 
+NO_SANITIZE_FUNCTION egl::Image *createBackBufferFromClientBuffer(const egl::ClientBuffer& clientBuffer)
+{
+	if(clientBuffer.getWidth() > es2::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE ||
+	   clientBuffer.getHeight() > es2::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE)
+	{
+		ERR("Invalid parameters: %dx%d", clientBuffer.getWidth(), clientBuffer.getHeight());
+		return nullptr;
+	}
+
+	return egl::Image::create(clientBuffer);
+}
+
 NO_SANITIZE_FUNCTION egl::Image *createDepthStencil(int width, int height, sw::Format format, int multiSampleDepth)
 {
 	if(width > es2::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE || height > es2::IMPLEMENTATION_MAX_RENDERBUFFER_SIZE)
diff --git a/src/OpenGL/libGLESv2/entry_points.cpp b/src/OpenGL/libGLESv2/entry_points.cpp
index e4b35aa..b142b85 100644
--- a/src/OpenGL/libGLESv2/entry_points.cpp
+++ b/src/OpenGL/libGLESv2/entry_points.cpp
@@ -1211,6 +1211,7 @@
 egl::Context *es2CreateContext(egl::Display *display, const egl::Context *shareContext, int clientVersion, const egl::Config *config);
 extern "C" __eglMustCastToProperFunctionPointerType es2GetProcAddress(const char *procname);
 egl::Image *createBackBuffer(int width, int height, sw::Format format, int multiSampleDepth);
+egl::Image *createBackBufferFromClientBuffer(const egl::ClientBuffer& clientBuffer);
 egl::Image *createDepthStencil(int width, int height, sw::Format format, int multiSampleDepth);
 sw::FrameBuffer *createFrameBuffer(void *nativeDisplay, EGLNativeWindowType window, int width, int height);
 
@@ -1414,6 +1415,7 @@
 	this->es2CreateContext = ::es2CreateContext;
 	this->es2GetProcAddress = ::es2GetProcAddress;
 	this->createBackBuffer = ::createBackBuffer;
+	this->createBackBufferFromClientBuffer = ::createBackBufferFromClientBuffer;
 	this->createDepthStencil = ::createDepthStencil;
 	this->createFrameBuffer = ::createFrameBuffer;
 }
diff --git a/src/OpenGL/libGLESv2/libGLESv2.hpp b/src/OpenGL/libGLESv2/libGLESv2.hpp
index 0897d3b..8946f0b 100644
--- a/src/OpenGL/libGLESv2/libGLESv2.hpp
+++ b/src/OpenGL/libGLESv2/libGLESv2.hpp
@@ -33,6 +33,7 @@
 class Context;
 class Image;
 class Config;
+class ClientBuffer;
 }
 
 class LibGLESv2exports
@@ -245,6 +246,7 @@
 	egl::Context *(*es2CreateContext)(egl::Display *display, const egl::Context *shareContext, int clientVersion, const egl::Config *config);
 	__eglMustCastToProperFunctionPointerType (*es2GetProcAddress)(const char *procname);
 	egl::Image *(*createBackBuffer)(int width, int height, sw::Format format, int multiSampleDepth);
+	egl::Image *(*createBackBufferFromClientBuffer)(const egl::ClientBuffer& clientBuffer);
 	egl::Image *(*createDepthStencil)(int width, int height, sw::Format format, int multiSampleDepth);
 	sw::FrameBuffer *(*createFrameBuffer)(void *nativeDisplay, EGLNativeWindowType window, int width, int height);
 };
diff --git a/tests/unittests/BUILD.gn b/tests/unittests/BUILD.gn
index aa7dfef..10f5fa5 100644
--- a/tests/unittests/BUILD.gn
+++ b/tests/unittests/BUILD.gn
@@ -46,6 +46,10 @@
       "-rpath",
       "@executable_path/",
     ]
+    libs = [
+      "CoreFoundation.framework",
+      "IOSurface.framework",
+    ]
   } else {
     ldflags = [ "-Wl,-rpath=\$ORIGIN/swiftshader" ]
   }
diff --git a/tests/unittests/unittests.cpp b/tests/unittests/unittests.cpp
index 7ae84da..99cbb61 100644
--- a/tests/unittests/unittests.cpp
+++ b/tests/unittests/unittests.cpp
@@ -97,6 +97,7 @@
 			EGL_ALPHA_SIZE,			8,
 			EGL_NONE
 		};
+
 		EGLint num_config = -1;
 		EGLBoolean success = eglChooseConfig(display, configAttributes, &config, 1, &num_config);
 		EXPECT_EQ(EGL_SUCCESS, eglGetError());
@@ -203,29 +204,43 @@
 		EXPECT_EQ((EGLBoolean)EGL_TRUE, success);
 	}
 
-	GLuint createProgram(const std::string& vs, const std::string& fs)
+	struct ProgramHandles {
+		GLuint program;
+		GLuint vsShader;
+		GLuint fsShader;
+	};
+
+	ProgramHandles createProgram(const std::string& vs, const std::string& fs)
 	{
-		GLuint program = glCreateProgram();
+		ProgramHandles ph;
+		ph.program = glCreateProgram();
 		EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-		GLuint vsShader = glCreateShader(GL_VERTEX_SHADER);
+		ph.vsShader = glCreateShader(GL_VERTEX_SHADER);
 		const char* vsSource[1] = { vs.c_str() };
-		glShaderSource(vsShader, 1, vsSource, nullptr);
-		glCompileShader(vsShader);
+		glShaderSource(ph.vsShader, 1, vsSource, nullptr);
+		glCompileShader(ph.vsShader);
 		EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-		GLuint fsShader = glCreateShader(GL_FRAGMENT_SHADER);
+		ph.fsShader = glCreateShader(GL_FRAGMENT_SHADER);
 		const char* fsSource[1] = { fs.c_str() };
-		glShaderSource(fsShader, 1, fsSource, nullptr);
-		glCompileShader(fsShader);
+		glShaderSource(ph.fsShader, 1, fsSource, nullptr);
+		glCompileShader(ph.fsShader);
 		EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-		glAttachShader(program, vsShader);
-		glAttachShader(program, fsShader);
-		glLinkProgram(program);
+		glAttachShader(ph.program, ph.vsShader);
+		glAttachShader(ph.program, ph.fsShader);
+		glLinkProgram(ph.program);
 		EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-		return program;
+		return ph;
+	}
+
+	void deleteProgram(const ProgramHandles& ph)
+	{
+		glDeleteShader(ph.fsShader);
+		glDeleteShader(ph.vsShader);
+		glDeleteProgram(ph.program);
 	}
 
 	void drawQuad(GLuint program)
@@ -262,7 +277,7 @@
 	}
 
 	EGLDisplay getDisplay() const { return display; }
-	EGLDisplay getConfig() const { return config; }
+	EGLConfig getConfig() const { return config; }
 	EGLSurface getSurface() const { return surface; }
 	EGLContext getContext() const { return context; }
 private:
@@ -532,10 +547,10 @@
 		"    gl_FragColor = texture2DRect(tex, vec2(0, 0));\n"
 		"}\n";
 
-	GLuint program = createProgram(vs, fs);
+	const ProgramHandles ph = createProgram(vs, fs);
 
-	glUseProgram(program);
-	GLint location = glGetUniformLocation(program, "tex");
+	glUseProgram(ph.program);
+	GLint location = glGetUniformLocation(ph.program, "tex");
 	ASSERT_NE(-1, location);
 	glUniform1i(location, 0);
 
@@ -543,7 +558,9 @@
 	glClear(GL_COLOR_BUFFER_BIT);
 	EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-	drawQuad(program);
+	drawQuad(ph.program);
+
+	deleteProgram(ph);
 
 	compareColor(green);
 
@@ -584,9 +601,10 @@
 		"    fragColor = texture(tex, vec2(0, 0));\n"
 		"}\n";
 
-	GLuint program = createProgram(vs, fs);
-	glUseProgram(program);
-	GLint location = glGetUniformLocation(program, "tex");
+	const ProgramHandles ph = createProgram(vs, fs);
+
+	glUseProgram(ph.program);
+	GLint location = glGetUniformLocation(ph.program, "tex");
 	ASSERT_NE(-1, location);
 	glUniform1i(location, 0);
 
@@ -594,7 +612,9 @@
 	glClear(GL_COLOR_BUFFER_BIT);
 	EXPECT_GLENUM_EQ(GL_NONE, glGetError());
 
-	drawQuad(program);
+	drawQuad(ph.program);
+
+	deleteProgram(ph);
 
 	compareColor(green);
 
@@ -717,3 +737,743 @@
 
 	Uninitialize();
 }
+
+#ifndef EGL_ANGLE_iosurface_client_buffer
+#define EGL_ANGLE_iosurface_client_buffer 1
+#define EGL_IOSURFACE_ANGLE 0x3454
+#define EGL_IOSURFACE_PLANE_ANGLE 0x345A
+#define EGL_TEXTURE_RECTANGLE_ANGLE 0x345B
+#define EGL_TEXTURE_TYPE_ANGLE 0x345C
+#define EGL_TEXTURE_INTERNAL_FORMAT_ANGLE 0x345D
+#endif /* EGL_ANGLE_iosurface_client_buffer */
+
+#if defined(__APPLE__)
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOSurface/IOSurface.h>
+
+namespace
+{
+	void AddIntegerValue(CFMutableDictionaryRef dictionary, const CFStringRef key, int32_t value)
+	{
+		CFNumberRef number = CFNumberCreate(nullptr, kCFNumberSInt32Type, &value);
+		CFDictionaryAddValue(dictionary, key, number);
+		CFRelease(number);
+	}
+}  // anonymous namespace
+
+class EGLClientBufferWrapper
+{
+public:
+	EGLClientBufferWrapper(int width = 1, int height = 1)
+	{
+		// Create a 1 by 1 BGRA8888 IOSurface
+		ioSurface = nullptr;
+
+		CFMutableDictionaryRef dict = CFDictionaryCreateMutable(
+			kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
+		AddIntegerValue(dict, kIOSurfaceWidth, width);
+		AddIntegerValue(dict, kIOSurfaceHeight, height);
+		AddIntegerValue(dict, kIOSurfacePixelFormat, 'BGRA');
+		AddIntegerValue(dict, kIOSurfaceBytesPerElement, 4);
+
+		ioSurface = IOSurfaceCreate(dict);
+		CFRelease(dict);
+
+		EXPECT_NE(nullptr, ioSurface);
+	}
+
+	~EGLClientBufferWrapper()
+	{
+		IOSurfaceUnlock(ioSurface, kIOSurfaceLockReadOnly, nullptr);
+
+		CFRelease(ioSurface);
+	}
+
+	EGLClientBuffer getClientBuffer() const
+	{
+		return ioSurface;
+	}
+
+	const unsigned char* lockColor()
+	{
+		IOSurfaceLock(ioSurface, kIOSurfaceLockReadOnly, nullptr);
+		return reinterpret_cast<const unsigned char*>(IOSurfaceGetBaseAddress(ioSurface));
+	}
+
+	void unlockColor()
+	{
+		IOSurfaceUnlock(ioSurface, kIOSurfaceLockReadOnly, nullptr);
+	}
+
+	void writeColor(void* data, size_t dataSize)
+	{
+		// Write the data to the IOSurface
+		IOSurfaceLock(ioSurface, 0, nullptr);
+		memcpy(IOSurfaceGetBaseAddress(ioSurface), data, dataSize);
+		IOSurfaceUnlock(ioSurface, 0, nullptr);
+	}
+private:
+	IOSurfaceRef ioSurface;
+};
+
+#else // __APPLE__
+
+class EGLClientBufferWrapper
+{
+public:
+	EGLClientBufferWrapper(int width = 1, int height = 1)
+	{
+		clientBuffer = new unsigned char[4 * width * height];
+	}
+
+	~EGLClientBufferWrapper()
+	{
+		delete[] clientBuffer;
+	}
+
+	EGLClientBuffer getClientBuffer() const
+	{
+		return clientBuffer;
+	}
+
+	const unsigned char* lockColor()
+	{
+		return clientBuffer;
+	}
+
+	void unlockColor()
+	{
+	}
+
+	void writeColor(void* data, size_t dataSize)
+	{
+		memcpy(clientBuffer, data, dataSize);
+	}
+private:
+	unsigned char* clientBuffer;
+};
+
+#endif
+
+class IOSurfaceClientBufferTest : public SwiftShaderTest
+{
+protected:
+	EGLSurface createIOSurfacePbuffer(EGLClientBuffer buffer, EGLint width, EGLint height, EGLint plane, GLenum internalFormat, GLenum type) const
+	{
+		// Make a PBuffer from it using the EGL_ANGLE_iosurface_client_buffer extension
+		const EGLint attribs[] = {
+			EGL_WIDTH,                         width,
+			EGL_HEIGHT,                        height,
+			EGL_IOSURFACE_PLANE_ANGLE,         plane,
+			EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+			EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, (EGLint)internalFormat,
+			EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+			EGL_TEXTURE_TYPE_ANGLE,            (EGLint)type,
+			EGL_NONE,                          EGL_NONE,
+		};
+
+		EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, buffer, getConfig(), attribs);
+		EXPECT_NE(EGL_NO_SURFACE, pbuffer);
+		return pbuffer;
+	}
+
+	void bindIOSurfaceToTexture(EGLClientBuffer buffer, EGLint width, EGLint height, EGLint plane, GLenum internalFormat, GLenum type, EGLSurface *pbuffer, GLuint *texture) const
+	{
+		*pbuffer = createIOSurfacePbuffer(buffer, width, height, plane, internalFormat, type);
+
+		// Bind the pbuffer
+		glBindTexture(GL_TEXTURE_RECTANGLE_ARB, *texture);
+		EGLBoolean result = eglBindTexImage(getDisplay(), *pbuffer, EGL_BACK_BUFFER);
+		EXPECT_EQ((EGLBoolean)EGL_TRUE, result);
+		EXPECT_EQ(EGL_SUCCESS, eglGetError());
+	}
+
+	void doClear(GLenum internalFormat, bool clearToZero)
+	{
+		if(internalFormat == GL_R16UI)
+		{
+			GLuint color = clearToZero ? 0 : 257;
+			glClearBufferuiv(GL_COLOR, 0, &color);
+			EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+		}
+		else
+		{
+			glClearColor(clearToZero ? 0.0f : 1.0f / 255.0f,
+				clearToZero ? 0.0f : 2.0f / 255.0f,
+				clearToZero ? 0.0f : 3.0f / 255.0f,
+				clearToZero ? 0.0f : 4.0f / 255.0f);
+			EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+			glClear(GL_COLOR_BUFFER_BIT);
+			EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+		}
+	}
+
+	void doClearTest(EGLClientBufferWrapper& clientBufferWrapper, GLenum internalFormat, GLenum type, void *data, size_t dataSize)
+	{
+		ASSERT_TRUE(dataSize <= 4);
+
+		// Bind the IOSurface to a texture and clear it.
+		GLuint texture = 1;
+		EGLSurface pbuffer;
+		bindIOSurfaceToTexture(clientBufferWrapper.getClientBuffer(), 1, 1, 0, internalFormat, type, &pbuffer, &texture);
+
+		// glClear the pbuffer
+		GLuint fbo = 2;
+		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+		EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_RECTANGLE_ARB, texture, 0);
+		EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+		EXPECT_GLENUM_EQ(glCheckFramebufferStatus(GL_FRAMEBUFFER), GL_FRAMEBUFFER_COMPLETE);
+		EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+
+		doClear(internalFormat, false);
+
+		// Unbind pbuffer and check content.
+		EGLBoolean result = eglReleaseTexImage(getDisplay(), pbuffer, EGL_BACK_BUFFER);
+		EXPECT_EQ((EGLBoolean)EGL_TRUE, result);
+		EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+		const unsigned char* color = clientBufferWrapper.lockColor();
+		for(size_t i = 0; i < dataSize; ++i)
+		{
+			EXPECT_EQ(color[i], reinterpret_cast<unsigned char*>(data)[i]);
+		}
+
+		result = eglDestroySurface(getDisplay(), pbuffer);
+		EXPECT_EQ((EGLBoolean)EGL_TRUE, result);
+		EXPECT_EQ(EGL_SUCCESS, eglGetError());
+	}
+
+	void doSampleTest(EGLClientBufferWrapper& clientBufferWrapper, GLenum internalFormat, GLenum type, void *data, size_t dataSize)
+	{
+		ASSERT_TRUE(dataSize <= 4);
+
+		clientBufferWrapper.writeColor(data, dataSize);
+
+		// Bind the IOSurface to a texture and clear it.
+		GLuint texture = 1;
+		EGLSurface pbuffer;
+		bindIOSurfaceToTexture(clientBufferWrapper.getClientBuffer(), 1, 1, 0, internalFormat, type, &pbuffer, &texture);
+
+		doClear(internalFormat, true);
+
+		// Create program and draw quad using it
+		const std::string vs =
+			"attribute vec4 position;\n"
+			"void main()\n"
+			"{\n"
+			"    gl_Position = vec4(position.xy, 0.0, 1.0);\n"
+			"}\n";
+
+		const std::string fs =
+			"#extension GL_ARB_texture_rectangle : require\n"
+			"precision mediump float;\n"
+			"uniform sampler2DRect tex;\n"
+			"void main()\n"
+			"{\n"
+			"    gl_FragColor = texture2DRect(tex, vec2(0, 0));\n"
+			"}\n";
+
+		const ProgramHandles ph = createProgram(vs, fs);
+
+		drawQuad(ph.program);
+
+		deleteProgram(ph);
+
+		EXPECT_GLENUM_EQ(GL_NO_ERROR, glGetError());
+
+		// Unbind pbuffer and check content.
+		EGLBoolean result = eglReleaseTexImage(getDisplay(), pbuffer, EGL_BACK_BUFFER);
+		EXPECT_EQ((EGLBoolean)EGL_TRUE, result);
+		EXPECT_EQ(EGL_SUCCESS, eglGetError());
+
+		const unsigned char* color = clientBufferWrapper.lockColor();
+		for(size_t i = 0; i < dataSize; ++i)
+		{
+			EXPECT_EQ(color[i], reinterpret_cast<unsigned char*>(data)[i]);
+		}
+		clientBufferWrapper.unlockColor();
+	}
+};
+
+// Tests for the EGL_ANGLE_iosurface_client_buffer extension
+TEST_F(IOSurfaceClientBufferTest, RenderToBGRA8888IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		unsigned char data[4] = { 3, 2, 1, 4 };
+		doClearTest(clientBufferWrapper, GL_BGRA_EXT, GL_UNSIGNED_BYTE, data, 4);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test reading from BGRA8888 IOSurfaces
+TEST_F(IOSurfaceClientBufferTest, ReadFromBGRA8888IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		unsigned char data[4] = { 3, 2, 1, 4 };
+		doSampleTest(clientBufferWrapper, GL_BGRA_EXT, GL_UNSIGNED_BYTE, data, 4);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test using RG88 IOSurfaces for rendering
+TEST_F(IOSurfaceClientBufferTest, RenderToRG88IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		unsigned char data[2] = { 1, 2 };
+		doClearTest(clientBufferWrapper, GL_RG, GL_UNSIGNED_BYTE, data, 2);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test reading from RG88 IOSurfaces
+TEST_F(IOSurfaceClientBufferTest, ReadFromRG88IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		unsigned char data[2] = { 1, 2 };
+		doSampleTest(clientBufferWrapper, GL_RG, GL_UNSIGNED_BYTE, data, 2);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test using R8 IOSurfaces for rendering
+TEST_F(IOSurfaceClientBufferTest, RenderToR8IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		unsigned char data[1] = { 1 };
+		doClearTest(clientBufferWrapper, GL_RED, GL_UNSIGNED_BYTE, data, 1);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test reading from R8 IOSurfaces
+TEST_F(IOSurfaceClientBufferTest, ReadFromR8IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		unsigned char data[1] = { 1 };
+		doSampleTest(clientBufferWrapper, GL_RED, GL_UNSIGNED_BYTE, data, 1);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test using R16 IOSurfaces for rendering
+TEST_F(IOSurfaceClientBufferTest, RenderToR16IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		uint16_t data[1] = { 257 };
+		doClearTest(clientBufferWrapper, GL_R16UI, GL_UNSIGNED_SHORT, data, 2);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test reading from R8 IOSurfaces
+TEST_F(IOSurfaceClientBufferTest, ReadFromR16IOSurface)
+{
+	Initialize(3, false);
+
+	{ // EGLClientBufferWrapper scope
+		EGLClientBufferWrapper clientBufferWrapper;
+		uint16_t data[1] = { 257 };
+		doSampleTest(clientBufferWrapper, GL_R16UI, GL_UNSIGNED_SHORT, data, 1);
+	} // end of EGLClientBufferWrapper scope
+
+	Uninitialize();
+}
+
+// Test the validation errors for missing attributes for eglCreatePbufferFromClientBuffer with
+// IOSurface
+TEST_F(IOSurfaceClientBufferTest, NegativeValidationMissingAttributes)
+{
+	Initialize(3, false);
+
+	{
+		EGLClientBufferWrapper clientBufferWrapper(10, 10);
+
+		// Success case
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_NE(EGL_NO_SURFACE, pbuffer);
+
+			EGLBoolean result = eglDestroySurface(getDisplay(), pbuffer);
+			EXPECT_EQ((EGLBoolean)EGL_TRUE, result);
+			EXPECT_EQ(EGL_SUCCESS, eglGetError());
+		}
+
+		// Missing EGL_WIDTH
+		{
+			const EGLint attribs[] = {
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+		}
+
+		// Missing EGL_HEIGHT
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+		}
+
+		// Missing EGL_IOSURFACE_PLANE_ANGLE
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+		}
+
+		// Missing EGL_TEXTURE_TARGET - EGL_BAD_MATCH from the base spec of
+		// eglCreatePbufferFromClientBuffer
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_MATCH, eglGetError());
+		}
+
+		// Missing EGL_TEXTURE_INTERNAL_FORMAT_ANGLE
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+		}
+
+		// Missing EGL_TEXTURE_FORMAT - EGL_BAD_MATCH from the base spec of
+		// eglCreatePbufferFromClientBuffer
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_MATCH, eglGetError());
+		}
+
+		// Missing EGL_TEXTURE_TYPE_ANGLE
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_PARAMETER, eglGetError());
+		}
+	}
+
+	Uninitialize();
+}
+
+// Test the validation errors for bad parameters for eglCreatePbufferFromClientBuffer with IOSurface
+TEST_F(IOSurfaceClientBufferTest, NegativeValidationBadAttributes)
+{
+	Initialize(3, false);
+
+	{
+		EGLClientBufferWrapper clientBufferWrapper(10, 10);
+
+		// Success case
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_NE(EGL_NO_SURFACE, pbuffer);
+
+			EGLBoolean result = eglDestroySurface(getDisplay(), pbuffer);
+			EXPECT_EQ((EGLBoolean)EGL_TRUE, result);
+			EXPECT_EQ(EGL_SUCCESS, eglGetError());
+		}
+
+		// EGL_TEXTURE_FORMAT must be EGL_TEXTURE_RGBA
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGB,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+		// EGL_WIDTH must be at least 1
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         0,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+		// EGL_HEIGHT must be at least 1
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        0,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+#if defined(__APPLE__)
+		// EGL_WIDTH must be at most the width of the IOSurface
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         11,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+		// EGL_HEIGHT must be at most the height of the IOSurface
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        11,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+		// EGL_IOSURFACE_PLANE_ANGLE must less than the number of planes of the IOSurface
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         1,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+#endif
+
+		// EGL_TEXTURE_FORMAT must be at EGL_TEXTURE_RECTANGLE_ANGLE
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_2D,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+		// EGL_IOSURFACE_PLANE_ANGLE must be at least 0
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         -1,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_BGRA_EXT,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+
+		// The internal format / type most be listed in the table
+		{
+			const EGLint attribs[] = {
+				EGL_WIDTH,                         10,
+				EGL_HEIGHT,                        10,
+				EGL_IOSURFACE_PLANE_ANGLE,         0,
+				EGL_TEXTURE_TARGET,                EGL_TEXTURE_RECTANGLE_ANGLE,
+				EGL_TEXTURE_INTERNAL_FORMAT_ANGLE, GL_RGBA,
+				EGL_TEXTURE_FORMAT,                EGL_TEXTURE_RGBA,
+				EGL_TEXTURE_TYPE_ANGLE,            GL_UNSIGNED_BYTE,
+				EGL_NONE,                          EGL_NONE,
+			};
+
+			EGLSurface pbuffer = eglCreatePbufferFromClientBuffer(getDisplay(), EGL_IOSURFACE_ANGLE, clientBufferWrapper.getClientBuffer(), getConfig(), attribs);
+			EXPECT_EQ(EGL_NO_SURFACE, pbuffer);
+			EXPECT_EQ(EGL_BAD_ATTRIBUTE, eglGetError());
+		}
+	}
+
+	Uninitialize();
+}
+
+// Test IOSurface pbuffers cannot be made current
+TEST_F(IOSurfaceClientBufferTest, MakeCurrentDisallowed)
+{
+	Initialize(3, false);
+
+	{
+		EGLClientBufferWrapper clientBufferWrapper(10, 10);
+
+		EGLSurface pbuffer = createIOSurfacePbuffer(clientBufferWrapper.getClientBuffer(), 10, 10, 0, GL_BGRA_EXT, GL_UNSIGNED_BYTE);
+
+		EGLBoolean result = eglMakeCurrent(getDisplay(), pbuffer, pbuffer, getContext());
+		EXPECT_EQ((EGLBoolean)EGL_FALSE, result);
+		EXPECT_EQ(EGL_BAD_SURFACE, eglGetError());
+	}
+
+	Uninitialize();
+}