tests/VkYcbcrSamplerTest.cpp - platform/external/skia - Gitiles

 /*
  * Copyright 2019 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "include/core/SkTypes.h"

 #if SK_SUPPORT_GPU && defined(SK_VULKAN)

 #include "include/core/SkImage.h"
 #include "include/core/SkSurface.h"
 #include "include/gpu/GrContext.h"
 #include "include/gpu/vk/GrVkBackendContext.h"
 #include "include/gpu/vk/GrVkExtensions.h"
 #include "tests/Test.h"
 #include "tools/gpu/vk/VkTestUtils.h"

 const size_t kImageWidth = 8;
 const size_t kImageHeight = 8;

 static int getY(size_t x, size_t y) {
     return 16 + (x + y) * 219 / (kImageWidth + kImageHeight - 2);
 }
 static int getU(size_t x, size_t y) { return 16 + x * 224 / (kImageWidth - 1); }
 static int getV(size_t x, size_t y) { return 16 + y * 224 / (kImageHeight - 1); }

 #define DECLARE_VK_PROC(name) PFN_vk##name fVk##name

 #define ACQUIRE_INST_VK_PROC(name)                                                           \
     fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, fBackendContext.fInstance,\
                                                        VK_NULL_HANDLE));                     \
     if (fVk##name == nullptr) {                                                              \
         ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);            \
         return false;                                                                        \
     }

 #define ACQUIRE_DEVICE_VK_PROC(name)                                                          \
     fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, VK_NULL_HANDLE, fDevice)); \
     if (fVk##name == nullptr) {                                                               \
         ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name);             \
         return false;                                                                         \
     }

 class VkYcbcrSamplerTestHelper {
 public:
     VkYcbcrSamplerTestHelper() {}
     ~VkYcbcrSamplerTestHelper();

     bool init(skiatest::Reporter* reporter);

     sk_sp<SkImage> createI420Image(skiatest::Reporter* reporter);

     GrContext* getGrContext() { return fGrContext.get(); }

 private:
     GrVkExtensions fExtensions;
     VkPhysicalDeviceFeatures2 fFeatures = {};
     VkDebugReportCallbackEXT fDebugCallback = VK_NULL_HANDLE;

     DECLARE_VK_PROC(DestroyInstance);
     DECLARE_VK_PROC(DeviceWaitIdle);
     DECLARE_VK_PROC(DestroyDevice);

     DECLARE_VK_PROC(GetPhysicalDeviceFormatProperties);
     DECLARE_VK_PROC(GetPhysicalDeviceMemoryProperties);

     DECLARE_VK_PROC(CreateImage);
     DECLARE_VK_PROC(DestroyImage);
     DECLARE_VK_PROC(GetImageMemoryRequirements);
     DECLARE_VK_PROC(AllocateMemory);
     DECLARE_VK_PROC(FreeMemory);
     DECLARE_VK_PROC(BindImageMemory);
     DECLARE_VK_PROC(MapMemory);
     DECLARE_VK_PROC(UnmapMemory);
     DECLARE_VK_PROC(FlushMappedMemoryRanges);
     DECLARE_VK_PROC(GetImageSubresourceLayout);

     VkDevice fDevice = VK_NULL_HANDLE;

     PFN_vkDestroyDebugReportCallbackEXT fDestroyDebugCallback = nullptr;

     GrVkBackendContext fBackendContext;
     sk_sp<GrContext> fGrContext;

     VkImage fImage = VK_NULL_HANDLE;
     VkDeviceMemory fImageMemory = VK_NULL_HANDLE;
     GrBackendTexture texture;
 };

 VkYcbcrSamplerTestHelper::~VkYcbcrSamplerTestHelper() {
     fGrContext.reset();

     if (fImage != VK_NULL_HANDLE) {
         fVkDestroyImage(fDevice, fImage, nullptr);
         fImage = VK_NULL_HANDLE;
     }
     if (fImageMemory != VK_NULL_HANDLE) {
         fVkFreeMemory(fDevice, fImageMemory, nullptr);
         fImageMemory = VK_NULL_HANDLE;
     }

     fBackendContext.fMemoryAllocator.reset();
     if (fDevice != VK_NULL_HANDLE) {
         fVkDeviceWaitIdle(fDevice);
         fVkDestroyDevice(fDevice, nullptr);
         fDevice = VK_NULL_HANDLE;
     }
     if (fDebugCallback != VK_NULL_HANDLE) {
         fDestroyDebugCallback(fBackendContext.fInstance, fDebugCallback, nullptr);
     }
     if (fBackendContext.fInstance != VK_NULL_HANDLE) {
         fVkDestroyInstance(fBackendContext.fInstance, nullptr);
         fBackendContext.fInstance = VK_NULL_HANDLE;
     }

     sk_gpu_test::FreeVulkanFeaturesStructs(&fFeatures);
 }

 bool VkYcbcrSamplerTestHelper::init(skiatest::Reporter* reporter) {
     PFN_vkGetInstanceProcAddr instProc;
     PFN_vkGetDeviceProcAddr devProc;
     if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc, &devProc)) {
         ERRORF(reporter, "Failed to load Vulkan");
         return false;
     }
     auto getProc = [&instProc, &devProc](const char* proc_name,
                                          VkInstance instance, VkDevice device) {
         if (device != VK_NULL_HANDLE) {
             return devProc(device, proc_name);
         }
         return instProc(instance, proc_name);
     };

     fFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
     fFeatures.pNext = nullptr;

     fBackendContext.fInstance = VK_NULL_HANDLE;
     fBackendContext.fDevice = VK_NULL_HANDLE;

     if (!sk_gpu_test::CreateVkBackendContext(getProc, &fBackendContext, &fExtensions, &fFeatures,
                                              &fDebugCallback, nullptr, sk_gpu_test::CanPresentFn(),
                                              false)) {
         return false;
     }
     fDevice = fBackendContext.fDevice;

     if (fDebugCallback != VK_NULL_HANDLE) {
         fDestroyDebugCallback = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
                 instProc(fBackendContext.fInstance, "vkDestroyDebugReportCallbackEXT"));
     }
     ACQUIRE_INST_VK_PROC(DestroyInstance)
     ACQUIRE_INST_VK_PROC(DeviceWaitIdle)
     ACQUIRE_INST_VK_PROC(DestroyDevice)

     ACQUIRE_INST_VK_PROC(GetPhysicalDeviceFormatProperties)
     ACQUIRE_INST_VK_PROC(GetPhysicalDeviceMemoryProperties)

     ACQUIRE_DEVICE_VK_PROC(CreateImage)
     ACQUIRE_DEVICE_VK_PROC(DestroyImage)
     ACQUIRE_DEVICE_VK_PROC(GetImageMemoryRequirements)
     ACQUIRE_DEVICE_VK_PROC(AllocateMemory)
     ACQUIRE_DEVICE_VK_PROC(FreeMemory)
     ACQUIRE_DEVICE_VK_PROC(BindImageMemory)
     ACQUIRE_DEVICE_VK_PROC(MapMemory)
     ACQUIRE_DEVICE_VK_PROC(UnmapMemory)
     ACQUIRE_DEVICE_VK_PROC(FlushMappedMemoryRanges)
     ACQUIRE_DEVICE_VK_PROC(GetImageSubresourceLayout)

     bool ycbcrSupported = false;
     VkBaseOutStructure* feature = reinterpret_cast<VkBaseOutStructure*>(fFeatures.pNext);
     while (feature) {
         if (feature->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES) {
             VkPhysicalDeviceSamplerYcbcrConversionFeatures* ycbcrFeatures =
                     reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(feature);
             ycbcrSupported = ycbcrFeatures->samplerYcbcrConversion;
             break;
         }
         feature = feature->pNext;
     }
     if (!ycbcrSupported) {
         return false;
     }

     fGrContext = GrContext::MakeVulkan(fBackendContext);
     if (!fGrContext) {
         return false;
     }

     return true;
 }

 sk_sp<SkImage> VkYcbcrSamplerTestHelper::createI420Image(skiatest::Reporter* reporter) {
     // Verify that the image format is supported.
     VkFormatProperties formatProperties;
     fVkGetPhysicalDeviceFormatProperties(fBackendContext.fPhysicalDevice,
                                          VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, &formatProperties);
     if (!(formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
         // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM is not supported
         return nullptr;
     }

     // Create YCbCr image.
     VkImageCreateInfo vkImageInfo = {};
     vkImageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
     vkImageInfo.imageType = VK_IMAGE_TYPE_2D;
     vkImageInfo.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
     vkImageInfo.extent = VkExtent3D{kImageWidth, kImageHeight, 1};
     vkImageInfo.mipLevels = 1;
     vkImageInfo.arrayLayers = 1;
     vkImageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
     vkImageInfo.tiling = VK_IMAGE_TILING_LINEAR;
     vkImageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
     vkImageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
     vkImageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

     REPORTER_ASSERT(reporter, fImage == VK_NULL_HANDLE);
     if (fVkCreateImage(fDevice, &vkImageInfo, nullptr, &fImage) != VK_SUCCESS) {
         ERRORF(reporter, "Failed to allocate I420 image");
         return nullptr;
     }

     VkMemoryRequirements requirements;
     fVkGetImageMemoryRequirements(fDevice, fImage, &requirements);

     uint32_t memoryTypeIndex = 0;
     bool foundHeap = false;
     VkPhysicalDeviceMemoryProperties phyDevMemProps;
     fVkGetPhysicalDeviceMemoryProperties(fBackendContext.fPhysicalDevice, &phyDevMemProps);
     for (uint32_t i = 0; i < phyDevMemProps.memoryTypeCount && !foundHeap; ++i) {
         if (requirements.memoryTypeBits & (1 << i)) {
             // Map host-visible memory.
             if (phyDevMemProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
                 memoryTypeIndex = i;
                 foundHeap = true;
             }
         }
     }
     if (!foundHeap) {
         ERRORF(reporter, "Failed to find valid heap for imported memory");
         return nullptr;
     }

     VkMemoryAllocateInfo allocInfo = {};
     allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
     allocInfo.allocationSize = requirements.size;
     allocInfo.memoryTypeIndex = memoryTypeIndex;

     REPORTER_ASSERT(reporter, fImageMemory == VK_NULL_HANDLE);
     if (fVkAllocateMemory(fDevice, &allocInfo, nullptr, &fImageMemory) != VK_SUCCESS) {
         ERRORF(reporter, "Failed to allocate VkDeviceMemory.");
         return nullptr;
     }

     void* mappedBuffer;
     if (fVkMapMemory(fDevice, fImageMemory, 0u, requirements.size, 0u, &mappedBuffer) !=
         VK_SUCCESS) {
         ERRORF(reporter, "Failed to map Vulkan memory.");
         return nullptr;
     }

     // Write Y channel.
     VkImageSubresource subresource;
     subresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
     subresource.mipLevel = 0;
     subresource.arrayLayer = 0;

     VkSubresourceLayout yLayout;
     fVkGetImageSubresourceLayout(fDevice, fImage, &subresource, &yLayout);
     uint8_t* bufferData = reinterpret_cast<uint8_t*>(mappedBuffer) + yLayout.offset;
     for (size_t y = 0; y < kImageHeight; ++y) {
         for (size_t x = 0; x < kImageWidth; ++x) {
             bufferData[y * yLayout.rowPitch + x] = getY(x, y);
         }
     }

     // Write UV channels.
     subresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
     VkSubresourceLayout uvLayout;
     fVkGetImageSubresourceLayout(fDevice, fImage, &subresource, &uvLayout);
     bufferData = reinterpret_cast<uint8_t*>(mappedBuffer) + uvLayout.offset;
     for (size_t y = 0; y < kImageHeight / 2; ++y) {
         for (size_t x = 0; x < kImageWidth / 2; ++x) {
             bufferData[y * uvLayout.rowPitch + x * 2] = getU(x * 2, y * 2);
             bufferData[y * uvLayout.rowPitch + x * 2 + 1] = getV(x * 2, y * 2);
         }
     }

     VkMappedMemoryRange flushRange;
     flushRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
     flushRange.pNext = nullptr;
     flushRange.memory = fImageMemory;
     flushRange.offset = 0;
     flushRange.size = VK_WHOLE_SIZE;
     if (fVkFlushMappedMemoryRanges(fDevice, 1, &flushRange) != VK_SUCCESS) {
         ERRORF(reporter, "Failed to flush buffer memory.");
         return nullptr;
     }
     fVkUnmapMemory(fDevice, fImageMemory);

     // Bind image memory.
     if (fVkBindImageMemory(fDevice, fImage, fImageMemory, 0u) != VK_SUCCESS) {
         ERRORF(reporter, "Failed to bind VkImage memory.");
         return nullptr;
     }

     // Wrap the image into SkImage.
     GrVkYcbcrConversionInfo ycbcrInfo(vkImageInfo.format,
                                       /*externalFormat=*/0,
                                       VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
                                       VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
                                       VK_CHROMA_LOCATION_COSITED_EVEN,
                                       VK_CHROMA_LOCATION_COSITED_EVEN,
                                       VK_FILTER_LINEAR,
                                       false,
                                       formatProperties.linearTilingFeatures);
     GrVkAlloc alloc(fImageMemory, 0 /* offset */, requirements.size, 0 /* flags */);
     GrVkImageInfo imageInfo(fImage, alloc, VK_IMAGE_TILING_LINEAR, VK_IMAGE_LAYOUT_UNDEFINED,
                             vkImageInfo.format, 1 /* levelCount */, VK_QUEUE_FAMILY_IGNORED,
                             GrProtected::kNo, ycbcrInfo);

     texture = GrBackendTexture(kImageWidth, kImageHeight, imageInfo);
     sk_sp<SkImage> image = SkImage::MakeFromTexture(fGrContext.get(),
                                                     texture,
                                                     kTopLeft_GrSurfaceOrigin,
                                                     kRGB_888x_SkColorType,
                                                     kPremul_SkAlphaType,
                                                     nullptr);

     if (!image) {
         ERRORF(reporter, "Failed to wrap VkImage with SkImage");
         return nullptr;
     }

     return image;
 }

 static int round_and_clamp(float x) {
     int r = static_cast<int>(round(x));
     if (r > 255) return 255;
     if (r < 0) return 0;
     return r;
 }

 DEF_GPUTEST(VkYCbcrSampler_DrawImageWithYcbcrSampler, reporter, options) {
     VkYcbcrSamplerTestHelper helper;
     if (!helper.init(reporter)) {
         return;
     }

     sk_sp<SkImage> srcImage = helper.createI420Image(reporter);
     if (!srcImage) {
         return;
     }

     sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
             helper.getGrContext(), SkBudgeted::kNo,
             SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType, kPremul_SkAlphaType));
     if (!surface) {
         ERRORF(reporter, "Failed to create target SkSurface");
         return;
     }
     surface->getCanvas()->drawImage(srcImage, 0, 0);
     surface->flush();

     std::vector<uint8_t> readbackData(kImageWidth * kImageHeight * 4);
     if (!surface->readPixels(SkImageInfo::Make(kImageWidth, kImageHeight, kRGBA_8888_SkColorType,
                                                kOpaque_SkAlphaType),
                              readbackData.data(), kImageWidth * 4, 0, 0)) {
         ERRORF(reporter, "Readback failed");
         return;
     }

     // Allow resulting color to be off by 1 in each channel as some Vulkan implementations do not
     // round YCbCr sampler result properly.
     const int kColorTolerance = 1;

     // Verify results only for pixels with even coordinates, since others use
     // interpolated U & V channels.
     for (size_t y = 0; y < kImageHeight; y += 2) {
         for (size_t x = 0; x < kImageWidth; x += 2) {
             // createI420Image() initializes the image with VK_SAMPLER_YCBCR_RANGE_ITU_NARROW.
             float yChannel = (static_cast<float>(getY(x, y)) - 16.0) / 219.0;
             float uChannel = (static_cast<float>(getU(x, y)) - 128.0) / 224.0;
             float vChannel = (static_cast<float>(getV(x, y)) - 128.0) / 224.0;

             // BR.709 conversion as specified in
             // https://www.khronos.org/registry/DataFormat/specs/1.2/dataformat.1.2.html#MODEL_YUV
             int expectedR = round_and_clamp((yChannel + 1.5748f * vChannel) * 255.0);
             int expectedG = round_and_clamp((yChannel - 0.13397432f / 0.7152f * uChannel -
                                              0.33480248f / 0.7152f * vChannel) *
                                             255.0);
             int expectedB = round_and_clamp((yChannel + 1.8556f * uChannel) * 255.0);

             int r = readbackData[(y * kImageWidth + x) * 4];
             if (abs(r - expectedR) > kColorTolerance) {
                 ERRORF(reporter, "R should be %d, but is %d at (%d, %d)", expectedR, r, x, y);
             }

             int g = readbackData[(y * kImageWidth + x) * 4 + 1];
             if (abs(g - expectedG) > kColorTolerance) {
                 ERRORF(reporter, "G should be %d, but is %d at (%d, %d)", expectedG, g, x, y);
             }

             int b = readbackData[(y * kImageWidth + x) * 4 + 2];
             if (abs(b - expectedB) > kColorTolerance) {
                 ERRORF(reporter, "B should be %d, but is %d at (%d, %d)", expectedB, b, x, y);
             }
         }
     }
 }

 // Verifies that it's not possible to allocate Ycbcr texture directly.
 DEF_GPUTEST(VkYCbcrSampler_NoYcbcrSurface, reporter, options) {
     VkYcbcrSamplerTestHelper helper;
     if (!helper.init(reporter)) {
         return;
     }

     GrBackendTexture texture = helper.getGrContext()->createBackendTexture(
             kImageWidth, kImageHeight, GrBackendFormat::MakeVk(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM),
             GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
     if (texture.isValid()) {
         ERRORF(reporter,
                "GrContext::createBackendTexture() didn't fail as expected for Ycbcr format.");
     }
 }

 #endif  // SK_SUPPORT_GPU && defined(SK_VULKAN)
	/*
	* Copyright 2019 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "include/core/SkTypes.h"

	#if SK_SUPPORT_GPU && defined(SK_VULKAN)

	#include "include/core/SkImage.h"
	#include "include/core/SkSurface.h"
	#include "include/gpu/GrContext.h"
	#include "include/gpu/vk/GrVkBackendContext.h"
	#include "include/gpu/vk/GrVkExtensions.h"
	#include "tests/Test.h"
	#include "tools/gpu/vk/VkTestUtils.h"

	const size_t kImageWidth = 8;
	const size_t kImageHeight = 8;

	static int getY(size_t x, size_t y) {
	return 16 + (x + y) * 219 / (kImageWidth + kImageHeight - 2);
	}
	static int getU(size_t x, size_t y) { return 16 + x * 224 / (kImageWidth - 1); }
	static int getV(size_t x, size_t y) { return 16 + y * 224 / (kImageHeight - 1); }

	#define DECLARE_VK_PROC(name) PFN_vk##name fVk##name

	#define ACQUIRE_INST_VK_PROC(name) \
	fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, fBackendContext.fInstance,\
	VK_NULL_HANDLE)); \
	if (fVk##name == nullptr) { \
	ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name); \
	return false; \
	}

	#define ACQUIRE_DEVICE_VK_PROC(name) \
	fVk##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, VK_NULL_HANDLE, fDevice)); \
	if (fVk##name == nullptr) { \
	ERRORF(reporter, "Function ptr for vk%s could not be acquired\n", #name); \
	return false; \
	}

	class VkYcbcrSamplerTestHelper {
	public:
	VkYcbcrSamplerTestHelper() {}
	~VkYcbcrSamplerTestHelper();

	bool init(skiatest::Reporter* reporter);

	sk_sp<SkImage> createI420Image(skiatest::Reporter* reporter);

	GrContext* getGrContext() { return fGrContext.get(); }

	private:
	GrVkExtensions fExtensions;
	VkPhysicalDeviceFeatures2 fFeatures = {};
	VkDebugReportCallbackEXT fDebugCallback = VK_NULL_HANDLE;

	DECLARE_VK_PROC(DestroyInstance);
	DECLARE_VK_PROC(DeviceWaitIdle);
	DECLARE_VK_PROC(DestroyDevice);

	DECLARE_VK_PROC(GetPhysicalDeviceFormatProperties);
	DECLARE_VK_PROC(GetPhysicalDeviceMemoryProperties);

	DECLARE_VK_PROC(CreateImage);
	DECLARE_VK_PROC(DestroyImage);
	DECLARE_VK_PROC(GetImageMemoryRequirements);
	DECLARE_VK_PROC(AllocateMemory);
	DECLARE_VK_PROC(FreeMemory);
	DECLARE_VK_PROC(BindImageMemory);
	DECLARE_VK_PROC(MapMemory);
	DECLARE_VK_PROC(UnmapMemory);
	DECLARE_VK_PROC(FlushMappedMemoryRanges);
	DECLARE_VK_PROC(GetImageSubresourceLayout);

	VkDevice fDevice = VK_NULL_HANDLE;

	PFN_vkDestroyDebugReportCallbackEXT fDestroyDebugCallback = nullptr;

	GrVkBackendContext fBackendContext;
	sk_sp<GrContext> fGrContext;

	VkImage fImage = VK_NULL_HANDLE;
	VkDeviceMemory fImageMemory = VK_NULL_HANDLE;
	GrBackendTexture texture;
	};

	VkYcbcrSamplerTestHelper::~VkYcbcrSamplerTestHelper() {
	fGrContext.reset();

	if (fImage != VK_NULL_HANDLE) {
	fVkDestroyImage(fDevice, fImage, nullptr);
	fImage = VK_NULL_HANDLE;
	}
	if (fImageMemory != VK_NULL_HANDLE) {
	fVkFreeMemory(fDevice, fImageMemory, nullptr);
	fImageMemory = VK_NULL_HANDLE;
	}

	fBackendContext.fMemoryAllocator.reset();
	if (fDevice != VK_NULL_HANDLE) {
	fVkDeviceWaitIdle(fDevice);
	fVkDestroyDevice(fDevice, nullptr);
	fDevice = VK_NULL_HANDLE;
	}
	if (fDebugCallback != VK_NULL_HANDLE) {
	fDestroyDebugCallback(fBackendContext.fInstance, fDebugCallback, nullptr);
	}
	if (fBackendContext.fInstance != VK_NULL_HANDLE) {
	fVkDestroyInstance(fBackendContext.fInstance, nullptr);
	fBackendContext.fInstance = VK_NULL_HANDLE;
	}

	sk_gpu_test::FreeVulkanFeaturesStructs(&fFeatures);
	}

	bool VkYcbcrSamplerTestHelper::init(skiatest::Reporter* reporter) {
	PFN_vkGetInstanceProcAddr instProc;
	PFN_vkGetDeviceProcAddr devProc;
	if (!sk_gpu_test::LoadVkLibraryAndGetProcAddrFuncs(&instProc, &devProc)) {
	ERRORF(reporter, "Failed to load Vulkan");
	return false;
	}
	auto getProc = [&instProc, &devProc](const char* proc_name,
	VkInstance instance, VkDevice device) {
	if (device != VK_NULL_HANDLE) {
	return devProc(device, proc_name);
	}
	return instProc(instance, proc_name);
	};

	fFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
	fFeatures.pNext = nullptr;

	fBackendContext.fInstance = VK_NULL_HANDLE;
	fBackendContext.fDevice = VK_NULL_HANDLE;

	if (!sk_gpu_test::CreateVkBackendContext(getProc, &fBackendContext, &fExtensions, &fFeatures,
	&fDebugCallback, nullptr, sk_gpu_test::CanPresentFn(),
	false)) {
	return false;
	}
	fDevice = fBackendContext.fDevice;

	if (fDebugCallback != VK_NULL_HANDLE) {
	fDestroyDebugCallback = reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
	instProc(fBackendContext.fInstance, "vkDestroyDebugReportCallbackEXT"));
	}
	ACQUIRE_INST_VK_PROC(DestroyInstance)
	ACQUIRE_INST_VK_PROC(DeviceWaitIdle)
	ACQUIRE_INST_VK_PROC(DestroyDevice)

	ACQUIRE_INST_VK_PROC(GetPhysicalDeviceFormatProperties)
	ACQUIRE_INST_VK_PROC(GetPhysicalDeviceMemoryProperties)

	ACQUIRE_DEVICE_VK_PROC(CreateImage)
	ACQUIRE_DEVICE_VK_PROC(DestroyImage)
	ACQUIRE_DEVICE_VK_PROC(GetImageMemoryRequirements)
	ACQUIRE_DEVICE_VK_PROC(AllocateMemory)
	ACQUIRE_DEVICE_VK_PROC(FreeMemory)
	ACQUIRE_DEVICE_VK_PROC(BindImageMemory)
	ACQUIRE_DEVICE_VK_PROC(MapMemory)
	ACQUIRE_DEVICE_VK_PROC(UnmapMemory)
	ACQUIRE_DEVICE_VK_PROC(FlushMappedMemoryRanges)
	ACQUIRE_DEVICE_VK_PROC(GetImageSubresourceLayout)

	bool ycbcrSupported = false;
	VkBaseOutStructure* feature = reinterpret_cast<VkBaseOutStructure*>(fFeatures.pNext);
	while (feature) {
	if (feature->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES) {
	VkPhysicalDeviceSamplerYcbcrConversionFeatures* ycbcrFeatures =
	reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures*>(feature);
	ycbcrSupported = ycbcrFeatures->samplerYcbcrConversion;
	break;
	}
	feature = feature->pNext;
	}
	if (!ycbcrSupported) {
	return false;
	}

	fGrContext = GrContext::MakeVulkan(fBackendContext);
	if (!fGrContext) {
	return false;
	}

	return true;
	}

	sk_sp<SkImage> VkYcbcrSamplerTestHelper::createI420Image(skiatest::Reporter* reporter) {
	// Verify that the image format is supported.
	VkFormatProperties formatProperties;
	fVkGetPhysicalDeviceFormatProperties(fBackendContext.fPhysicalDevice,
	VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, &formatProperties);
	if (!(formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
	// VK_FORMAT_G8_B8R8_2PLANE_420_UNORM is not supported
	return nullptr;
	}

	// Create YCbCr image.
	VkImageCreateInfo vkImageInfo = {};
	vkImageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
	vkImageInfo.imageType = VK_IMAGE_TYPE_2D;
	vkImageInfo.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
	vkImageInfo.extent = VkExtent3D{kImageWidth, kImageHeight, 1};
	vkImageInfo.mipLevels = 1;
	vkImageInfo.arrayLayers = 1;
	vkImageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
	vkImageInfo.tiling = VK_IMAGE_TILING_LINEAR;
	vkImageInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
	vkImageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	vkImageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;

	REPORTER_ASSERT(reporter, fImage == VK_NULL_HANDLE);
	if (fVkCreateImage(fDevice, &vkImageInfo, nullptr, &fImage) != VK_SUCCESS) {
	ERRORF(reporter, "Failed to allocate I420 image");
	return nullptr;
	}

	VkMemoryRequirements requirements;
	fVkGetImageMemoryRequirements(fDevice, fImage, &requirements);

	uint32_t memoryTypeIndex = 0;
	bool foundHeap = false;
	VkPhysicalDeviceMemoryProperties phyDevMemProps;
	fVkGetPhysicalDeviceMemoryProperties(fBackendContext.fPhysicalDevice, &phyDevMemProps);
	for (uint32_t i = 0; i < phyDevMemProps.memoryTypeCount && !foundHeap; ++i) {
	if (requirements.memoryTypeBits & (1 << i)) {
	// Map host-visible memory.
	if (phyDevMemProps.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
	memoryTypeIndex = i;
	foundHeap = true;
	}
	}
	}
	if (!foundHeap) {
	ERRORF(reporter, "Failed to find valid heap for imported memory");
	return nullptr;
	}

	VkMemoryAllocateInfo allocInfo = {};
	allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
	allocInfo.allocationSize = requirements.size;
	allocInfo.memoryTypeIndex = memoryTypeIndex;

	REPORTER_ASSERT(reporter, fImageMemory == VK_NULL_HANDLE);
	if (fVkAllocateMemory(fDevice, &allocInfo, nullptr, &fImageMemory) != VK_SUCCESS) {
	ERRORF(reporter, "Failed to allocate VkDeviceMemory.");
	return nullptr;
	}

	void* mappedBuffer;
	if (fVkMapMemory(fDevice, fImageMemory, 0u, requirements.size, 0u, &mappedBuffer) !=
	VK_SUCCESS) {
	ERRORF(reporter, "Failed to map Vulkan memory.");
	return nullptr;
	}

	// Write Y channel.
	VkImageSubresource subresource;
	subresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT;
	subresource.mipLevel = 0;
	subresource.arrayLayer = 0;

	VkSubresourceLayout yLayout;
	fVkGetImageSubresourceLayout(fDevice, fImage, &subresource, &yLayout);
	uint8_t* bufferData = reinterpret_cast<uint8_t*>(mappedBuffer) + yLayout.offset;
	for (size_t y = 0; y < kImageHeight; ++y) {
	for (size_t x = 0; x < kImageWidth; ++x) {
	bufferData[y * yLayout.rowPitch + x] = getY(x, y);
	}
	}

	// Write UV channels.
	subresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT;
	VkSubresourceLayout uvLayout;
	fVkGetImageSubresourceLayout(fDevice, fImage, &subresource, &uvLayout);
	bufferData = reinterpret_cast<uint8_t*>(mappedBuffer) + uvLayout.offset;
	for (size_t y = 0; y < kImageHeight / 2; ++y) {
	for (size_t x = 0; x < kImageWidth / 2; ++x) {
	bufferData[y * uvLayout.rowPitch + x * 2] = getU(x * 2, y * 2);
	bufferData[y * uvLayout.rowPitch + x * 2 + 1] = getV(x * 2, y * 2);
	}
	}

	VkMappedMemoryRange flushRange;
	flushRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
	flushRange.pNext = nullptr;
	flushRange.memory = fImageMemory;
	flushRange.offset = 0;
	flushRange.size = VK_WHOLE_SIZE;
	if (fVkFlushMappedMemoryRanges(fDevice, 1, &flushRange) != VK_SUCCESS) {
	ERRORF(reporter, "Failed to flush buffer memory.");
	return nullptr;
	}
	fVkUnmapMemory(fDevice, fImageMemory);

	// Bind image memory.
	if (fVkBindImageMemory(fDevice, fImage, fImageMemory, 0u) != VK_SUCCESS) {
	ERRORF(reporter, "Failed to bind VkImage memory.");
	return nullptr;
	}

	// Wrap the image into SkImage.
	GrVkYcbcrConversionInfo ycbcrInfo(vkImageInfo.format,
	/externalFormat=/0,
	VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
	VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,
	VK_CHROMA_LOCATION_COSITED_EVEN,
	VK_CHROMA_LOCATION_COSITED_EVEN,
	VK_FILTER_LINEAR,
	false,
	formatProperties.linearTilingFeatures);
	GrVkAlloc alloc(fImageMemory, 0 /* offset /, requirements.size, 0 / flags */);
	GrVkImageInfo imageInfo(fImage, alloc, VK_IMAGE_TILING_LINEAR, VK_IMAGE_LAYOUT_UNDEFINED,
	vkImageInfo.format, 1 /* levelCount */, VK_QUEUE_FAMILY_IGNORED,
	GrProtected::kNo, ycbcrInfo);

	texture = GrBackendTexture(kImageWidth, kImageHeight, imageInfo);
	sk_sp<SkImage> image = SkImage::MakeFromTexture(fGrContext.get(),
	texture,
	kTopLeft_GrSurfaceOrigin,
	kRGB_888x_SkColorType,
	kPremul_SkAlphaType,
	nullptr);

	if (!image) {
	ERRORF(reporter, "Failed to wrap VkImage with SkImage");
	return nullptr;
	}

	return image;
	}

	static int round_and_clamp(float x) {
	int r = static_cast<int>(round(x));
	if (r > 255) return 255;
	if (r < 0) return 0;
	return r;
	}

	DEF_GPUTEST(VkYCbcrSampler_DrawImageWithYcbcrSampler, reporter, options) {
	VkYcbcrSamplerTestHelper helper;
	if (!helper.init(reporter)) {
	return;
	}

	sk_sp<SkImage> srcImage = helper.createI420Image(reporter);
	if (!srcImage) {
	return;
	}

	sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
	helper.getGrContext(), SkBudgeted::kNo,
	SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType, kPremul_SkAlphaType));
	if (!surface) {
	ERRORF(reporter, "Failed to create target SkSurface");
	return;
	}
	surface->getCanvas()->drawImage(srcImage, 0, 0);
	surface->flush();

	std::vector<uint8_t> readbackData(kImageWidth * kImageHeight * 4);
	if (!surface->readPixels(SkImageInfo::Make(kImageWidth, kImageHeight, kRGBA_8888_SkColorType,
	kOpaque_SkAlphaType),
	readbackData.data(), kImageWidth * 4, 0, 0)) {
	ERRORF(reporter, "Readback failed");
	return;
	}

	// Allow resulting color to be off by 1 in each channel as some Vulkan implementations do not
	// round YCbCr sampler result properly.
	const int kColorTolerance = 1;

	// Verify results only for pixels with even coordinates, since others use
	// interpolated U & V channels.
	for (size_t y = 0; y < kImageHeight; y += 2) {
	for (size_t x = 0; x < kImageWidth; x += 2) {
	// createI420Image() initializes the image with VK_SAMPLER_YCBCR_RANGE_ITU_NARROW.
	float yChannel = (static_cast<float>(getY(x, y)) - 16.0) / 219.0;
	float uChannel = (static_cast<float>(getU(x, y)) - 128.0) / 224.0;
	float vChannel = (static_cast<float>(getV(x, y)) - 128.0) / 224.0;

	// BR.709 conversion as specified in
	// https://www.khronos.org/registry/DataFormat/specs/1.2/dataformat.1.2.html#MODEL_YUV
	int expectedR = round_and_clamp((yChannel + 1.5748f * vChannel) * 255.0);
	int expectedG = round_and_clamp((yChannel - 0.13397432f / 0.7152f * uChannel -
	0.33480248f / 0.7152f * vChannel) *
	255.0);
	int expectedB = round_and_clamp((yChannel + 1.8556f * uChannel) * 255.0);

	int r = readbackData[(y * kImageWidth + x) * 4];
	if (abs(r - expectedR) > kColorTolerance) {
	ERRORF(reporter, "R should be %d, but is %d at (%d, %d)", expectedR, r, x, y);
	}

	int g = readbackData[(y * kImageWidth + x) * 4 + 1];
	if (abs(g - expectedG) > kColorTolerance) {
	ERRORF(reporter, "G should be %d, but is %d at (%d, %d)", expectedG, g, x, y);
	}

	int b = readbackData[(y * kImageWidth + x) * 4 + 2];
	if (abs(b - expectedB) > kColorTolerance) {
	ERRORF(reporter, "B should be %d, but is %d at (%d, %d)", expectedB, b, x, y);
	}
	}
	}
	}

	// Verifies that it's not possible to allocate Ycbcr texture directly.
	DEF_GPUTEST(VkYCbcrSampler_NoYcbcrSurface, reporter, options) {
	VkYcbcrSamplerTestHelper helper;
	if (!helper.init(reporter)) {
	return;
	}

	GrBackendTexture texture = helper.getGrContext()->createBackendTexture(
	kImageWidth, kImageHeight, GrBackendFormat::MakeVk(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM),
	GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
	if (texture.isValid()) {
	ERRORF(reporter,
	"GrContext::createBackendTexture() didn't fail as expected for Ycbcr format.");
	}
	}

	#endif // SK_SUPPORT_GPU && defined(SK_VULKAN)