external/vulkancts/modules/vulkan/texture/vktTextureCompressedFormatTests.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2016 The Khronos Group Inc.
  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
  * Copyright (c) 2014 The Android Open Source Project
  *
  * 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 Compressed texture tests.
  *//*--------------------------------------------------------------------*/

 #include "vktTextureCompressedFormatTests.hpp"

 #include "deString.h"
 #include "deStringUtil.hpp"
 #include "tcuCompressedTexture.hpp"
 #include "tcuTexture.hpp"
 #include "tcuTextureUtil.hpp"
 #include "tcuAstcUtil.hpp"
 #include "vkImageUtil.hpp"
 #include "vktTestGroupUtil.hpp"
 #include "vktTextureTestUtil.hpp"
 #include <string>
 #include <vector>

 namespace vkt
 {
 namespace texture
 {
 namespace
 {

 using namespace vk;
 using namespace glu::TextureTestUtil;
 using namespace texture::util;

 using std::string;
 using std::vector;
 using tcu::Sampler;
 using tcu::TestLog;

 // Compressed formats
 static const struct {
 	const VkFormat	format;
 } formats[] =
 {
 	{ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK		},
 	{ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK		},
 	{ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK	},
 	{ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK	},
 	{ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK	},
 	{ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK	},

 	{ VK_FORMAT_EAC_R11_UNORM_BLOCK			},
 	{ VK_FORMAT_EAC_R11_SNORM_BLOCK			},
 	{ VK_FORMAT_EAC_R11G11_UNORM_BLOCK		},
 	{ VK_FORMAT_EAC_R11G11_SNORM_BLOCK		},

 	{ VK_FORMAT_ASTC_4x4_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_4x4_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_5x4_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_5x4_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_5x5_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_5x5_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_6x5_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_6x5_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_6x6_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_6x6_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_8x5_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_8x5_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_8x6_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_8x6_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_8x8_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_8x8_SRGB_BLOCK			},
 	{ VK_FORMAT_ASTC_10x5_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_10x5_SRGB_BLOCK		},
 	{ VK_FORMAT_ASTC_10x6_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_10x6_SRGB_BLOCK		},
 	{ VK_FORMAT_ASTC_10x8_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_10x8_SRGB_BLOCK		},
 	{ VK_FORMAT_ASTC_10x10_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_10x10_SRGB_BLOCK		},
 	{ VK_FORMAT_ASTC_12x10_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_12x10_SRGB_BLOCK		},
 	{ VK_FORMAT_ASTC_12x12_UNORM_BLOCK		},
 	{ VK_FORMAT_ASTC_12x12_SRGB_BLOCK		},

 	{ VK_FORMAT_BC1_RGB_UNORM_BLOCK			},
 	{ VK_FORMAT_BC1_RGB_SRGB_BLOCK			},
 	{ VK_FORMAT_BC1_RGBA_UNORM_BLOCK		},
 	{ VK_FORMAT_BC1_RGBA_SRGB_BLOCK			},
 	{ VK_FORMAT_BC2_UNORM_BLOCK				},
 	{ VK_FORMAT_BC2_SRGB_BLOCK				},
 	{ VK_FORMAT_BC3_UNORM_BLOCK				},
 	{ VK_FORMAT_BC3_SRGB_BLOCK				},
 	{ VK_FORMAT_BC4_UNORM_BLOCK				},
 	{ VK_FORMAT_BC4_SNORM_BLOCK				},
 	{ VK_FORMAT_BC5_UNORM_BLOCK				},
 	{ VK_FORMAT_BC5_SNORM_BLOCK				},
 	{ VK_FORMAT_BC6H_UFLOAT_BLOCK			},
 	{ VK_FORMAT_BC6H_SFLOAT_BLOCK			},
 	{ VK_FORMAT_BC7_UNORM_BLOCK				},
 	{ VK_FORMAT_BC7_SRGB_BLOCK				}
 };

 static const struct {
 	const int	width;
 	const int	height;
 	const int   depth;		// 2D test ignore depth value
 	const char*	name;
 } sizes[] =
 {
 	{ 128, 64, 8,  "pot"  },
 	{ 51,  65, 17, "npot" },
 };

 static const struct {
 	const char*								name;
 	const TextureBinding::ImageBackingMode	backingMode;
 } backingModes[] =
 {
 	{ "",			TextureBinding::IMAGE_BACKING_MODE_REGULAR	},
 	{ "_sparse",	TextureBinding::IMAGE_BACKING_MODE_SPARSE	}
 };

 struct Compressed3DTestParameters : public Texture3DTestCaseParameters
 {
 										Compressed3DTestParameters	(void);
 	TextureBinding::ImageBackingMode	backingMode;
 };

 Compressed3DTestParameters::Compressed3DTestParameters (void)
 	: backingMode(TextureBinding::IMAGE_BACKING_MODE_REGULAR)
 {
 }

 struct Compressed2DTestParameters : public Texture2DTestCaseParameters
 {
 										Compressed2DTestParameters	(void);
 	TextureBinding::ImageBackingMode	backingMode;
 };

 Compressed2DTestParameters::Compressed2DTestParameters (void)
 	: backingMode(TextureBinding::IMAGE_BACKING_MODE_REGULAR)
 {
 }

 class Compressed2DTestInstance : public TestInstance
 {
 public:
 	typedef Compressed2DTestParameters	ParameterType;

 										Compressed2DTestInstance	(Context&				context,
 																	 const ParameterType&	testParameters);
 	tcu::TestStatus						iterate						(void);

 private:
 										Compressed2DTestInstance	(const Compressed2DTestInstance& other);
 	Compressed2DTestInstance&			operator=					(const Compressed2DTestInstance& other);

 	const ParameterType&				m_testParameters;
 	const tcu::CompressedTexFormat		m_compressedFormat;
 	TestTexture2DSp						m_texture;
 	TextureRenderer						m_renderer;
 };

 Compressed2DTestInstance::Compressed2DTestInstance (Context&				context,
 													const ParameterType&	testParameters)
 	: TestInstance			(context)
 	, m_testParameters		(testParameters)
 	, m_compressedFormat	(mapVkCompressedFormat(testParameters.format))
 	, m_texture				(TestTexture2DSp(new pipeline::TestTexture2D(m_compressedFormat, testParameters.width, testParameters.height)))
 	, m_renderer			(context, testParameters.sampleCount, testParameters.width, testParameters.height)
 {
 	m_renderer.add2DTexture(m_texture, testParameters.aspectMask, testParameters.backingMode);
 }

 tcu::TestStatus Compressed2DTestInstance::iterate (void)
 {
 	tcu::TestLog&					log				= m_context.getTestContext().getLog();
 	const pipeline::TestTexture2D&	texture			= m_renderer.get2DTexture(0);
 	const tcu::TextureFormat		textureFormat	= texture.getTextureFormat();
 	const tcu::TextureFormatInfo	formatInfo		= tcu::getTextureFormatInfo(textureFormat);

 	ReferenceParams					sampleParams	(TEXTURETYPE_2D);
 	tcu::Surface					rendered		(m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
 	vector<float>					texCoord;

 	// Setup params for reference.
 	sampleParams.sampler			= util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter);
 	sampleParams.samplerType		= SAMPLERTYPE_FLOAT;
 	sampleParams.lodMode			= LODMODE_EXACT;

 	if (isAstcFormat(m_compressedFormat)
 		|| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK
 		|| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK)
 	{
 		sampleParams.colorBias			= tcu::Vec4(0.0f);
 		sampleParams.colorScale			= tcu::Vec4(1.0f);
 	}
 	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK)
 	{
 		sampleParams.colorBias			= tcu::Vec4(0.5f, 0.0f, 0.0f, 0.0f);
 		sampleParams.colorScale			= tcu::Vec4(0.5f, 1.0f, 1.0f, 1.0f);
 	}
 	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK)
 	{
 		sampleParams.colorBias			= tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f);
 		sampleParams.colorScale			= tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f);
 	}
 	else
 	{
 		sampleParams.colorBias			= formatInfo.lookupBias;
 		sampleParams.colorScale			= formatInfo.lookupScale;
 	}

 	log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;

 	// Compute texture coordinates.
 	computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));

 	m_renderer.renderQuad(rendered, 0, &texCoord[0], sampleParams);

 	// Compute reference.
 	const tcu::IVec4		formatBitDepth	= getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
 	const tcu::PixelFormat	pixelFormat		(formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
 	tcu::Surface			referenceFrame	(m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
 	sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat), m_texture->getTexture(), &texCoord[0], sampleParams);

 	// Compare and log.
 	tcu::RGBA threshold;

 	if (isBcBitExactFormat(m_compressedFormat))
 		threshold = tcu::RGBA(1, 1, 1, 1);
 	else if (isBcFormat(m_compressedFormat))
 		threshold = tcu::RGBA(8, 8, 8, 8);
 	else
 		threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);

 	const bool isOk = compareImages(log, referenceFrame, rendered, threshold);

 	return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
 }

 class Compressed3DTestInstance : public TestInstance
 {
 public:
 	typedef Compressed3DTestParameters	ParameterType;

 										Compressed3DTestInstance	(Context&				context,
 																	 const ParameterType&	testParameters);
 	tcu::TestStatus						iterate						(void);

 private:
 										Compressed3DTestInstance	(const Compressed3DTestInstance& other);
 	Compressed3DTestInstance&			operator=					(const Compressed3DTestInstance& other);

 	const ParameterType&				m_testParameters;
 	const tcu::CompressedTexFormat		m_compressedFormat;
 	TestTexture3DSp						m_texture3D;
 	TextureRenderer						m_renderer3D;
 };

 Compressed3DTestInstance::Compressed3DTestInstance (Context&				context,
 													const ParameterType&	testParameters)
 	: TestInstance			(context)
 	, m_testParameters		(testParameters)
 	, m_compressedFormat	(mapVkCompressedFormat(testParameters.format))
 	, m_texture3D			(TestTexture3DSp(new pipeline::TestTexture3D(m_compressedFormat, testParameters.width, testParameters.height, testParameters.depth)))
 	, m_renderer3D			(context, testParameters.sampleCount, testParameters.width, testParameters.height, testParameters.depth, makeComponentMappingRGBA(), VK_IMAGE_TYPE_3D, VK_IMAGE_VIEW_TYPE_3D)
 {
 	m_renderer3D.add3DTexture		(m_texture3D, testParameters.aspectMask, testParameters.backingMode);

 	VkPhysicalDeviceFeatures		physicalFeatures;
 	context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &physicalFeatures);

 	if (tcu::isAstcFormat(m_compressedFormat))
 	{
 		if (!physicalFeatures.textureCompressionASTC_LDR)
 			throw tcu::NotSupportedError(std::string("Unsupported format: ") + getFormatName(testParameters.format));
 	}
 	else if (tcu::isEtcFormat(m_compressedFormat))
 	{
 		if (!physicalFeatures.textureCompressionETC2)
 			throw tcu::NotSupportedError(std::string("Unsupported format: ") + getFormatName(testParameters.format));
 	}
 	else if(tcu::isBcFormat(m_compressedFormat))
 	{
 		if (!physicalFeatures.textureCompressionBC)
 			throw tcu::NotSupportedError(std::string("Unsupported format: ") + getFormatName(testParameters.format));
 	}
 	else
 	{
 		DE_FATAL("Unsupported compressed format");
 	}
 }

 tcu::TestStatus Compressed3DTestInstance::iterate (void)
 {
 	tcu::TestLog&					log				= m_context.getTestContext().getLog();
 	const pipeline::TestTexture3D&	texture			= m_renderer3D.get3DTexture(0);
 	const tcu::TextureFormat		textureFormat	= texture.getTextureFormat();
 	const tcu::TextureFormatInfo	formatInfo		= tcu::getTextureFormatInfo(textureFormat);

 	ReferenceParams					sampleParams	(TEXTURETYPE_3D);
 	tcu::Surface					rendered		(m_renderer3D.getRenderWidth(), m_renderer3D.getRenderHeight());
 	vector<float>					texCoord;

 	// Setup params for reference.
 	sampleParams.sampler			= util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter);
 	sampleParams.samplerType		= SAMPLERTYPE_FLOAT;
 	sampleParams.lodMode			= LODMODE_EXACT;

 	if (isAstcFormat(m_compressedFormat)
 		|| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK
 		|| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK)
 	{
 		sampleParams.colorBias			= tcu::Vec4(0.0f);
 		sampleParams.colorScale			= tcu::Vec4(1.0f);
 	}
 	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK)
 	{
 		sampleParams.colorBias			= tcu::Vec4(0.5f, 0.0f, 0.0f, 0.0f);
 		sampleParams.colorScale			= tcu::Vec4(0.5f, 1.0f, 1.0f, 1.0f);
 	}
 	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK)
 	{
 		sampleParams.colorBias			= tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f);
 		sampleParams.colorScale			= tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f);
 	}
 	else
 	{
 		sampleParams.colorBias			= formatInfo.lookupBias;
 		sampleParams.colorScale			= formatInfo.lookupScale;
 	}

 	log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;

 	constexpr deUint32		slices			= 3;
 	deUint32				sliceNdx		= 0;
 	float					z				= 0;
 	bool					isOk			= false;
 	const tcu::IVec4		formatBitDepth	= getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
 	const tcu::PixelFormat	pixelFormat	(formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
 	tcu::RGBA				threshold;

 	if (isBcBitExactFormat(m_compressedFormat))
 		threshold = tcu::RGBA(1, 1, 1, 1);
 	else if (isBcSRGBFormat(m_compressedFormat))
 		threshold = tcu::RGBA(9, 9, 9, 9);
 	else if (isBcFormat(m_compressedFormat))
 		threshold = tcu::RGBA(8, 8, 8, 8);
 	else
 		threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);

 	for (deUint32 s = 0; s < slices; ++s)
 	{
 		// Test different slices of 3D texture.

 		sliceNdx = (m_testParameters.depth - 1) * s / (slices - 1);

 		// Render texture.
 		z = ((float)sliceNdx + 0.5f) / (float)m_testParameters.depth;
 		computeQuadTexCoord3D(texCoord, tcu::Vec3(0.0f, 0.0f, z), tcu::Vec3(1.0f, 1.0f, z), tcu::IVec3(0,1,2));
 		m_renderer3D.renderQuad(rendered, 0, &texCoord[0], sampleParams);

 		// Compute reference.
 		tcu::Surface referenceFrame	(m_renderer3D.getRenderWidth(), m_renderer3D.getRenderHeight());
 		sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat), m_texture3D->getTexture(), &texCoord[0], sampleParams);

 		// Compare and log.
 		isOk = compareImages(log, referenceFrame, rendered, threshold);

 		if (!isOk)
 			break;
 	}

 	return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
 }

 } // anonymous

 void populateTextureCompressedFormatTests (tcu::TestCaseGroup* compressedTextureTests)
 {
 	tcu::TestContext&	testCtx	= compressedTextureTests->getTestContext();

 	for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); sizeNdx++)
 	for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
 	for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
 	{
 		const string	formatStr	= de::toString(getFormatStr(formats[formatNdx].format));
 		const string	nameBase	= de::toLower(formatStr.substr(10));

 		Compressed2DTestParameters	testParameters;
 		testParameters.format		= formats[formatNdx].format;
 		testParameters.backingMode	= backingModes[backingNdx].backingMode;
 		testParameters.width		= sizes[sizeNdx].width;
 		testParameters.height		= sizes[sizeNdx].height;
 		testParameters.minFilter	= tcu::Sampler::NEAREST;
 		testParameters.magFilter	= tcu::Sampler::NEAREST;
 		testParameters.aspectMask	= VK_IMAGE_ASPECT_COLOR_BIT;
 		testParameters.programs.push_back(PROGRAM_2D_FLOAT);

 		compressedTextureTests->addChild(new TextureTestCase<Compressed2DTestInstance>(testCtx, (nameBase + "_2d_" + sizes[sizeNdx].name + backingModes[backingNdx].name).c_str(), (formatStr + ", TEXTURETYPE_2D").c_str(), testParameters));
 	}
 }

 void populate3DTextureCompressedFormatTests (tcu::TestCaseGroup* compressedTextureTests)
 {
 	tcu::TestContext&	testCtx	= compressedTextureTests->getTestContext();

 	for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx)
 	for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
 	for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); ++backingNdx)
 	{
 		const string	formatStr	= de::toString(getFormatStr(formats[formatNdx].format));
 		const string	nameBase	= de::toLower(formatStr.substr(10));

 		Compressed3DTestParameters	testParameters;
 		testParameters.format		= formats[formatNdx].format;
 		testParameters.backingMode	= backingModes[backingNdx].backingMode;
 		testParameters.width		= sizes[sizeNdx].width;
 		testParameters.height		= sizes[sizeNdx].height;
 		testParameters.depth        = sizes[sizeNdx].depth;
 		testParameters.minFilter	= tcu::Sampler::NEAREST;
 		testParameters.magFilter	= tcu::Sampler::NEAREST;
 		testParameters.aspectMask	= VK_IMAGE_ASPECT_COLOR_BIT;
 		testParameters.programs.push_back(PROGRAM_3D_FLOAT);

 		compressedTextureTests->addChild(new TextureTestCase<Compressed3DTestInstance>(testCtx, (nameBase + "_3d_" + sizes[sizeNdx].name + backingModes[backingNdx].name).c_str(), (formatStr + ", TEXTURETYPE_3D").c_str(), testParameters));
 	}
 }

 tcu::TestCaseGroup* createTextureCompressedFormatTests (tcu::TestContext& testCtx)
 {
 	return createTestGroup(testCtx, "compressed", "Texture compressed format tests.", populateTextureCompressedFormatTests);
 }

 tcu::TestCaseGroup* create3DTextureCompressedFormatTests (tcu::TestContext& testCtx)
 {
 	return createTestGroup(testCtx, "compressed_3D", "3D texture compressed format tests.", populate3DTextureCompressedFormatTests);
 }

 } // texture
 } // vkt
	/*-------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2016 The Khronos Group Inc.
	* Copyright (c) 2016 Samsung Electronics Co., Ltd.
	* Copyright (c) 2014 The Android Open Source Project
	*
	* 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 Compressed texture tests.
	//--------------------------------------------------------------------*/

	#include "vktTextureCompressedFormatTests.hpp"

	#include "deString.h"
	#include "deStringUtil.hpp"
	#include "tcuCompressedTexture.hpp"
	#include "tcuTexture.hpp"
	#include "tcuTextureUtil.hpp"
	#include "tcuAstcUtil.hpp"
	#include "vkImageUtil.hpp"
	#include "vktTestGroupUtil.hpp"
	#include "vktTextureTestUtil.hpp"
	#include <string>
	#include <vector>

	namespace vkt
	{
	namespace texture
	{
	namespace
	{

	using namespace vk;
	using namespace glu::TextureTestUtil;
	using namespace texture::util;

	using std::string;
	using std::vector;
	using tcu::Sampler;
	using tcu::TestLog;

	// Compressed formats
	static const struct {
	const VkFormat format;
	} formats[] =
	{
	{ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK },
	{ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK },
	{ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK },
	{ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK },
	{ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK },
	{ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK },

	{ VK_FORMAT_EAC_R11_UNORM_BLOCK },
	{ VK_FORMAT_EAC_R11_SNORM_BLOCK },
	{ VK_FORMAT_EAC_R11G11_UNORM_BLOCK },
	{ VK_FORMAT_EAC_R11G11_SNORM_BLOCK },

	{ VK_FORMAT_ASTC_4x4_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_4x4_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_5x4_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_5x4_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_5x5_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_5x5_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_6x5_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_6x5_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_6x6_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_6x6_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_8x5_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_8x5_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_8x6_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_8x6_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_8x8_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_8x8_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_10x5_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_10x5_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_10x6_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_10x6_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_10x8_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_10x8_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_10x10_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_10x10_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_12x10_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_12x10_SRGB_BLOCK },
	{ VK_FORMAT_ASTC_12x12_UNORM_BLOCK },
	{ VK_FORMAT_ASTC_12x12_SRGB_BLOCK },

	{ VK_FORMAT_BC1_RGB_UNORM_BLOCK },
	{ VK_FORMAT_BC1_RGB_SRGB_BLOCK },
	{ VK_FORMAT_BC1_RGBA_UNORM_BLOCK },
	{ VK_FORMAT_BC1_RGBA_SRGB_BLOCK },
	{ VK_FORMAT_BC2_UNORM_BLOCK },
	{ VK_FORMAT_BC2_SRGB_BLOCK },
	{ VK_FORMAT_BC3_UNORM_BLOCK },
	{ VK_FORMAT_BC3_SRGB_BLOCK },
	{ VK_FORMAT_BC4_UNORM_BLOCK },
	{ VK_FORMAT_BC4_SNORM_BLOCK },
	{ VK_FORMAT_BC5_UNORM_BLOCK },
	{ VK_FORMAT_BC5_SNORM_BLOCK },
	{ VK_FORMAT_BC6H_UFLOAT_BLOCK },
	{ VK_FORMAT_BC6H_SFLOAT_BLOCK },
	{ VK_FORMAT_BC7_UNORM_BLOCK },
	{ VK_FORMAT_BC7_SRGB_BLOCK }
	};

	static const struct {
	const int width;
	const int height;
	const int depth; // 2D test ignore depth value
	const char* name;
	} sizes[] =
	{
	{ 128, 64, 8, "pot" },
	{ 51, 65, 17, "npot" },
	};

	static const struct {
	const char* name;
	const TextureBinding::ImageBackingMode backingMode;
	} backingModes[] =
	{
	{ "", TextureBinding::IMAGE_BACKING_MODE_REGULAR },
	{ "_sparse", TextureBinding::IMAGE_BACKING_MODE_SPARSE }
	};

	struct Compressed3DTestParameters : public Texture3DTestCaseParameters
	{
	Compressed3DTestParameters (void);
	TextureBinding::ImageBackingMode backingMode;
	};

	Compressed3DTestParameters::Compressed3DTestParameters (void)
	: backingMode(TextureBinding::IMAGE_BACKING_MODE_REGULAR)
	{
	}

	struct Compressed2DTestParameters : public Texture2DTestCaseParameters
	{
	Compressed2DTestParameters (void);
	TextureBinding::ImageBackingMode backingMode;
	};

	Compressed2DTestParameters::Compressed2DTestParameters (void)
	: backingMode(TextureBinding::IMAGE_BACKING_MODE_REGULAR)
	{
	}

	class Compressed2DTestInstance : public TestInstance
	{
	public:
	typedef Compressed2DTestParameters ParameterType;

	Compressed2DTestInstance (Context& context,
	const ParameterType& testParameters);
	tcu::TestStatus iterate (void);

	private:
	Compressed2DTestInstance (const Compressed2DTestInstance& other);
	Compressed2DTestInstance& operator= (const Compressed2DTestInstance& other);

	const ParameterType& m_testParameters;
	const tcu::CompressedTexFormat m_compressedFormat;
	TestTexture2DSp m_texture;
	TextureRenderer m_renderer;
	};

	Compressed2DTestInstance::Compressed2DTestInstance (Context& context,
	const ParameterType& testParameters)
	: TestInstance (context)
	, m_testParameters (testParameters)
	, m_compressedFormat (mapVkCompressedFormat(testParameters.format))
	, m_texture (TestTexture2DSp(new pipeline::TestTexture2D(m_compressedFormat, testParameters.width, testParameters.height)))
	, m_renderer (context, testParameters.sampleCount, testParameters.width, testParameters.height)
	{
	m_renderer.add2DTexture(m_texture, testParameters.aspectMask, testParameters.backingMode);
	}

	tcu::TestStatus Compressed2DTestInstance::iterate (void)
	{
	tcu::TestLog& log = m_context.getTestContext().getLog();
	const pipeline::TestTexture2D& texture = m_renderer.get2DTexture(0);
	const tcu::TextureFormat textureFormat = texture.getTextureFormat();
	const tcu::TextureFormatInfo formatInfo = tcu::getTextureFormatInfo(textureFormat);

	ReferenceParams sampleParams (TEXTURETYPE_2D);
	tcu::Surface rendered (m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
	vector<float> texCoord;

	// Setup params for reference.
	sampleParams.sampler = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter);
	sampleParams.samplerType = SAMPLERTYPE_FLOAT;
	sampleParams.lodMode = LODMODE_EXACT;

	if (isAstcFormat(m_compressedFormat)
	\|\| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK
	\|\| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK)
	{
	sampleParams.colorBias = tcu::Vec4(0.0f);
	sampleParams.colorScale = tcu::Vec4(1.0f);
	}
	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK)
	{
	sampleParams.colorBias = tcu::Vec4(0.5f, 0.0f, 0.0f, 0.0f);
	sampleParams.colorScale = tcu::Vec4(0.5f, 1.0f, 1.0f, 1.0f);
	}
	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK)
	{
	sampleParams.colorBias = tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f);
	sampleParams.colorScale = tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f);
	}
	else
	{
	sampleParams.colorBias = formatInfo.lookupBias;
	sampleParams.colorScale = formatInfo.lookupScale;
	}

	log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;

	// Compute texture coordinates.
	computeQuadTexCoord2D(texCoord, tcu::Vec2(0.0f, 0.0f), tcu::Vec2(1.0f, 1.0f));

	m_renderer.renderQuad(rendered, 0, &texCoord[0], sampleParams);

	// Compute reference.
	const tcu::IVec4 formatBitDepth = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
	const tcu::PixelFormat pixelFormat (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
	tcu::Surface referenceFrame (m_renderer.getRenderWidth(), m_renderer.getRenderHeight());
	sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat), m_texture->getTexture(), &texCoord[0], sampleParams);

	// Compare and log.
	tcu::RGBA threshold;

	if (isBcBitExactFormat(m_compressedFormat))
	threshold = tcu::RGBA(1, 1, 1, 1);
	else if (isBcFormat(m_compressedFormat))
	threshold = tcu::RGBA(8, 8, 8, 8);
	else
	threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);

	const bool isOk = compareImages(log, referenceFrame, rendered, threshold);

	return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
	}

	class Compressed3DTestInstance : public TestInstance
	{
	public:
	typedef Compressed3DTestParameters ParameterType;

	Compressed3DTestInstance (Context& context,
	const ParameterType& testParameters);
	tcu::TestStatus iterate (void);

	private:
	Compressed3DTestInstance (const Compressed3DTestInstance& other);
	Compressed3DTestInstance& operator= (const Compressed3DTestInstance& other);

	const ParameterType& m_testParameters;
	const tcu::CompressedTexFormat m_compressedFormat;
	TestTexture3DSp m_texture3D;
	TextureRenderer m_renderer3D;
	};

	Compressed3DTestInstance::Compressed3DTestInstance (Context& context,
	const ParameterType& testParameters)
	: TestInstance (context)
	, m_testParameters (testParameters)
	, m_compressedFormat (mapVkCompressedFormat(testParameters.format))
	, m_texture3D (TestTexture3DSp(new pipeline::TestTexture3D(m_compressedFormat, testParameters.width, testParameters.height, testParameters.depth)))
	, m_renderer3D (context, testParameters.sampleCount, testParameters.width, testParameters.height, testParameters.depth, makeComponentMappingRGBA(), VK_IMAGE_TYPE_3D, VK_IMAGE_VIEW_TYPE_3D)
	{
	m_renderer3D.add3DTexture (m_texture3D, testParameters.aspectMask, testParameters.backingMode);

	VkPhysicalDeviceFeatures physicalFeatures;
	context.getInstanceInterface().getPhysicalDeviceFeatures(context.getPhysicalDevice(), &physicalFeatures);

	if (tcu::isAstcFormat(m_compressedFormat))
	{
	if (!physicalFeatures.textureCompressionASTC_LDR)
	throw tcu::NotSupportedError(std::string("Unsupported format: ") + getFormatName(testParameters.format));
	}
	else if (tcu::isEtcFormat(m_compressedFormat))
	{
	if (!physicalFeatures.textureCompressionETC2)
	throw tcu::NotSupportedError(std::string("Unsupported format: ") + getFormatName(testParameters.format));
	}
	else if(tcu::isBcFormat(m_compressedFormat))
	{
	if (!physicalFeatures.textureCompressionBC)
	throw tcu::NotSupportedError(std::string("Unsupported format: ") + getFormatName(testParameters.format));
	}
	else
	{
	DE_FATAL("Unsupported compressed format");
	}
	}

	tcu::TestStatus Compressed3DTestInstance::iterate (void)
	{
	tcu::TestLog& log = m_context.getTestContext().getLog();
	const pipeline::TestTexture3D& texture = m_renderer3D.get3DTexture(0);
	const tcu::TextureFormat textureFormat = texture.getTextureFormat();
	const tcu::TextureFormatInfo formatInfo = tcu::getTextureFormatInfo(textureFormat);

	ReferenceParams sampleParams (TEXTURETYPE_3D);
	tcu::Surface rendered (m_renderer3D.getRenderWidth(), m_renderer3D.getRenderHeight());
	vector<float> texCoord;

	// Setup params for reference.
	sampleParams.sampler = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter);
	sampleParams.samplerType = SAMPLERTYPE_FLOAT;
	sampleParams.lodMode = LODMODE_EXACT;

	if (isAstcFormat(m_compressedFormat)
	\|\| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK
	\|\| m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK)
	{
	sampleParams.colorBias = tcu::Vec4(0.0f);
	sampleParams.colorScale = tcu::Vec4(1.0f);
	}
	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK)
	{
	sampleParams.colorBias = tcu::Vec4(0.5f, 0.0f, 0.0f, 0.0f);
	sampleParams.colorScale = tcu::Vec4(0.5f, 1.0f, 1.0f, 1.0f);
	}
	else if (m_compressedFormat == tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK)
	{
	sampleParams.colorBias = tcu::Vec4(0.5f, 0.5f, 0.0f, 0.0f);
	sampleParams.colorScale = tcu::Vec4(0.5f, 0.5f, 1.0f, 1.0f);
	}
	else
	{
	sampleParams.colorBias = formatInfo.lookupBias;
	sampleParams.colorScale = formatInfo.lookupScale;
	}

	log << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage;

	constexpr deUint32 slices = 3;
	deUint32 sliceNdx = 0;
	float z = 0;
	bool isOk = false;
	const tcu::IVec4 formatBitDepth = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
	const tcu::PixelFormat pixelFormat (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
	tcu::RGBA threshold;

	if (isBcBitExactFormat(m_compressedFormat))
	threshold = tcu::RGBA(1, 1, 1, 1);
	else if (isBcSRGBFormat(m_compressedFormat))
	threshold = tcu::RGBA(9, 9, 9, 9);
	else if (isBcFormat(m_compressedFormat))
	threshold = tcu::RGBA(8, 8, 8, 8);
	else
	threshold = pixelFormat.getColorThreshold() + tcu::RGBA(2, 2, 2, 2);

	for (deUint32 s = 0; s < slices; ++s)
	{
	// Test different slices of 3D texture.

	sliceNdx = (m_testParameters.depth - 1) * s / (slices - 1);

	// Render texture.
	z = ((float)sliceNdx + 0.5f) / (float)m_testParameters.depth;
	computeQuadTexCoord3D(texCoord, tcu::Vec3(0.0f, 0.0f, z), tcu::Vec3(1.0f, 1.0f, z), tcu::IVec3(0,1,2));
	m_renderer3D.renderQuad(rendered, 0, &texCoord[0], sampleParams);

	// Compute reference.
	tcu::Surface referenceFrame (m_renderer3D.getRenderWidth(), m_renderer3D.getRenderHeight());
	sampleTexture(tcu::SurfaceAccess(referenceFrame, pixelFormat), m_texture3D->getTexture(), &texCoord[0], sampleParams);

	// Compare and log.
	isOk = compareImages(log, referenceFrame, rendered, threshold);

	if (!isOk)
	break;
	}

	return isOk ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Image verification failed");
	}

	} // anonymous

	void populateTextureCompressedFormatTests (tcu::TestCaseGroup* compressedTextureTests)
	{
	tcu::TestContext& testCtx = compressedTextureTests->getTestContext();

	for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); sizeNdx++)
	for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
	for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); backingNdx++)
	{
	const string formatStr = de::toString(getFormatStr(formats[formatNdx].format));
	const string nameBase = de::toLower(formatStr.substr(10));

	Compressed2DTestParameters testParameters;
	testParameters.format = formats[formatNdx].format;
	testParameters.backingMode = backingModes[backingNdx].backingMode;
	testParameters.width = sizes[sizeNdx].width;
	testParameters.height = sizes[sizeNdx].height;
	testParameters.minFilter = tcu::Sampler::NEAREST;
	testParameters.magFilter = tcu::Sampler::NEAREST;
	testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	testParameters.programs.push_back(PROGRAM_2D_FLOAT);

	compressedTextureTests->addChild(new TextureTestCase<Compressed2DTestInstance>(testCtx, (nameBase + "_2d_" + sizes[sizeNdx].name + backingModes[backingNdx].name).c_str(), (formatStr + ", TEXTURETYPE_2D").c_str(), testParameters));
	}
	}

	void populate3DTextureCompressedFormatTests (tcu::TestCaseGroup* compressedTextureTests)
	{
	tcu::TestContext& testCtx = compressedTextureTests->getTestContext();

	for (int sizeNdx = 0; sizeNdx < DE_LENGTH_OF_ARRAY(sizes); ++sizeNdx)
	for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); ++formatNdx)
	for (int backingNdx = 0; backingNdx < DE_LENGTH_OF_ARRAY(backingModes); ++backingNdx)
	{
	const string formatStr = de::toString(getFormatStr(formats[formatNdx].format));
	const string nameBase = de::toLower(formatStr.substr(10));

	Compressed3DTestParameters testParameters;
	testParameters.format = formats[formatNdx].format;
	testParameters.backingMode = backingModes[backingNdx].backingMode;
	testParameters.width = sizes[sizeNdx].width;
	testParameters.height = sizes[sizeNdx].height;
	testParameters.depth = sizes[sizeNdx].depth;
	testParameters.minFilter = tcu::Sampler::NEAREST;
	testParameters.magFilter = tcu::Sampler::NEAREST;
	testParameters.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	testParameters.programs.push_back(PROGRAM_3D_FLOAT);

	compressedTextureTests->addChild(new TextureTestCase<Compressed3DTestInstance>(testCtx, (nameBase + "_3d_" + sizes[sizeNdx].name + backingModes[backingNdx].name).c_str(), (formatStr + ", TEXTURETYPE_3D").c_str(), testParameters));
	}
	}

	tcu::TestCaseGroup* createTextureCompressedFormatTests (tcu::TestContext& testCtx)
	{
	return createTestGroup(testCtx, "compressed", "Texture compressed format tests.", populateTextureCompressedFormatTests);
	}

	tcu::TestCaseGroup* create3DTextureCompressedFormatTests (tcu::TestContext& testCtx)
	{
	return createTestGroup(testCtx, "compressed_3D", "3D texture compressed format tests.", populate3DTextureCompressedFormatTests);
	}

	} // texture
	} // vkt