diff --git a/src/Android.bp b/src/Android.bp
index 026e23c..1f9f5fa 100644
--- a/src/Android.bp
+++ b/src/Android.bp
@@ -56,7 +56,6 @@
             shared_libs: [
                 "android.hardware.graphics.mapper@3.0",
                 "android.hardware.graphics.mapper@4.0",
-                "libdrm",
                 "libnativewindow",
                 "libhardware",
                 "libhidlbase",
@@ -591,7 +590,6 @@
             shared_libs: [
                 "android.hardware.graphics.mapper@3.0",
                 "android.hardware.graphics.mapper@4.0",
-                "libdrm",
                 "libnativewindow",
                 "libhardware",
                 "libhidlbase",
@@ -664,8 +662,6 @@
     include_dirs: [
         "external/swiftshader/third_party/SPIRV-Headers/include",
         "external/swiftshader/include",
-        "external/minigbm",
-        "external/libdrm"
     ],
 }
 
diff --git a/src/Vulkan/VkBuffer.hpp b/src/Vulkan/VkBuffer.hpp
index 2aa59fc..fd95fe2 100644
--- a/src/Vulkan/VkBuffer.hpp
+++ b/src/Vulkan/VkBuffer.hpp
@@ -41,6 +41,9 @@
 	uint8_t *end() const;
 	bool canBindToMemory(DeviceMemory *pDeviceMemory) const;
 
+	VkBufferUsageFlags getUsage() const { return usage; }
+	VkBufferCreateFlags getFlags() const { return flags; }
+
 private:
 	void *memory = nullptr;
 	VkBufferCreateFlags flags = 0;
diff --git a/src/Vulkan/VkDevice.cpp b/src/Vulkan/VkDevice.cpp
index cc0a359..4cdca03 100644
--- a/src/Vulkan/VkDevice.cpp
+++ b/src/Vulkan/VkDevice.cpp
@@ -146,10 +146,6 @@
 		debugger.server = vk::dbg::Server::create(debugger.context, atoi(port));
 	}
 #endif  // ENABLE_VK_DEBUGGER
-
-#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
-	ahbAddressMap.reset(new AHBAddressMap());
-#endif
 }
 
 void Device::destroy(const VkAllocationCallbacks *pAllocator)
@@ -379,60 +375,4 @@
 	}
 }
 
-#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
-Device::AHBAddressMap *Device::getAHBAddressMap() const
-{
-	return ahbAddressMap.get();
-}
-
-void *Device::AHBAddressMap::query(const uint32_t key)
-{
-	std::unique_lock<std::mutex> lock(addressMapMutex);
-	if(addressMap.find(key) == addressMap.end())
-		return nullptr;
-
-	return addressMap[key].address;
-}
-
-void Device::AHBAddressMap::add(const uint32_t key, void *value)
-{
-	std::unique_lock<std::mutex> lock(addressMapMutex);
-	auto it = addressMap.find(key);
-	if(it == addressMap.end())
-	{
-		MapValue mv;
-		mv.refCount = 1;
-		mv.address = value;
-		addressMap[key] = mv;
-	}
-	else
-	{
-		it->second.address = value;
-		it->second.refCount++;
-	}
-}
-
-int Device::AHBAddressMap::incrementReference(const uint32_t key)
-{
-	std::unique_lock<std::mutex> lock(addressMapMutex);
-	auto it = addressMap.find(key);
-	if(it == addressMap.end())
-		return -1;
-
-	it->second.refCount++;
-	return it->second.refCount;
-}
-
-int Device::AHBAddressMap::decrementReference(const uint32_t key)
-{
-	std::unique_lock<std::mutex> lock(addressMapMutex);
-	auto it = addressMap.find(key);
-	if(it == addressMap.end())
-		return -1;
-
-	it->second.refCount--;
-	return it->second.refCount;
-}
-#endif  // SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
-
 }  // namespace vk
diff --git a/src/Vulkan/VkDevice.hpp b/src/Vulkan/VkDevice.hpp
index 9fce601..7f67ffa 100644
--- a/src/Vulkan/VkDevice.hpp
+++ b/src/Vulkan/VkDevice.hpp
@@ -193,41 +193,6 @@
 		std::shared_ptr<vk::dbg::Server> server;
 	} debugger;
 #endif  // ENABLE_VK_DEBUGGER
-
-#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
-public:
-	class AHBAddressMap
-	{
-	public:
-		AHBAddressMap() {}
-		~AHBAddressMap() {}
-
-		struct MapValue
-		{
-			MapValue()
-			    : refCount(0)
-			    , address(nullptr)
-			{
-			}
-			int refCount;
-			void *address;
-		};
-
-		void *query(const uint32_t key);
-		int incrementReference(const uint32_t key);
-		int decrementReference(const uint32_t key);
-		void add(const uint32_t key, void *value);
-
-	private:
-		std::map<uint32_t, MapValue> addressMap;
-		std::mutex addressMapMutex;
-	};
-
-	AHBAddressMap *getAHBAddressMap() const;
-
-private:
-	std::unique_ptr<AHBAddressMap> ahbAddressMap;
-#endif
 };
 
 using DispatchableDevice = DispatchableObject<Device, VkDevice>;
