external/vulkancts/modules/vulkan/api/vktApiGranularityTests.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2015 The Khronos Group Inc.
  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Vulkan Get Render Area Granularity Tests
  *//*--------------------------------------------------------------------*/

 #include "vktApiGranularityTests.hpp"

 #include "deRandom.hpp"
 #include "deSharedPtr.hpp"
 #include "deStringUtil.hpp"
 #include "deUniquePtr.hpp"

 #include "vkImageUtil.hpp"
 #include "vkMemUtil.hpp"
 #include "vkQueryUtil.hpp"
 #include "vkRefUtil.hpp"
 #include "vkCmdUtil.hpp"
 #include "vkTypeUtil.hpp"
 #include "vktTestCase.hpp"

 #include "tcuTestLog.hpp"
 #include "tcuTextureUtil.hpp"

 #include <string>

 namespace vkt
 {

 namespace api
 {

 using namespace vk;

 namespace
 {

 struct AttachmentInfo
 {
 	AttachmentInfo (const VkFormat	vkFormat,
 					const deUint32	width,
 					const deUint32	height,
 					const deUint32	depth)
 		: format	(vkFormat)
 	{
 		extent.width	= width;
 		extent.height	= height;
 		extent.depth	= depth;
 	}

 	~AttachmentInfo (void)
 	{}

 	VkFormat	format;
 	VkExtent3D	extent;
 };

 typedef de::SharedPtr<Allocation>			AllocationSp;
 typedef de::SharedPtr<Unique<VkImage> >		VkImageSp;
 typedef de::SharedPtr<Unique<VkImageView> >	VkImageViewSp;

 class GranularityInstance : public vkt::TestInstance
 {
 public:
 											GranularityInstance			(Context&							context,
 																		 const std::vector<AttachmentInfo>&	attachments,
 																		 const bool							useRenderPass);
 	virtual									~GranularityInstance		(void);
 	void									checkFormatSupport			(const VkFormat format);
 	void									initAttachmentDescriptions	(void);
 	void									initImages					(void);
 	void									initRenderPass				(void);
 	void									beginRenderPass				(void);
 	void									endRenderPass				(void);
 	virtual	tcu::TestStatus					iterate						(void);
 private:
 	const std::vector<AttachmentInfo>		m_attachments;
 	const bool								m_useRenderPass;

 	Move<VkRenderPass>						m_renderPass;
 	Move<VkFramebuffer>						m_frameBuffer;
 	Move<VkCommandPool>						m_cmdPool;
 	Move<VkCommandBuffer>					m_cmdBuffer;
 	std::vector<VkAttachmentDescription>	m_attachmentDescriptions;
 	std::vector<VkImageSp>					m_images;
 	std::vector<AllocationSp>				m_imageAllocs;
 	std::vector<VkImageViewSp>				m_imageViews;
 };

 GranularityInstance::GranularityInstance (Context&								context,
 										  const std::vector<AttachmentInfo>&	attachments,
 										  const bool							useRenderPass)
 	: vkt::TestInstance	(context)
 	, m_attachments		(attachments)
 	, m_useRenderPass	(useRenderPass)
 {
 	initAttachmentDescriptions();
 }

 GranularityInstance::~GranularityInstance (void)
 {
 }

 void GranularityInstance::checkFormatSupport (const VkFormat format)
 {
 	VkImageFormatProperties	properties;

 	VkResult result = m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(),
 																							  format, VK_IMAGE_TYPE_2D,
 																							  VK_IMAGE_TILING_OPTIMAL,
 																							  VK_IMAGE_USAGE_SAMPLED_BIT,
 																							  0,
 																							  &properties);

 	if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
 		TCU_THROW(NotSupportedError, "Format not supported");
 }

 void GranularityInstance::initAttachmentDescriptions (void)
 {
 	VkAttachmentDescription	attachmentDescription	=
 	{
 		0u,									// VkAttachmentDescriptionFlags	flags;
 		VK_FORMAT_UNDEFINED,				// VkFormat						format;
 		VK_SAMPLE_COUNT_1_BIT,				// VkSampleCountFlagBits		samples;
 		VK_ATTACHMENT_LOAD_OP_DONT_CARE,	// VkAttachmentLoadOp			loadOp;
 		VK_ATTACHMENT_STORE_OP_DONT_CARE,	// VkAttachmentStoreOp			storeOp;
 		VK_ATTACHMENT_LOAD_OP_DONT_CARE,	// VkAttachmentLoadOp			stencilLoadOp;
 		VK_ATTACHMENT_STORE_OP_DONT_CARE,	// VkAttachmentStoreOp			stencilStoreOp;
 		VK_IMAGE_LAYOUT_UNDEFINED,			// VkImageLayout				initialLayout;
 		VK_IMAGE_LAYOUT_GENERAL,			// VkImageLayout				finalLayout;
 	};

 	for (std::vector<AttachmentInfo>::const_iterator it = m_attachments.begin(); it != m_attachments.end(); ++it)
 	{
 		checkFormatSupport(it->format);
 		attachmentDescription.format = it->format;
 		m_attachmentDescriptions.push_back(attachmentDescription);
 	}
 }

 void GranularityInstance::initImages (void)
 {
 	const DeviceInterface&	vk					= m_context.getDeviceInterface();
 	const VkDevice			device				= m_context.getDevice();
 	const deUint32			queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
 	SimpleAllocator			memAlloc			(vk, device, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));

 	for (std::vector<AttachmentInfo>::const_iterator it = m_attachments.begin(); it != m_attachments.end(); ++it)
 	{
 		const VkImageCreateInfo		imageInfo	=
 		{
 			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// VkStructureType		sType;
 			DE_NULL,								// const void*			pNext;
 			0u,										// VkImageCreateFlags	flags;
 			VK_IMAGE_TYPE_2D,						// VkImageType			imageType;
 			it->format,								// VkFormat				format;
 			it->extent,								// VkExtent3D			extent;
 			1u,										// deUint32				mipLevels;
 			1u,										// deUint32				arrayLayers;
 			VK_SAMPLE_COUNT_1_BIT,					// deUint32				samples;
 			VK_IMAGE_TILING_OPTIMAL,				// VkImageTiling		tiling;
 			VK_IMAGE_USAGE_SAMPLED_BIT,				// VkImageUsageFlags	usage;
 			VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode		sharingMode;
 			1u,										// deUint32				queueFamilyCount;
 			&queueFamilyIndex,						// const deUint32*		pQueueFamilyIndices;
 			VK_IMAGE_LAYOUT_UNDEFINED,				// VkImageLayout		initialLayout;
 		};

 		// Create the image
 		Move<VkImage>			image		= createImage(vk, device, &imageInfo);
 		de::MovePtr<Allocation>	imageAlloc	= memAlloc.allocate(getImageMemoryRequirements(vk, device, *image), MemoryRequirement::Any);
 		VK_CHECK(vk.bindImageMemory(device, *image, imageAlloc->getMemory(), imageAlloc->getOffset()));

 		VkImageAspectFlags			aspectFlags = 0;
 		const tcu::TextureFormat	tcuFormat	= mapVkFormat(it->format);

 		if (tcu::hasDepthComponent(tcuFormat.order))
 			aspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;

 		if (tcu::hasStencilComponent(tcuFormat.order))
 			aspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;

 		if (!aspectFlags)
 			aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;

 		VkFormatProperties formatProperties;
 		m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(),
 										   it->format, &formatProperties);

 		if ((formatProperties.optimalTilingFeatures & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
 							       VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) == 0)
 			throw tcu::NotSupportedError("Format not supported as attachment");

 		const VkImageViewCreateInfo		createInfo	=
 		{
 			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// VkStructureType			sType;
 			DE_NULL,										// const void*				pNext;
 			0,												// VkImageViewCreateFlags	flags;
 			*image,											// VkImage					image;
 			VK_IMAGE_VIEW_TYPE_2D,							// VkImageViewType			viewType;
 			it->format,										// VkFormat					format;
 			{
 				VK_COMPONENT_SWIZZLE_R,
 				VK_COMPONENT_SWIZZLE_G,
 				VK_COMPONENT_SWIZZLE_B,
 				VK_COMPONENT_SWIZZLE_A
 			},												// VkComponentMapping		components;
 			{ aspectFlags, 0u, 1u, 0u, 1u	}	// VkImageSubresourceRange	subresourceRange;
 		};

 		// Create the Image View
 		Move<VkImageView>	imageView		= createImageView(vk, device, &createInfo);

 		// To prevent object free
 		m_images.push_back(VkImageSp(new Unique<VkImage>(image)));
 		m_imageAllocs.push_back(AllocationSp(imageAlloc.release()));
 		m_imageViews.push_back(VkImageViewSp(new Unique<VkImageView>(imageView)));
 	}
 }

 void GranularityInstance::initRenderPass (void)
 {
 	const DeviceInterface&		vk					= m_context.getDeviceInterface();
 	const VkDevice				device				= m_context.getDevice();
 	const deUint32				queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();

 	{	// Create RenderPass
 		const VkSubpassDescription	subpassDesc =
 		{
 			(VkSubpassDescriptionFlags)0u,		// VkSubpassDescriptionFlags		flags;
 			VK_PIPELINE_BIND_POINT_GRAPHICS,	// VkPipelineBindPoint				pipelineBindPoint;
 			0u,									// deUint32							inputCount;
 			DE_NULL,							// const VkAttachmentReference*		pInputAttachments;
 			0u,									// deUint32							colorCount;
 			DE_NULL,							// const VkAttachmentReference*		pColorAttachments;
 			DE_NULL,							// const VkAttachmentReference*		pResolveAttachments;
 			DE_NULL,							// VkAttachmentReference			depthStencilAttachment;
 			0u,									// deUint32							preserveCount;
 			DE_NULL								// const VkAttachmentReference*		pPreserveAttachments;
 		};

 		const VkRenderPassCreateInfo	renderPassParams =
 		{
 			VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,	// VkStructureType					sType;
 			DE_NULL,									// const void*						pNext;
 			(VkRenderPassCreateFlags)0,					// VkRenderPassCreateFlags			flags;
 			(deUint32)m_attachmentDescriptions.size(),	// deUint32							attachmentCount;
 			&m_attachmentDescriptions[0],				// const VkAttachmentDescription*	pAttachments;
 			1u,											// deUint32							subpassCount;
 			&subpassDesc,								// const VkSubpassDescription*		pSubpasses;
 			0u,											// deUint32							dependencyCount;
 			DE_NULL										// const VkSubpassDependency*		pDependencies;
 		};

 		m_renderPass	= createRenderPass(vk, device, &renderPassParams);
 	}

 	initImages();

 	{	// Create Framebuffer
 		std::vector<VkImageView>	imageViews;

 		for (std::vector<VkImageViewSp>::const_iterator it = m_imageViews.begin(); it != m_imageViews.end(); ++it)
 			imageViews.push_back(it->get()->get());

 		const VkFramebufferCreateInfo	framebufferParams	=
 		{
 			VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,	// VkStructureType			sType;
 			DE_NULL,									// const void*				pNext;
 			(VkFramebufferCreateFlags)0,				// VkFramebufferCreateFlags	flags;
 			*m_renderPass,								// VkRenderPass				renderPass;
 			(deUint32)imageViews.size(),				// deUint32					attachmentCount;
 			&imageViews[0],								// const VkImageView*		pAttachments;
 			1,											// deUint32					width;
 			1,											// deUint32					height;
 			1											// deUint32					layers;
 		};

 		m_frameBuffer	= createFramebuffer(vk, device, &framebufferParams);
 	}

 	m_cmdPool	= createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);

 	// Create CommandBuffer
 	m_cmdBuffer	= allocateCommandBuffer(vk, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

 	// Begin CommandBuffer
 	beginCommandBuffer(vk, *m_cmdBuffer, 0u);
 }

 void GranularityInstance::beginRenderPass (void)
 {
 	const DeviceInterface&	vk	= m_context.getDeviceInterface();

 	const VkRect2D	renderArea	= makeRect2D(1u, 1u);

 	vk::beginRenderPass(vk, *m_cmdBuffer, *m_renderPass, *m_frameBuffer, renderArea);
 }

 void GranularityInstance::endRenderPass (void)
 {
 	const DeviceInterface&	vk	= m_context.getDeviceInterface();

 	vk::endRenderPass(vk, *m_cmdBuffer);
 	endCommandBuffer(vk, *m_cmdBuffer);
 }

 tcu::TestStatus GranularityInstance::iterate (void)
 {
 	const DeviceInterface&	vk		= m_context.getDeviceInterface();
 	const VkDevice			device	= m_context.getDevice();
 	tcu::TestLog&			log		= m_context.getTestContext().getLog();

 	initRenderPass();

 	VkExtent2D prePassGranularity = { ~0u, ~0u };
 	vk.getRenderAreaGranularity(device, *m_renderPass, &prePassGranularity);

 	if(m_useRenderPass)
 		beginRenderPass();

 	VkExtent2D	granularity = { 0u, 0u };
 	vk.getRenderAreaGranularity(device, *m_renderPass, &granularity);
 	TCU_CHECK(granularity.width >= 1 && granularity.height >= 1);
 	TCU_CHECK(prePassGranularity.width == granularity.width && prePassGranularity.height == granularity.height);
 	TCU_CHECK(granularity.width <= m_context.getDeviceProperties().limits.maxFramebufferWidth && granularity.height <= m_context.getDeviceProperties().limits.maxFramebufferHeight);

 	if(m_useRenderPass)
 		endRenderPass();

 	log << tcu::TestLog::Message << "Horizontal granularity: " << granularity.width << " Vertical granularity: " << granularity.height << tcu::TestLog::EndMessage;
 	return tcu::TestStatus::pass("Granularity test");
 }

 class GranularityCase : public vkt::TestCase
 {
 public:
 										GranularityCase		(tcu::TestContext&					testCtx,
 															 const std::string&					name,
 															 const std::string&					description,
 															 const std::vector<AttachmentInfo>&	attachments,
 															 const bool							useRenderPass);
 	virtual								~GranularityCase	(void);

 	virtual TestInstance*				createInstance		(Context&	context) const;
 private:
 	const std::vector<AttachmentInfo>	m_attachments;
 	const bool							m_useRenderPass;
 };

 GranularityCase::GranularityCase (tcu::TestContext&						testCtx,
 								  const std::string&					name,
 								  const std::string&					description,
 								  const std::vector<AttachmentInfo>&	attachments,
 								  const bool							useRenderPass = false)
 	: vkt::TestCase		(testCtx, name, description)
 	, m_attachments		(attachments)
 	, m_useRenderPass	(useRenderPass)
 {
 }

 GranularityCase::~GranularityCase (void)
 {
 }

 TestInstance* GranularityCase::createInstance (Context& context) const
 {
 	return new GranularityInstance(context, m_attachments, m_useRenderPass);
 }

 } // anonymous

 tcu::TestCaseGroup* createGranularityQueryTests (tcu::TestContext& testCtx)
 {
 	de::MovePtr<tcu::TestCaseGroup>	group			(new tcu::TestCaseGroup(testCtx, "granularity", "Granularity query tests"));
 	// Subgroups
 	de::MovePtr<tcu::TestCaseGroup>	single			(new tcu::TestCaseGroup(testCtx, "single", "Single texture granularity tests."));
 	de::MovePtr<tcu::TestCaseGroup>	multi			(new tcu::TestCaseGroup(testCtx, "multi", "Multiple textures with same format granularity tests."));
 	de::MovePtr<tcu::TestCaseGroup>	random			(new tcu::TestCaseGroup(testCtx, "random", "Multiple textures with a guaranteed format occurence."));
 	de::MovePtr<tcu::TestCaseGroup>	inRenderPass	(new tcu::TestCaseGroup(testCtx, "in_render_pass", "Single texture granularity tests, inside render pass"));

 	de::Random	rnd(215);
 	const char*	description	= "Granularity case.";

 	const VkFormat mandatoryFormats[] =
 	{
 		VK_FORMAT_B4G4R4A4_UNORM_PACK16,
 		VK_FORMAT_R5G6B5_UNORM_PACK16,
 		VK_FORMAT_A1R5G5B5_UNORM_PACK16,
 		VK_FORMAT_R8_UNORM,
 		VK_FORMAT_R8_SNORM,
 		VK_FORMAT_R8_UINT,
 		VK_FORMAT_R8_SINT,
 		VK_FORMAT_R8G8_UNORM,
 		VK_FORMAT_R8G8_SNORM,
 		VK_FORMAT_R8G8_UINT,
 		VK_FORMAT_R8G8_SINT,
 		VK_FORMAT_R8G8B8A8_UNORM,
 		VK_FORMAT_R8G8B8A8_SNORM,
 		VK_FORMAT_R8G8B8A8_UINT,
 		VK_FORMAT_R8G8B8A8_SINT,
 		VK_FORMAT_R8G8B8A8_SRGB,
 		VK_FORMAT_B8G8R8A8_UNORM,
 		VK_FORMAT_B8G8R8A8_SRGB,
 		VK_FORMAT_A8B8G8R8_UNORM_PACK32,
 		VK_FORMAT_A8B8G8R8_SNORM_PACK32,
 		VK_FORMAT_A8B8G8R8_UINT_PACK32,
 		VK_FORMAT_A8B8G8R8_SINT_PACK32,
 		VK_FORMAT_A8B8G8R8_SRGB_PACK32,
 		VK_FORMAT_A2B10G10R10_UNORM_PACK32,
 		VK_FORMAT_A2B10G10R10_UINT_PACK32,
 		VK_FORMAT_R16_UINT,
 		VK_FORMAT_R16_SINT,
 		VK_FORMAT_R16_SFLOAT,
 		VK_FORMAT_R16G16_UINT,
 		VK_FORMAT_R16G16_SINT,
 		VK_FORMAT_R16G16_SFLOAT,
 		VK_FORMAT_R16G16B16A16_UINT,
 		VK_FORMAT_R16G16B16A16_SINT,
 		VK_FORMAT_R16G16B16A16_SFLOAT,
 		VK_FORMAT_R32_UINT,
 		VK_FORMAT_R32_SINT,
 		VK_FORMAT_R32_SFLOAT,
 		VK_FORMAT_R32G32_UINT,
 		VK_FORMAT_R32G32_SINT,
 		VK_FORMAT_R32G32_SFLOAT,
 		VK_FORMAT_R32G32B32A32_UINT,
 		VK_FORMAT_R32G32B32A32_SINT,
 		VK_FORMAT_R32G32B32A32_SFLOAT,
 		VK_FORMAT_B10G11R11_UFLOAT_PACK32,
 		VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
 		VK_FORMAT_D16_UNORM,
 		VK_FORMAT_D32_SFLOAT,
 	};

 	const deUint32	maxDimension	= 500;
 	const deUint32	minIteration	= 2;
 	const deUint32	maxIteration	= 10;

 	for (deUint32 formatIdx = 1; formatIdx <= VK_FORMAT_D32_SFLOAT_S8_UINT; ++formatIdx)
 	{
 		VkFormat	format		= VkFormat(formatIdx);
 		std::string name		= de::toLower(getFormatName(format)).substr(10);

 		{
 			std::vector<AttachmentInfo>	attachments;
 			const int					i0				= rnd.getInt(1, maxDimension);
 			const int					i1				= rnd.getInt(1, maxDimension);
 			attachments.push_back(AttachmentInfo(format, i0, i1, 1));
 			single->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments));
 		}

 		{
 			std::vector<AttachmentInfo>	attachments;
 			const deUint32				iterations		= rnd.getInt(minIteration, maxIteration);
 			const int					i0				= rnd.getInt(1, maxDimension);
 			const int					i1				= rnd.getInt(1, maxDimension);
 			for (deUint32 idx = 0; idx < iterations; ++idx)
 				attachments.push_back(AttachmentInfo(VkFormat(formatIdx), i0, i1, 1));
 			multi->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments));
 		}

 		{
 			std::vector<AttachmentInfo>	attachments;
 			const deUint32				iterations		= rnd.getInt(minIteration, maxIteration);
 			const int					i0				= rnd.getInt(1, maxDimension);
 			const int					i1				= rnd.getInt(1, maxDimension);
 			attachments.push_back(AttachmentInfo(VkFormat(formatIdx), i0, i1, 1));
 			for (deUint32 idx = 0; idx < iterations; ++idx)
 			{
 				const int	i2	= rnd.getInt(0, DE_LENGTH_OF_ARRAY(mandatoryFormats) - 1);
 				const int	i3	= rnd.getInt(1, maxDimension);
 				const int	i4	= rnd.getInt(1, maxDimension);
 				attachments.push_back(AttachmentInfo(mandatoryFormats[i2], i3, i4, 1));
 			}
 			random->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments));
 		}

 		{
 			std::vector<AttachmentInfo>	attachments;
 			const int					i0				= rnd.getInt(1, maxDimension);
 			const int					i1				= rnd.getInt(1, maxDimension);
 			attachments.push_back(AttachmentInfo(format, i0, i1, 1));
 			inRenderPass->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments, true));
 		}
 	}

 	group->addChild(single.release());
 	group->addChild(multi.release());
 	group->addChild(random.release());
 	group->addChild(inRenderPass.release());

 	return group.release();
 }

 } // api
 } // vkt
	/*------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2015 The Khronos Group Inc.
	* Copyright (c) 2015 Samsung Electronics Co., Ltd.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Vulkan Get Render Area Granularity Tests
	//--------------------------------------------------------------------*/

	#include "vktApiGranularityTests.hpp"

	#include "deRandom.hpp"
	#include "deSharedPtr.hpp"
	#include "deStringUtil.hpp"
	#include "deUniquePtr.hpp"

	#include "vkImageUtil.hpp"
	#include "vkMemUtil.hpp"
	#include "vkQueryUtil.hpp"
	#include "vkRefUtil.hpp"
	#include "vkCmdUtil.hpp"
	#include "vkTypeUtil.hpp"
	#include "vktTestCase.hpp"

	#include "tcuTestLog.hpp"
	#include "tcuTextureUtil.hpp"

	#include <string>

	namespace vkt
	{

	namespace api
	{

	using namespace vk;

	namespace
	{

	struct AttachmentInfo
	{
	AttachmentInfo (const VkFormat vkFormat,
	const deUint32 width,
	const deUint32 height,
	const deUint32 depth)
	: format (vkFormat)
	{
	extent.width = width;
	extent.height = height;
	extent.depth = depth;
	}

	~AttachmentInfo (void)
	{}

	VkFormat format;
	VkExtent3D extent;
	};

	typedef de::SharedPtr<Allocation> AllocationSp;
	typedef de::SharedPtr<Unique<VkImage> > VkImageSp;
	typedef de::SharedPtr<Unique<VkImageView> > VkImageViewSp;

	class GranularityInstance : public vkt::TestInstance
	{
	public:
	GranularityInstance (Context& context,
	const std::vector<AttachmentInfo>& attachments,
	const bool useRenderPass);
	virtual ~GranularityInstance (void);
	void checkFormatSupport (const VkFormat format);
	void initAttachmentDescriptions (void);
	void initImages (void);
	void initRenderPass (void);
	void beginRenderPass (void);
	void endRenderPass (void);
	virtual tcu::TestStatus iterate (void);
	private:
	const std::vector<AttachmentInfo> m_attachments;
	const bool m_useRenderPass;

	Move<VkRenderPass> m_renderPass;
	Move<VkFramebuffer> m_frameBuffer;
	Move<VkCommandPool> m_cmdPool;
	Move<VkCommandBuffer> m_cmdBuffer;
	std::vector<VkAttachmentDescription> m_attachmentDescriptions;
	std::vector<VkImageSp> m_images;
	std::vector<AllocationSp> m_imageAllocs;
	std::vector<VkImageViewSp> m_imageViews;
	};

	GranularityInstance::GranularityInstance (Context& context,
	const std::vector<AttachmentInfo>& attachments,
	const bool useRenderPass)
	: vkt::TestInstance (context)
	, m_attachments (attachments)
	, m_useRenderPass (useRenderPass)
	{
	initAttachmentDescriptions();
	}

	GranularityInstance::~GranularityInstance (void)
	{
	}

	void GranularityInstance::checkFormatSupport (const VkFormat format)
	{
	VkImageFormatProperties properties;

	VkResult result = m_context.getInstanceInterface().getPhysicalDeviceImageFormatProperties(m_context.getPhysicalDevice(),
	format, VK_IMAGE_TYPE_2D,
	VK_IMAGE_TILING_OPTIMAL,
	VK_IMAGE_USAGE_SAMPLED_BIT,
	0,
	&properties);

	if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
	TCU_THROW(NotSupportedError, "Format not supported");
	}

	void GranularityInstance::initAttachmentDescriptions (void)
	{
	VkAttachmentDescription attachmentDescription =
	{
	0u, // VkAttachmentDescriptionFlags flags;
	VK_FORMAT_UNDEFINED, // VkFormat format;
	VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
	VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp loadOp;
	VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp storeOp;
	VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
	VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
	VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
	VK_IMAGE_LAYOUT_GENERAL, // VkImageLayout finalLayout;
	};

	for (std::vector<AttachmentInfo>::const_iterator it = m_attachments.begin(); it != m_attachments.end(); ++it)
	{
	checkFormatSupport(it->format);
	attachmentDescription.format = it->format;
	m_attachmentDescriptions.push_back(attachmentDescription);
	}
	}

	void GranularityInstance::initImages (void)
	{
	const DeviceInterface& vk = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
	SimpleAllocator memAlloc (vk, device, getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()));

	for (std::vector<AttachmentInfo>::const_iterator it = m_attachments.begin(); it != m_attachments.end(); ++it)
	{
	const VkImageCreateInfo imageInfo =
	{
	VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // VkImageCreateFlags flags;
	VK_IMAGE_TYPE_2D, // VkImageType imageType;
	it->format, // VkFormat format;
	it->extent, // VkExtent3D extent;
	1u, // deUint32 mipLevels;
	1u, // deUint32 arrayLayers;
	VK_SAMPLE_COUNT_1_BIT, // deUint32 samples;
	VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
	VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
	VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
	1u, // deUint32 queueFamilyCount;
	&queueFamilyIndex, // const deUint32* pQueueFamilyIndices;
	VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
	};

	// Create the image
	Move<VkImage> image = createImage(vk, device, &imageInfo);
	de::MovePtr<Allocation> imageAlloc = memAlloc.allocate(getImageMemoryRequirements(vk, device, *image), MemoryRequirement::Any);
	VK_CHECK(vk.bindImageMemory(device, *image, imageAlloc->getMemory(), imageAlloc->getOffset()));

	VkImageAspectFlags aspectFlags = 0;
	const tcu::TextureFormat tcuFormat = mapVkFormat(it->format);

	if (tcu::hasDepthComponent(tcuFormat.order))
	aspectFlags \|= VK_IMAGE_ASPECT_DEPTH_BIT;

	if (tcu::hasStencilComponent(tcuFormat.order))
	aspectFlags \|= VK_IMAGE_ASPECT_STENCIL_BIT;

	if (!aspectFlags)
	aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;

	VkFormatProperties formatProperties;
	m_context.getInstanceInterface().getPhysicalDeviceFormatProperties(m_context.getPhysicalDevice(),
	it->format, &formatProperties);

	if ((formatProperties.optimalTilingFeatures & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT \|
	VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) == 0)
	throw tcu::NotSupportedError("Format not supported as attachment");

	const VkImageViewCreateInfo createInfo =
	{
	VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0, // VkImageViewCreateFlags flags;
	*image, // VkImage image;
	VK_IMAGE_VIEW_TYPE_2D, // VkImageViewType viewType;
	it->format, // VkFormat format;
	{
	VK_COMPONENT_SWIZZLE_R,
	VK_COMPONENT_SWIZZLE_G,
	VK_COMPONENT_SWIZZLE_B,
	VK_COMPONENT_SWIZZLE_A
	}, // VkComponentMapping components;
	{ aspectFlags, 0u, 1u, 0u, 1u } // VkImageSubresourceRange subresourceRange;
	};

	// Create the Image View
	Move<VkImageView> imageView = createImageView(vk, device, &createInfo);

	// To prevent object free
	m_images.push_back(VkImageSp(new Unique<VkImage>(image)));
	m_imageAllocs.push_back(AllocationSp(imageAlloc.release()));
	m_imageViews.push_back(VkImageViewSp(new Unique<VkImageView>(imageView)));
	}
	}

	void GranularityInstance::initRenderPass (void)
	{
	const DeviceInterface& vk = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();

	{ // Create RenderPass
	const VkSubpassDescription subpassDesc =
	{
	(VkSubpassDescriptionFlags)0u, // VkSubpassDescriptionFlags flags;
	VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
	0u, // deUint32 inputCount;
	DE_NULL, // const VkAttachmentReference* pInputAttachments;
	0u, // deUint32 colorCount;
	DE_NULL, // const VkAttachmentReference* pColorAttachments;
	DE_NULL, // const VkAttachmentReference* pResolveAttachments;
	DE_NULL, // VkAttachmentReference depthStencilAttachment;
	0u, // deUint32 preserveCount;
	DE_NULL // const VkAttachmentReference* pPreserveAttachments;
	};

	const VkRenderPassCreateInfo renderPassParams =
	{
	VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
	(deUint32)m_attachmentDescriptions.size(), // deUint32 attachmentCount;
	&m_attachmentDescriptions[0], // const VkAttachmentDescription* pAttachments;
	1u, // deUint32 subpassCount;
	&subpassDesc, // const VkSubpassDescription* pSubpasses;
	0u, // deUint32 dependencyCount;
	DE_NULL // const VkSubpassDependency* pDependencies;
	};

	m_renderPass = createRenderPass(vk, device, &renderPassParams);
	}

	initImages();

	{ // Create Framebuffer
	std::vector<VkImageView> imageViews;

	for (std::vector<VkImageViewSp>::const_iterator it = m_imageViews.begin(); it != m_imageViews.end(); ++it)
	imageViews.push_back(it->get()->get());

	const VkFramebufferCreateInfo framebufferParams =
	{
	VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
	*m_renderPass, // VkRenderPass renderPass;
	(deUint32)imageViews.size(), // deUint32 attachmentCount;
	&imageViews[0], // const VkImageView* pAttachments;
	1, // deUint32 width;
	1, // deUint32 height;
	1 // deUint32 layers;
	};

	m_frameBuffer = createFramebuffer(vk, device, &framebufferParams);
	}

	m_cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);

	// Create CommandBuffer
	m_cmdBuffer = allocateCommandBuffer(vk, device, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

	// Begin CommandBuffer
	beginCommandBuffer(vk, *m_cmdBuffer, 0u);
	}

	void GranularityInstance::beginRenderPass (void)
	{
	const DeviceInterface& vk = m_context.getDeviceInterface();

	const VkRect2D renderArea = makeRect2D(1u, 1u);

	vk::beginRenderPass(vk, m_cmdBuffer, m_renderPass, *m_frameBuffer, renderArea);
	}

	void GranularityInstance::endRenderPass (void)
	{
	const DeviceInterface& vk = m_context.getDeviceInterface();

	vk::endRenderPass(vk, *m_cmdBuffer);
	endCommandBuffer(vk, *m_cmdBuffer);
	}

	tcu::TestStatus GranularityInstance::iterate (void)
	{
	const DeviceInterface& vk = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	tcu::TestLog& log = m_context.getTestContext().getLog();

	initRenderPass();

	VkExtent2D prePassGranularity = { ~0u, ~0u };
	vk.getRenderAreaGranularity(device, *m_renderPass, &prePassGranularity);

	if(m_useRenderPass)
	beginRenderPass();

	VkExtent2D granularity = { 0u, 0u };
	vk.getRenderAreaGranularity(device, *m_renderPass, &granularity);
	TCU_CHECK(granularity.width >= 1 && granularity.height >= 1);
	TCU_CHECK(prePassGranularity.width == granularity.width && prePassGranularity.height == granularity.height);
	TCU_CHECK(granularity.width <= m_context.getDeviceProperties().limits.maxFramebufferWidth && granularity.height <= m_context.getDeviceProperties().limits.maxFramebufferHeight);

	if(m_useRenderPass)
	endRenderPass();

	log << tcu::TestLog::Message << "Horizontal granularity: " << granularity.width << " Vertical granularity: " << granularity.height << tcu::TestLog::EndMessage;
	return tcu::TestStatus::pass("Granularity test");
	}

	class GranularityCase : public vkt::TestCase
	{
	public:
	GranularityCase (tcu::TestContext& testCtx,
	const std::string& name,
	const std::string& description,
	const std::vector<AttachmentInfo>& attachments,
	const bool useRenderPass);
	virtual ~GranularityCase (void);

	virtual TestInstance* createInstance (Context& context) const;
	private:
	const std::vector<AttachmentInfo> m_attachments;
	const bool m_useRenderPass;
	};

	GranularityCase::GranularityCase (tcu::TestContext& testCtx,
	const std::string& name,
	const std::string& description,
	const std::vector<AttachmentInfo>& attachments,
	const bool useRenderPass = false)
	: vkt::TestCase (testCtx, name, description)
	, m_attachments (attachments)
	, m_useRenderPass (useRenderPass)
	{
	}

	GranularityCase::~GranularityCase (void)
	{
	}

	TestInstance* GranularityCase::createInstance (Context& context) const
	{
	return new GranularityInstance(context, m_attachments, m_useRenderPass);
	}

	} // anonymous

	tcu::TestCaseGroup* createGranularityQueryTests (tcu::TestContext& testCtx)
	{
	de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "granularity", "Granularity query tests"));
	// Subgroups
	de::MovePtr<tcu::TestCaseGroup> single (new tcu::TestCaseGroup(testCtx, "single", "Single texture granularity tests."));
	de::MovePtr<tcu::TestCaseGroup> multi (new tcu::TestCaseGroup(testCtx, "multi", "Multiple textures with same format granularity tests."));
	de::MovePtr<tcu::TestCaseGroup> random (new tcu::TestCaseGroup(testCtx, "random", "Multiple textures with a guaranteed format occurence."));
	de::MovePtr<tcu::TestCaseGroup> inRenderPass (new tcu::TestCaseGroup(testCtx, "in_render_pass", "Single texture granularity tests, inside render pass"));

	de::Random rnd(215);
	const char* description = "Granularity case.";

	const VkFormat mandatoryFormats[] =
	{
	VK_FORMAT_B4G4R4A4_UNORM_PACK16,
	VK_FORMAT_R5G6B5_UNORM_PACK16,
	VK_FORMAT_A1R5G5B5_UNORM_PACK16,
	VK_FORMAT_R8_UNORM,
	VK_FORMAT_R8_SNORM,
	VK_FORMAT_R8_UINT,
	VK_FORMAT_R8_SINT,
	VK_FORMAT_R8G8_UNORM,
	VK_FORMAT_R8G8_SNORM,
	VK_FORMAT_R8G8_UINT,
	VK_FORMAT_R8G8_SINT,
	VK_FORMAT_R8G8B8A8_UNORM,
	VK_FORMAT_R8G8B8A8_SNORM,
	VK_FORMAT_R8G8B8A8_UINT,
	VK_FORMAT_R8G8B8A8_SINT,
	VK_FORMAT_R8G8B8A8_SRGB,
	VK_FORMAT_B8G8R8A8_UNORM,
	VK_FORMAT_B8G8R8A8_SRGB,
	VK_FORMAT_A8B8G8R8_UNORM_PACK32,
	VK_FORMAT_A8B8G8R8_SNORM_PACK32,
	VK_FORMAT_A8B8G8R8_UINT_PACK32,
	VK_FORMAT_A8B8G8R8_SINT_PACK32,
	VK_FORMAT_A8B8G8R8_SRGB_PACK32,
	VK_FORMAT_A2B10G10R10_UNORM_PACK32,
	VK_FORMAT_A2B10G10R10_UINT_PACK32,
	VK_FORMAT_R16_UINT,
	VK_FORMAT_R16_SINT,
	VK_FORMAT_R16_SFLOAT,
	VK_FORMAT_R16G16_UINT,
	VK_FORMAT_R16G16_SINT,
	VK_FORMAT_R16G16_SFLOAT,
	VK_FORMAT_R16G16B16A16_UINT,
	VK_FORMAT_R16G16B16A16_SINT,
	VK_FORMAT_R16G16B16A16_SFLOAT,
	VK_FORMAT_R32_UINT,
	VK_FORMAT_R32_SINT,
	VK_FORMAT_R32_SFLOAT,
	VK_FORMAT_R32G32_UINT,
	VK_FORMAT_R32G32_SINT,
	VK_FORMAT_R32G32_SFLOAT,
	VK_FORMAT_R32G32B32A32_UINT,
	VK_FORMAT_R32G32B32A32_SINT,
	VK_FORMAT_R32G32B32A32_SFLOAT,
	VK_FORMAT_B10G11R11_UFLOAT_PACK32,
	VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
	VK_FORMAT_D16_UNORM,
	VK_FORMAT_D32_SFLOAT,
	};

	const deUint32 maxDimension = 500;
	const deUint32 minIteration = 2;
	const deUint32 maxIteration = 10;

	for (deUint32 formatIdx = 1; formatIdx <= VK_FORMAT_D32_SFLOAT_S8_UINT; ++formatIdx)
	{
	VkFormat format = VkFormat(formatIdx);
	std::string name = de::toLower(getFormatName(format)).substr(10);

	{
	std::vector<AttachmentInfo> attachments;
	const int i0 = rnd.getInt(1, maxDimension);
	const int i1 = rnd.getInt(1, maxDimension);
	attachments.push_back(AttachmentInfo(format, i0, i1, 1));
	single->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments));
	}

	{
	std::vector<AttachmentInfo> attachments;
	const deUint32 iterations = rnd.getInt(minIteration, maxIteration);
	const int i0 = rnd.getInt(1, maxDimension);
	const int i1 = rnd.getInt(1, maxDimension);
	for (deUint32 idx = 0; idx < iterations; ++idx)
	attachments.push_back(AttachmentInfo(VkFormat(formatIdx), i0, i1, 1));
	multi->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments));
	}

	{
	std::vector<AttachmentInfo> attachments;
	const deUint32 iterations = rnd.getInt(minIteration, maxIteration);
	const int i0 = rnd.getInt(1, maxDimension);
	const int i1 = rnd.getInt(1, maxDimension);
	attachments.push_back(AttachmentInfo(VkFormat(formatIdx), i0, i1, 1));
	for (deUint32 idx = 0; idx < iterations; ++idx)
	{
	const int i2 = rnd.getInt(0, DE_LENGTH_OF_ARRAY(mandatoryFormats) - 1);
	const int i3 = rnd.getInt(1, maxDimension);
	const int i4 = rnd.getInt(1, maxDimension);
	attachments.push_back(AttachmentInfo(mandatoryFormats[i2], i3, i4, 1));
	}
	random->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments));
	}

	{
	std::vector<AttachmentInfo> attachments;
	const int i0 = rnd.getInt(1, maxDimension);
	const int i1 = rnd.getInt(1, maxDimension);
	attachments.push_back(AttachmentInfo(format, i0, i1, 1));
	inRenderPass->addChild(new GranularityCase(testCtx, name.c_str(), description, attachments, true));
	}
	}

	group->addChild(single.release());
	group->addChild(multi.release());
	group->addChild(random.release());
	group->addChild(inRenderPass.release());

	return group.release();
	}

	} // api
	} // vkt