diff --git a/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp b/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp
index 8890829..80e3250 100644
--- a/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp
+++ b/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp
@@ -16,159 +16,19 @@
 
 #	include "VkDeviceMemoryExternalAndroid.hpp"
 
+#	include "System/Debug.hpp"
 #	include "VkDestroy.hpp"
-#	include "VkDevice.hpp"
 #	include "VkFormat.hpp"
 #	include "VkObject.hpp"
 #	include "VkPhysicalDevice.hpp"
-
-#	include "System/Debug.hpp"
-#	include "System/Linux/MemFd.hpp"
-#	include <sys/mman.h>
+#	include "VkStringify.hpp"
 
 #	include <android/hardware_buffer.h>
-#	include <cutils/native_handle.h>
 #	include <vndk/hardware_buffer.h>
 
-#	include <cros_gralloc/cros_gralloc_handle.h>
-#	include <external/virgl_hw.h>
-#	include <unistd.h>
-#	include <virtgpu_drm.h>
-#	include <xf86drm.h>
+namespace {
 
-AHardwareBufferExternalMemory::~AHardwareBufferExternalMemory()
-{
-	// correct deallocation of AHB does not require a pointer or size
-	deallocate(nullptr, 0);
-}
-
-VkResult AHardwareBufferExternalMemory::allocate(size_t size, void **pBuffer)
-{
-	if(allocateInfo.importAhb)
-	{
-		ahb = allocateInfo.ahb;
-		AHardwareBuffer_acquire(ahb);
-		return allocateAndroidHardwareBuffer(size, pBuffer);
-	}
-	else
-	{
-		ASSERT(allocateInfo.exportAhb);
-
-		// Outline ahbDesc
-		AHardwareBuffer_Desc ahbDesc;
-		if(allocateInfo.imageHandle)
-		{
-			ahbDesc.format = GetAndroidHardwareBufferDescFormat(VkFormat(allocateInfo.imageHandle->getFormat()));
-			VkExtent3D extent = allocateInfo.imageHandle->getMipLevelExtent(VK_IMAGE_ASPECT_COLOR_BIT, 0);
-			ahbDesc.width = extent.width;
-			ahbDesc.height = extent.height;
-			ahbDesc.layers = allocateInfo.imageHandle->getArrayLayers();
-			ahbDesc.stride = allocateInfo.imageHandle->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0);
-
-			VkImageCreateFlags createFlags = allocateInfo.imageHandle->getFlags();
-			VkImageUsageFlags usageFlags = allocateInfo.imageHandle->getUsage();
-			GetAndroidHardwareBufferUsageFromVkUsage(createFlags, usageFlags, ahbDesc.usage);
-		}
-		else
-		{
-			ASSERT(allocateInfo.bufferHandle);
-			ahbDesc.format = AHARDWAREBUFFER_FORMAT_BLOB;
-			ahbDesc.width = uint32_t(allocateInfo.bufferHandle->getSize());
-			ahbDesc.height = 1;
-			ahbDesc.layers = 1;
-			ahbDesc.stride = uint32_t(allocateInfo.bufferHandle->getSize());
-			// TODO(b/141698760)
-			//   This will be fairly specific, needs fleshing out
-			ahbDesc.usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
-		}
-
-		// create a new ahb from desc
-		if(AHardwareBuffer_allocate(&ahbDesc, &ahb) != 0)
-		{
-			return VK_ERROR_OUT_OF_HOST_MEMORY;
-		}
-
-		return allocateAndroidHardwareBuffer(size, pBuffer);
-	}
-}
-
-VkResult AHardwareBufferExternalMemory::allocateAndroidHardwareBuffer(size_t size, void **pBuffer)
-{
-	// get native_handle_t from ahb
-	const native_handle_t *h = AHardwareBuffer_getNativeHandle(ahb);
-	if(h == nullptr)
-	{
-		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
-	}
-
-	// get rendernodeFD and primeHandle from native_handle_t.data
-	uint32_t primeHandle;
-	createRenderNodeFD();
-	VkResult result = getPrimeHandle(h, primeHandle);
-	if(result != VK_SUCCESS)
-	{
-		return result;
-	}
-
-	// get memory pointer from store or mmap it
-	vk::Device::AHBAddressMap *pDeviceHandleMap = device->getAHBAddressMap();
-	void *pAddress = pDeviceHandleMap->query(primeHandle);
-	if(pAddress != nullptr)
-	{
-		*pBuffer = pAddress;
-		pDeviceHandleMap->incrementReference(primeHandle);
-	}
-	else
-	{
-		// map memory
-		void *ptr;
-		VkResult result = mapMemory(primeHandle, &ptr);
-		if(result != VK_SUCCESS)
-		{
-			return result;
-		}
-
-		// Add primeHandle and ptr to deviceHandleMap
-		pDeviceHandleMap->add(primeHandle, ptr);
-		*pBuffer = pDeviceHandleMap->query(primeHandle);
-	}
-
-	return VK_SUCCESS;
-}
-
-void AHardwareBufferExternalMemory::deallocate(void *buffer, size_t size)
-{
-	if(ahb != nullptr)
-	{
-		const native_handle_t *h = AHardwareBuffer_getNativeHandle(ahb);
-		uint32_t primeHandle;
-		VkResult result = getPrimeHandle(h, primeHandle);
-		ASSERT(result == VK_SUCCESS);
-
-		// close gpu memory and rendernodeFD
-		vk::Device::AHBAddressMap *pDeviceHandleMap = device->getAHBAddressMap();
-		if(pDeviceHandleMap->decrementReference(primeHandle) == 0)
-		{
-			closeMemory(primeHandle);
-		}
-		close(rendernodeFD);
-
-		AHardwareBuffer_release(ahb);
-		ahb = nullptr;
-	}
-}
-
-VkResult AHardwareBufferExternalMemory::exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const
-{
-	// Each call to vkGetMemoryAndroidHardwareBufferANDROID *must* return an Android hardware buffer with a new reference
-	// acquired in addition to the reference held by the VkDeviceMemory. To avoid leaking resources, the application *must*
-	// release the reference by calling AHardwareBuffer_release when it is no longer needed.
-	AHardwareBuffer_acquire(ahb);
-	*pAhb = ahb;
-	return VK_SUCCESS;
-}
-
-uint32_t AHardwareBufferExternalMemory::GetAndroidHardwareBufferDescFormat(VkFormat format)
+uint32_t GetAHBFormatFromVkFormat(VkFormat format)
 {
 	switch(format)
 	{
@@ -204,7 +64,7 @@
 	}
 }
 
-VkFormat AHardwareBufferExternalMemory::GetVkFormat(uint32_t ahbFormat)
+VkFormat GetVkFormatFromAHBFormat(uint32_t ahbFormat)
 {
 	switch(ahbFormat)
 	{
@@ -244,8 +104,94 @@
 	}
 }
 
-VkFormatFeatureFlags AHardwareBufferExternalMemory::GetVkFormatFeatures(VkFormat format)
+uint64_t GetAHBLockUsageFromVkImageUsageFlags(VkImageUsageFlags flags)
 {
+	uint64_t usage = 0;
+
+	if(flags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT ||
+	   flags & VK_IMAGE_USAGE_SAMPLED_BIT ||
+	   flags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
+	{
+		usage |= AHARDWAREBUFFER_USAGE_CPU_READ_MASK;
+	}
+
+	if(flags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT ||
+	   flags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
+	{
+		usage |= AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK;
+	}
+
+	return usage;
+}
+
+uint64_t GetAHBLockUsageFromVkBufferUsageFlags(VkBufferUsageFlags flags)
+{
+	uint64_t usage = 0;
+
+	if(flags & VK_BUFFER_USAGE_TRANSFER_SRC_BIT)
+	{
+		usage |= AHARDWAREBUFFER_USAGE_CPU_READ_MASK;
+	}
+
+	if(flags & VK_BUFFER_USAGE_TRANSFER_DST_BIT)
+	{
+		usage |= AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK;
+	}
+
+	return usage;
+}
+
+uint64_t GetAHBUsageFromVkImageFlags(VkImageCreateFlags createFlags, VkImageUsageFlags usageFlags)
+{
+	uint64_t ahbUsage = 0;
+
+	if(usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT)
+	{
+		ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN;
+	}
+	if(usageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
+	{
+		ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN;
+	}
+	if(usageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
+	{
+		ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
+	}
+
+	if(createFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
+	{
+		ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
+	}
+	if(createFlags & VK_IMAGE_CREATE_PROTECTED_BIT)
+	{
+		ahbUsage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
+	}
+
+	// No usage bits set - set at least one GPU usage
+	if(ahbUsage == 0)
+	{
+		ahbUsage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+		           AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
+	}
+
+	return ahbUsage;
+}
+
+uint64_t GetAHBUsageFromVkBufferFlags(VkBufferCreateFlags /*createFlags*/, VkBufferUsageFlags /*usageFlags*/)
+{
+	uint64_t ahbUsage = 0;
+
+	// TODO(b/141698760): needs fleshing out.
+	ahbUsage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN;
+
+	return ahbUsage;
+}
+
+VkFormatFeatureFlags GetVkFormatFeaturesFromAHBFormat(uint32_t ahbFormat)
+{
+	VkFormatFeatureFlags features = 0;
+
+	VkFormat format = GetVkFormatFromAHBFormat(ahbFormat);
 	VkFormatProperties formatProperties;
 	vk::PhysicalDevice::GetFormatProperties(vk::Format(format), &formatProperties);
 
@@ -254,148 +200,14 @@
 	// TODO: b/167896057
 	//   The correct formatFeatureFlags depends on consumer and format
 	//   So this solution is incomplete without more information
-	return formatProperties.linearTilingFeatures | formatProperties.optimalTilingFeatures | formatProperties.bufferFeatures;
+	features |= formatProperties.linearTilingFeatures |
+	            formatProperties.optimalTilingFeatures |
+	            formatProperties.bufferFeatures;
+
+	return features;
 }
 
-VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferFormatProperties(const AHardwareBuffer_Desc &ahbDesc, VkAndroidHardwareBufferFormatPropertiesANDROID *pFormat)
-{
-
-	pFormat->sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
-	pFormat->pNext = nullptr;
-
-	pFormat->format = GetVkFormat(ahbDesc.format);
-	pFormat->externalFormat = ahbDesc.format;
-	pFormat->formatFeatures = GetVkFormatFeatures(pFormat->format);
-
-	pFormat->samplerYcbcrConversionComponents = { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY };
-	pFormat->suggestedYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
-	pFormat->suggestedYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
-	pFormat->suggestedXChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
-	pFormat->suggestedYChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
-
-	return VK_SUCCESS;
-}
-
-VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
-{
-	AHardwareBuffer_Desc ahbDesc;
-	AHardwareBuffer_describe(buffer, &ahbDesc);
-
-	GetAndroidHardwareBufferFormatProperties(ahbDesc, (VkAndroidHardwareBufferFormatPropertiesANDROID *)pProperties->pNext);
-
-	const VkPhysicalDeviceMemoryProperties phyDeviceMemProps = vk::PhysicalDevice::GetMemoryProperties();
-	pProperties->memoryTypeBits = phyDeviceMemProps.memoryTypes[0].propertyFlags;
-
-	if(ahbDesc.format == AHARDWAREBUFFER_FORMAT_BLOB)
-	{
-		pProperties->allocationSize = ahbDesc.width;
-	}
-	else
-	{
-		VkImageCreateInfo info = {};
-		info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
-		info.pNext = nullptr;
-		info.flags = 0;
-		info.imageType = VK_IMAGE_TYPE_2D;
-		info.format = GetVkFormat(ahbDesc.format);
-		info.extent.width = ahbDesc.width;
-		info.extent.height = ahbDesc.height;
-		info.extent.depth = 1;
-		info.mipLevels = 1;
-		info.arrayLayers = 1;
-		info.samples = VK_SAMPLE_COUNT_1_BIT;
-		info.tiling = VK_IMAGE_TILING_OPTIMAL;
-		info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
-
-		VkImage Image;
-		VkResult result = vk::Image::Create(vk::DEVICE_MEMORY, &info, &Image, vk::Cast(device));
-
-		pProperties->allocationSize = vk::Cast(Image)->getMemoryRequirements().size;
-		vk::destroy(Image, vk::DEVICE_MEMORY);
-	}
-
-	return VK_SUCCESS;
-}
-
-VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags createFlags, const VkImageUsageFlags usageFlags, uint64_t &ahbDescUsage)
-{
-	if(usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT)
-		ahbDescUsage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-	if(usageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
-		ahbDescUsage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-	if(usageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
-		ahbDescUsage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
-
-	if(createFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
-		ahbDescUsage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
-	if(createFlags & VK_IMAGE_CREATE_PROTECTED_BIT)
-		ahbDescUsage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
-
-	// No usage bits set - set at least one GPU usage
-	if(ahbDescUsage == 0)
-		ahbDescUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
-
-	return VK_SUCCESS;
-}
-
-// Call into the native gralloc implementation to request a handle for the
-// rendernodeFD
-VkResult AHardwareBufferExternalMemory::getPrimeHandle(const native_handle_t *h, uint32_t &primeHandle)
-{
-	cros_gralloc_handle const *crosHandle = reinterpret_cast<cros_gralloc_handle const *>(h);
-	int ret = drmPrimeFDToHandle(rendernodeFD, crosHandle->fds[0], &primeHandle);
-	if(ret != 0)
-	{
-		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
-	}
-
-	return VK_SUCCESS;
-}
-
-// Create a rendernodeFD
-void AHardwareBufferExternalMemory::createRenderNodeFD()
-{
-	rendernodeFD = drmOpenRender(128);
-}
-
-// using a primeHandle associated with a specific rendernodeFD, map a new block
-// of memory
-VkResult AHardwareBufferExternalMemory::mapMemory(uint32_t &primeHandle, void **ptr)
-{
-	drm_virtgpu_map map;
-	memset(&map, 0, sizeof(drm_virtgpu_map));
-	map.handle = primeHandle;
-	int ret = drmIoctl(rendernodeFD, DRM_IOCTL_VIRTGPU_MAP, &map);
-	if(ret != 0)
-	{
-		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
-	}
-
-	// mmap it
-	*ptr = static_cast<unsigned char *>(
-	    mmap64(nullptr, 4096, PROT_WRITE, MAP_SHARED, rendernodeFD, map.offset));
-	if(ptr == MAP_FAILED)
-	{
-		return VK_ERROR_MEMORY_MAP_FAILED;
-	}
-
-	return VK_SUCCESS;
-}
-
-// Close out the memory block associated with rendernodeFD
-VkResult AHardwareBufferExternalMemory::closeMemory(uint32_t &primeHandle)
-{
-	struct drm_gem_close gem_close;
-	memset(&gem_close, 0x0, sizeof(gem_close));
-	gem_close.handle = primeHandle;
-	int ret = drmIoctl(rendernodeFD, DRM_IOCTL_GEM_CLOSE, &gem_close);
-	if(ret != 0)
-	{
-		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
-	}
-
-	return VK_SUCCESS;
-}
+}  // namespace
 
 AHardwareBufferExternalMemory::AllocateInfo::AllocateInfo(const VkMemoryAllocateInfo *pAllocateInfo)
 {
@@ -415,11 +227,14 @@
 			{
 				const auto *exportInfo = reinterpret_cast<const VkExportMemoryAllocateInfo *>(createInfo);
 
-				if(exportInfo->handleTypes != VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
+				if(exportInfo->handleTypes == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
+				{
+					exportAhb = true;
+				}
+				else
 				{
 					UNSUPPORTED("VkExportMemoryAllocateInfo::handleTypes %d", int(exportInfo->handleTypes));
 				}
-				exportAhb = true;
 			}
 			break;
 			case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
@@ -439,4 +254,208 @@
 	}
 }
 
+AHardwareBufferExternalMemory::AHardwareBufferExternalMemory(const VkMemoryAllocateInfo *pAllocateInfo)
+    : allocateInfo(pAllocateInfo)
+{
+}
+
+AHardwareBufferExternalMemory::~AHardwareBufferExternalMemory()
+{
+	// correct deallocation of AHB does not require a pointer or size
+	deallocate(nullptr, 0);
+}
+
+// VkAllocateMemory
+VkResult AHardwareBufferExternalMemory::allocate(size_t /*size*/, void **pBuffer)
+{
+	if(allocateInfo.importAhb)
+	{
+		return importAndroidHardwareBuffer(allocateInfo.ahb, pBuffer);
+	}
+	else
+	{
+		ASSERT(allocateInfo.exportAhb);
+		return allocateAndroidHardwareBuffer(pBuffer);
+	}
+}
+
+void AHardwareBufferExternalMemory::deallocate(void *buffer, size_t size)
+{
+	if(ahb != nullptr)
+	{
+		unlockAndroidHardwareBuffer();
+
+		AHardwareBuffer_release(ahb);
+		ahb = nullptr;
+	}
+}
+
+VkResult AHardwareBufferExternalMemory::importAndroidHardwareBuffer(struct AHardwareBuffer *buffer, void **pBuffer)
+{
+	ahb = buffer;
+
+	AHardwareBuffer_acquire(ahb);
+
+	return lockAndroidHardwareBuffer(pBuffer);
+}
+
+VkResult AHardwareBufferExternalMemory::allocateAndroidHardwareBuffer(void **pBuffer)
+{
+	AHardwareBuffer_Desc desc = {};
+
+	if(allocateInfo.imageHandle)
+	{
+		vk::Image *image = allocateInfo.imageHandle;
+		ASSERT(image != nullptr);
+		ASSERT(image->getArrayLayers() == 1);
+
+		VkExtent3D extent = image->getExtent();
+
+		desc.width = extent.width;
+		desc.height = extent.height;
+		desc.layers = image->getArrayLayers();
+		desc.format = GetAHBFormatFromVkFormat(image->getFormat());
+		desc.usage = GetAHBUsageFromVkImageFlags(image->getFlags(), image->getUsage());
+	}
+	else
+	{
+		vk::Buffer *buffer = allocateInfo.bufferHandle;
+		ASSERT(buffer != nullptr);
+
+		desc.width = static_cast<uint32_t>(buffer->getSize());
+		desc.height = 1;
+		desc.layers = 1;
+		desc.format = AHARDWAREBUFFER_FORMAT_BLOB;
+		desc.usage = GetAHBUsageFromVkBufferFlags(buffer->getFlags(), buffer->getUsage());
+	}
+
+	// create a new ahb from desc
+	int ret = AHardwareBuffer_allocate(&desc, &ahb);
+	if(ret != 0)
+	{
+		return VK_ERROR_OUT_OF_HOST_MEMORY;
+	}
+
+	return lockAndroidHardwareBuffer(pBuffer);
+}
+
+VkResult AHardwareBufferExternalMemory::lockAndroidHardwareBuffer(void **pBuffer)
+{
+	uint64_t usage = 0;
+	if(allocateInfo.imageHandle)
+	{
+		usage = GetAHBLockUsageFromVkImageUsageFlags(allocateInfo.imageHandle->getUsage());
+	}
+	else
+	{
+		usage = GetAHBLockUsageFromVkBufferUsageFlags(allocateInfo.bufferHandle->getUsage());
+	}
+
+	// Empty fence, lock immedietly.
+	int32_t fence = -1;
+
+	// Empty rect, lock entire buffer.
+	ARect *rect = nullptr;
+
+	int ret = AHardwareBuffer_lock(ahb, usage, fence, rect, pBuffer);
+	if(ret != 0)
+	{
+		return VK_ERROR_OUT_OF_HOST_MEMORY;
+	}
+
+	return VK_SUCCESS;
+}
+
+VkResult AHardwareBufferExternalMemory::unlockAndroidHardwareBuffer()
+{
+	int ret = AHardwareBuffer_unlock(ahb, /*fence=*/nullptr);
+	if(ret != 0)
+	{
+		return VK_ERROR_UNKNOWN;
+	}
+
+	return VK_SUCCESS;
+}
+
+VkResult AHardwareBufferExternalMemory::exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const
+{
+	// Each call to vkGetMemoryAndroidHardwareBufferANDROID *must* return an Android hardware buffer with a new reference
+	// acquired in addition to the reference held by the VkDeviceMemory. To avoid leaking resources, the application *must*
+	// release the reference by calling AHardwareBuffer_release when it is no longer needed.
+	AHardwareBuffer_acquire(ahb);
+	*pAhb = ahb;
+	return VK_SUCCESS;
+}
+
+VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferFormatProperties(const AHardwareBuffer_Desc &ahbDesc, VkAndroidHardwareBufferFormatPropertiesANDROID *pFormat)
+{
+	pFormat->sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
+	pFormat->pNext = nullptr;
+	pFormat->format = GetVkFormatFromAHBFormat(ahbDesc.format);
+	pFormat->externalFormat = ahbDesc.format;
+	pFormat->formatFeatures = GetVkFormatFeaturesFromAHBFormat(ahbDesc.format);
+	pFormat->samplerYcbcrConversionComponents = { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY };
+	pFormat->suggestedYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+	pFormat->suggestedYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
+	pFormat->suggestedXChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
+	pFormat->suggestedYChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
+
+	return VK_SUCCESS;
+}
+
+VkResult AHardwareBufferExternalMemory::GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
+{
+	VkResult result = VK_SUCCESS;
+
+	AHardwareBuffer_Desc ahbDesc;
+	AHardwareBuffer_describe(buffer, &ahbDesc);
+
+	if(pProperties->pNext != nullptr)
+	{
+		result = GetAndroidHardwareBufferFormatProperties(ahbDesc, (VkAndroidHardwareBufferFormatPropertiesANDROID *)pProperties->pNext);
+		if(result != VK_SUCCESS)
+		{
+			return result;
+		}
+	}
+
+	const VkPhysicalDeviceMemoryProperties phyDeviceMemProps = vk::PhysicalDevice::GetMemoryProperties();
+	pProperties->memoryTypeBits = phyDeviceMemProps.memoryTypes[0].propertyFlags;
+
+	if(ahbDesc.format == AHARDWAREBUFFER_FORMAT_BLOB)
+	{
+		pProperties->allocationSize = ahbDesc.width;
+	}
+	else
+	{
+		VkImageCreateInfo info = {};
+		info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
+		info.pNext = nullptr;
+		info.flags = 0;
+		info.imageType = VK_IMAGE_TYPE_2D;
+		info.format = GetVkFormatFromAHBFormat(ahbDesc.format);
+		info.extent.width = ahbDesc.width;
+		info.extent.height = ahbDesc.height;
+		info.extent.depth = 1;
+		info.mipLevels = 1;
+		info.arrayLayers = 1;
+		info.samples = VK_SAMPLE_COUNT_1_BIT;
+		info.tiling = VK_IMAGE_TILING_OPTIMAL;
+		info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+
+		VkImage Image;
+
+		result = vk::Image::Create(vk::DEVICE_MEMORY, &info, &Image, vk::Cast(device));
+		if(result != VK_SUCCESS)
+		{
+			return result;
+		}
+
+		pProperties->allocationSize = vk::Cast(Image)->getMemoryRequirements().size;
+		vk::destroy(Image, vk::DEVICE_MEMORY);
+	}
+
+	return result;
+}
+
 #endif  // SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
diff --git a/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp b/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp
index 6292af5..9931daf 100644
--- a/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp
+++ b/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp
@@ -17,29 +17,14 @@
 
 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
 
+#	include "VkBuffer.hpp"
 #	include "VkDevice.hpp"
 #	include "VkDeviceMemory.hpp"
 #	include "VkDeviceMemoryExternalBase.hpp"
-
-#	include "VkBuffer.hpp"
-#	include "VkDeviceMemory.hpp"
 #	include "VkImage.hpp"
-#	include "VkStringify.hpp"
-
-#	include "System/Debug.hpp"
-#	include "System/Linux/MemFd.hpp"
 
 #	include <android/hardware_buffer.h>
 
-#	include <cros_gralloc/cros_gralloc_handle.h>
-#	include <unistd.h>
-#	include <virtgpu_drm.h>
-#	include <xf86drm.h>
-
-#	include <errno.h>
-#	include <string.h>
-#	include <map>
-
 class AHardwareBufferExternalMemory : public vk::DeviceMemory::ExternalBase
 {
 public:
@@ -68,49 +53,29 @@
 		return (info.importAhb || info.exportAhb) && (info.bufferHandle || info.imageHandle);
 	}
 
-	explicit AHardwareBufferExternalMemory(const VkMemoryAllocateInfo *pAllocateInfo)
-	    : allocateInfo(pAllocateInfo)
-	{
-	}
-
+	explicit AHardwareBufferExternalMemory(const VkMemoryAllocateInfo *pAllocateInfo);
 	~AHardwareBufferExternalMemory();
+
 	VkResult allocate(size_t size, void **pBuffer) override;
 	void deallocate(void *buffer, size_t size) override;
-	VkResult allocateAndroidHardwareBuffer(size_t size, void **pBuffer);
 
-	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override
-	{
-		return typeFlagBit;
-	}
+	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override { return typeFlagBit; }
 
 	VkResult exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const override;
 
-	void setDevicePtr(vk::Device *pDevice) override
-	{
-		device = pDevice;
-	}
+	void setDevicePtr(vk::Device *pDevice) override { device = pDevice; }
+	bool isAndroidHardwareBuffer() override { return true; }
 
-	bool isAndroidHardwareBuffer() override
-	{
-		return true;
-	}
-
-	static uint32_t GetAndroidHardwareBufferDescFormat(VkFormat format);
-	static VkFormat GetVkFormat(uint32_t ahbFormat);
-	static VkFormatFeatureFlags GetVkFormatFeatures(VkFormat format);
 	static VkResult GetAndroidHardwareBufferFormatProperties(const AHardwareBuffer_Desc &ahbDesc, VkAndroidHardwareBufferFormatPropertiesANDROID *pFormat);
 	static VkResult GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties);
-	static VkResult GetAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags createFlags, const VkImageUsageFlags usageFlags, uint64_t &ahbDescUsage);
-
-	// All reliance on minigbm and DRM is contained in these functions
-	VkResult getPrimeHandle(const native_handle_t *h, uint32_t &primeHandle);
-	void createRenderNodeFD();
-	VkResult mapMemory(uint32_t &primeHandle, void **ptr);
-	VkResult closeMemory(uint32_t &primeHandle);
 
 private:
+	VkResult importAndroidHardwareBuffer(struct AHardwareBuffer *buffer, void **pBuffer);
+	VkResult allocateAndroidHardwareBuffer(void **pBuffer);
+	VkResult lockAndroidHardwareBuffer(void **pBuffer);
+	VkResult unlockAndroidHardwareBuffer();
+
 	struct AHardwareBuffer *ahb = nullptr;
-	int rendernodeFD;
 	vk::Device *device = nullptr;
 	AllocateInfo allocateInfo;
 };
diff --git a/src/Vulkan/libVulkan.cpp b/src/Vulkan/libVulkan.cpp
index 97abeab..41977fd 100644
--- a/src/Vulkan/libVulkan.cpp
+++ b/src/Vulkan/libVulkan.cpp
@@ -529,108 +529,24 @@
 	TRACE("(VkPhysicalDevice physicalDevice = %p, VkFormat format = %d, VkImageType type = %d, VkImageTiling tiling = %d, VkImageUsageFlags usage = %d, VkImageCreateFlags flags = %d, VkImageFormatProperties* pImageFormatProperties = %p)",
 	      physicalDevice, (int)format, (int)type, (int)tiling, usage, flags, pImageFormatProperties);
 
-	// "If the combination of parameters to vkGetPhysicalDeviceImageFormatProperties is not supported by the implementation
-	//  for use in vkCreateImage, then all members of VkImageFormatProperties will be filled with zero."
-	memset(pImageFormatProperties, 0, sizeof(VkImageFormatProperties));
+	VkPhysicalDeviceImageFormatInfo2 info2 = {};
+	info2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
+	info2.pNext = nullptr;
+	info2.format = format;
+	info2.type = type;
+	info2.tiling = tiling;
+	info2.usage = usage;
+	info2.flags = flags;
 
-	VkFormatProperties properties;
-	vk::PhysicalDevice::GetFormatProperties(format, &properties);
+	VkImageFormatProperties2 properties2 = {};
+	properties2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+	properties2.pNext = nullptr;
 
-	VkFormatFeatureFlags features;
-	switch(tiling)
-	{
-		case VK_IMAGE_TILING_LINEAR:
-			features = properties.linearTilingFeatures;
-			break;
+	VkResult result = vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, &info2, &properties2);
 
-		case VK_IMAGE_TILING_OPTIMAL:
-			features = properties.optimalTilingFeatures;
-			break;
+	*pImageFormatProperties = properties2.imageFormatProperties;
 
-		default:
-			UNSUPPORTED("VkImageTiling %d", int(tiling));
-			features = 0;
-	}
-
-	if(features == 0)
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	// Check for usage conflict with features
-	if((usage & VK_IMAGE_USAGE_SAMPLED_BIT) && !(features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	if((usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	if((usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && !(features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	if((usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	if((usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) && !(features & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	if((usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) && !(features & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	if((usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) && !(features & VK_FORMAT_FEATURE_TRANSFER_DST_BIT))
-	{
-		return VK_ERROR_FORMAT_NOT_SUPPORTED;
-	}
-
-	auto allRecognizedUsageBits = VK_IMAGE_USAGE_SAMPLED_BIT |
-	                              VK_IMAGE_USAGE_STORAGE_BIT |
-	                              VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-	                              VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
-	                              VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
-	                              VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
-	                              VK_IMAGE_USAGE_TRANSFER_DST_BIT |
-	                              VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
-	ASSERT(!(usage & ~(allRecognizedUsageBits)));
-
-	// "Images created with tiling equal to VK_IMAGE_TILING_LINEAR have further restrictions on their limits and capabilities
-	//  compared to images created with tiling equal to VK_IMAGE_TILING_OPTIMAL."
-	if(tiling == VK_IMAGE_TILING_LINEAR)
-	{
-		if(type != VK_IMAGE_TYPE_2D)
-		{
-			return VK_ERROR_FORMAT_NOT_SUPPORTED;
-		}
-
-		if(vk::Format(format).isDepth() || vk::Format(format).isStencil())
-		{
-			return VK_ERROR_FORMAT_NOT_SUPPORTED;
-		}
-	}
-
-	// "Images created with a format from one of those listed in Formats requiring sampler Y'CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
-	//  have further restrictions on their limits and capabilities compared to images created with other formats."
-	if(vk::Format(format).isYcbcrFormat())
-	{
-		if(type != VK_IMAGE_TYPE_2D)
-		{
-			return VK_ERROR_FORMAT_NOT_SUPPORTED;
-		}
-	}
-
-	vk::Cast(physicalDevice)->getImageFormatProperties(format, type, tiling, usage, flags, pImageFormatProperties);
-
-	return VK_SUCCESS;
+	return result;
 }
 
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
@@ -3044,6 +2960,10 @@
 	TRACE("(VkPhysicalDevice physicalDevice = %p, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo = %p, VkImageFormatProperties2* pImageFormatProperties = %p)",
 	      physicalDevice, pImageFormatInfo, pImageFormatProperties);
 
+	// "If the combination of parameters to vkGetPhysicalDeviceImageFormatProperties is not supported by the implementation
+	//  for use in vkCreateImage, then all members of VkImageFormatProperties will be filled with zero."
+	memset(&pImageFormatProperties->imageFormatProperties, 0, sizeof(VkImageFormatProperties));
+
 	const VkBaseInStructure *extensionFormatInfo = reinterpret_cast<const VkBaseInStructure *>(pImageFormatInfo->pNext);
 
 	const VkExternalMemoryHandleTypeFlagBits *handleType = nullptr;
@@ -3085,6 +3005,10 @@
 
 	VkBaseOutStructure *extensionProperties = reinterpret_cast<VkBaseOutStructure *>(pImageFormatProperties->pNext);
 
+#ifdef __ANDROID__
+	bool hasAHBUsage = false;
+#endif
+
 	while(extensionProperties)
 	{
 		switch(extensionProperties->sType)
@@ -3112,6 +3036,7 @@
 			{
 				auto properties = reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>(extensionProperties);
 				vk::Cast(physicalDevice)->getProperties(properties);
+				hasAHBUsage = true;
 			}
 			break;
 #endif
@@ -3123,13 +3048,119 @@
 		extensionProperties = extensionProperties->pNext;
 	}
 
-	return vkGetPhysicalDeviceImageFormatProperties(physicalDevice,
-	                                                pImageFormatInfo->format,
-	                                                pImageFormatInfo->type,
-	                                                pImageFormatInfo->tiling,
-	                                                pImageFormatInfo->usage,
-	                                                pImageFormatInfo->flags,
-	                                                &(pImageFormatProperties->imageFormatProperties));
+	VkFormat format = pImageFormatInfo->format;
+	VkImageType type = pImageFormatInfo->type;
+	VkImageTiling tiling = pImageFormatInfo->tiling;
+	VkImageUsageFlags usage = pImageFormatInfo->usage;
+	VkImageCreateFlags flags = pImageFormatInfo->flags;
+
+	VkFormatProperties properties;
+	vk::PhysicalDevice::GetFormatProperties(format, &properties);
+
+	VkFormatFeatureFlags features;
+	switch(tiling)
+	{
+		case VK_IMAGE_TILING_LINEAR:
+			features = properties.linearTilingFeatures;
+			break;
+
+		case VK_IMAGE_TILING_OPTIMAL:
+			features = properties.optimalTilingFeatures;
+			break;
+
+		default:
+			UNSUPPORTED("VkImageTiling %d", int(tiling));
+			features = 0;
+	}
+
+	if(features == 0)
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	// Check for usage conflict with features
+	if((usage & VK_IMAGE_USAGE_SAMPLED_BIT) && !(features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	if((usage & VK_IMAGE_USAGE_STORAGE_BIT) && !(features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	if((usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && !(features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	if((usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	if((usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) && !(features & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	if((usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) && !(features & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	if((usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) && !(features & VK_FORMAT_FEATURE_TRANSFER_DST_BIT))
+	{
+		return VK_ERROR_FORMAT_NOT_SUPPORTED;
+	}
+
+	auto allRecognizedUsageBits = VK_IMAGE_USAGE_SAMPLED_BIT |
+	                              VK_IMAGE_USAGE_STORAGE_BIT |
+	                              VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+	                              VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT |
+	                              VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
+	                              VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
+	                              VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+	                              VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
+	ASSERT(!(usage & ~(allRecognizedUsageBits)));
+
+	// "Images created with tiling equal to VK_IMAGE_TILING_LINEAR have further restrictions on their limits and capabilities
+	//  compared to images created with tiling equal to VK_IMAGE_TILING_OPTIMAL."
+	if(tiling == VK_IMAGE_TILING_LINEAR)
+	{
+		if(type != VK_IMAGE_TYPE_2D)
+		{
+			return VK_ERROR_FORMAT_NOT_SUPPORTED;
+		}
+
+		if(vk::Format(format).isDepth() || vk::Format(format).isStencil())
+		{
+			return VK_ERROR_FORMAT_NOT_SUPPORTED;
+		}
+	}
+
+	// "Images created with a format from one of those listed in Formats requiring sampler Y'CBCR conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
+	//  have further restrictions on their limits and capabilities compared to images created with other formats."
+	if(vk::Format(format).isYcbcrFormat())
+	{
+		if(type != VK_IMAGE_TYPE_2D)
+		{
+			return VK_ERROR_FORMAT_NOT_SUPPORTED;
+		}
+	}
+
+	vk::Cast(physicalDevice)->getImageFormatProperties(format, type, tiling, usage, flags, &pImageFormatProperties->imageFormatProperties);
+
+#ifdef __ANDROID__
+	if(hasAHBUsage)
+	{
+		// AHardwareBuffer_lock may only be called with a single layer.
+		pImageFormatProperties->imageFormatProperties.maxArrayLayers = 1;
+		pImageFormatProperties->imageFormatProperties.maxMipLevels = 1;
+	}
+#endif
+
+	return VK_SUCCESS;
 }
 
 VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2 *pQueueFamilyProperties)