Google Git
Sign in
fuchsia / third_party / vulkan-cts / 6694bda1d8d0d105d4ac1c907bb7c92bf83b45bd / . / external / vulkancts / framework / vulkan / vkImageUtil.cpp
blob: b629e8f588d8f54931ed1acee21481aba46990a9 [file] [log] [blame]
/*-------------------------------------------------------------------------
* Vulkan CTS Framework
* --------------------
*
* Copyright (c) 2015 The Khronos Group Inc.
* Copyright (c) 2015 Imagination Technologies Ltd.
* Copyright (c) 2015 Google Inc.
*
* 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 Utilities for images.
*//*--------------------------------------------------------------------*/
#include "vkImageUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "deMath.h"
#include <map>
#include <assert.h>
namespace vk
{
bool isFloatFormat (VkFormat format)
{
return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
}
bool isUnormFormat (VkFormat format)
{
return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
}
bool isSnormFormat (VkFormat format)
{
return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
}
bool isIntFormat (VkFormat format)
{
return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER;
}
bool isUintFormat (VkFormat format)
{
return tcu::getTextureChannelClass(mapVkFormat(format).type) == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
}
bool isDepthStencilFormat (VkFormat format)
{
if (isCompressedFormat(format))
return false;
if (isYCbCrFormat(format))
return false;
const tcu::TextureFormat tcuFormat = mapVkFormat(format);
return tcuFormat.order == tcu::TextureFormat::D || tcuFormat.order == tcu::TextureFormat::S || tcuFormat.order == tcu::TextureFormat::DS;
}
bool isSrgbFormat (VkFormat format)
{
switch (mapVkFormat(format).order)
{
case tcu::TextureFormat::sR:
case tcu::TextureFormat::sRG:
case tcu::TextureFormat::sRGB:
case tcu::TextureFormat::sRGBA:
case tcu::TextureFormat::sBGR:
case tcu::TextureFormat::sBGRA:
return true;
default:
return false;
}
}
bool isUfloatFormat (VkFormat format)
{
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (format)
{
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
return true;
default:
return false;
}
}
bool isSfloatFormat (VkFormat format)
{
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (format)
{
case VK_FORMAT_R16_SFLOAT:
case VK_FORMAT_R16G16_SFLOAT:
case VK_FORMAT_R16G16B16_SFLOAT:
case VK_FORMAT_R16G16B16A16_SFLOAT:
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_R32G32_SFLOAT:
case VK_FORMAT_R32G32B32_SFLOAT:
case VK_FORMAT_R32G32B32A32_SFLOAT:
case VK_FORMAT_R64_SFLOAT:
case VK_FORMAT_R64G64_SFLOAT:
case VK_FORMAT_R64G64B64_SFLOAT:
case VK_FORMAT_R64G64B64A64_SFLOAT:
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_BC6H_SFLOAT_BLOCK:
return true;
default:
return false;
}
}
bool isCompressedFormat (VkFormat format)
{
// update this mapping if VkFormat changes
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (format)
{
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
case VK_FORMAT_BC2_UNORM_BLOCK:
case VK_FORMAT_BC2_SRGB_BLOCK:
case VK_FORMAT_BC3_UNORM_BLOCK:
case VK_FORMAT_BC3_SRGB_BLOCK:
case VK_FORMAT_BC4_UNORM_BLOCK:
case VK_FORMAT_BC4_SNORM_BLOCK:
case VK_FORMAT_BC5_UNORM_BLOCK:
case VK_FORMAT_BC5_SNORM_BLOCK:
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
case VK_FORMAT_BC6H_SFLOAT_BLOCK:
case VK_FORMAT_BC7_UNORM_BLOCK:
case VK_FORMAT_BC7_SRGB_BLOCK:
case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
case VK_FORMAT_EAC_R11_UNORM_BLOCK:
case VK_FORMAT_EAC_R11_SNORM_BLOCK:
case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
return true;
default:
return false;
}
}
bool isYCbCrFormat (VkFormat format)
{
switch (format)
{
case VK_FORMAT_G8B8G8R8_422_UNORM:
case VK_FORMAT_B8G8R8G8_422_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
case VK_FORMAT_R10X6_UNORM_PACK16:
case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
case VK_FORMAT_R12X4_UNORM_PACK16:
case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
case VK_FORMAT_G16B16G16R16_422_UNORM:
case VK_FORMAT_B16G16R16G16_422_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
return true;
default:
return false;
}
}
bool isYCbCrExtensionFormat (VkFormat format)
{
switch (format)
{
case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
return true;
default:
return false;
}
}
bool isYCbCr420Format (VkFormat format)
{
switch (format)
{
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
return true;
default:
return false;
}
}
bool isYCbCr422Format (VkFormat format)
{
switch (format)
{
case VK_FORMAT_G8B8G8R8_422_UNORM:
case VK_FORMAT_B8G8R8G8_422_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G16B16G16R16_422_UNORM:
case VK_FORMAT_B16G16R16G16_422_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
return true;
default:
return false;
}
}
const std::map<VkFormat, std::string> spirvFormats = {
{ VK_FORMAT_R32G32B32A32_SFLOAT, "Rgba32f" },
{ VK_FORMAT_R32G32_SFLOAT, "Rg32f" },
{ VK_FORMAT_R32_SFLOAT, "R32f" },
{ VK_FORMAT_R16G16B16A16_SFLOAT, "Rgba16f" },
{ VK_FORMAT_R16G16_SFLOAT, "Rg16f" },
{ VK_FORMAT_R16_SFLOAT, "R16f" },
{ VK_FORMAT_R16G16B16A16_UNORM, "Rgba16" },
{ VK_FORMAT_R16G16_UNORM, "Rg16" },
{ VK_FORMAT_R16_UNORM, "R16" },
{ VK_FORMAT_R16G16B16A16_SNORM, "Rgba16Snorm" },
{ VK_FORMAT_R16G16_SNORM, "Rg16Snorm" },
{ VK_FORMAT_R16_SNORM, "R16Snorm" },
{ VK_FORMAT_A2B10G10R10_UNORM_PACK32, "Rgb10A2" },
{ VK_FORMAT_B10G11R11_UFLOAT_PACK32, "R11fG11fB10f" },
{ VK_FORMAT_R8G8B8A8_UNORM, "Rgba8" },
{ VK_FORMAT_R8G8_UNORM, "Rg8" },
{ VK_FORMAT_R8_UNORM, "R8" },
{ VK_FORMAT_R8G8B8A8_SNORM, "Rgba8Snorm" },
{ VK_FORMAT_R8G8_SNORM, "Rg8Snorm" },
{ VK_FORMAT_R8_SNORM, "R8Snorm" },
{ VK_FORMAT_R32G32B32A32_SINT, "Rgba32i" },
{ VK_FORMAT_R32G32_SINT, "Rg32i" },
{ VK_FORMAT_R32_SINT, "R32i" },
{ VK_FORMAT_R16G16B16A16_SINT, "Rgba16i" },
{ VK_FORMAT_R16G16_SINT, "Rg16i" },
{ VK_FORMAT_R16_SINT, "R16i" },
{ VK_FORMAT_R8G8B8A8_SINT, "Rgba8i" },
{ VK_FORMAT_R8G8_SINT, "Rg8i" },
{ VK_FORMAT_R8_SINT, "R8i" },
{ VK_FORMAT_R32G32B32A32_UINT, "Rgba32ui" },
{ VK_FORMAT_R32G32_UINT, "Rg32ui" },
{ VK_FORMAT_R32_UINT, "R32ui" },
{ VK_FORMAT_R16G16B16A16_UINT, "Rgba16ui" },
{ VK_FORMAT_R16G16_UINT, "Rg16ui" },
{ VK_FORMAT_R16_UINT, "R16ui" },
{ VK_FORMAT_A2B10G10R10_UINT_PACK32, "Rgb10a2ui" },
{ VK_FORMAT_R8G8B8A8_UINT, "Rgba8ui" },
{ VK_FORMAT_R8G8_UINT, "Rg8ui" },
{ VK_FORMAT_R8_UINT, "R8ui" },
{ VK_FORMAT_R64_SINT, "R64i" },
{ VK_FORMAT_R64_UINT, "R64ui" },
};
bool hasSpirvFormat(VkFormat fmt)
{
auto iter = spirvFormats.find(fmt);
return (iter != spirvFormats.end());
}
const std::string getSpirvFormat(VkFormat fmt)
{
auto iter = spirvFormats.find(fmt);
assert(iter != spirvFormats.end());
return iter->second;
}
bool is64BitIntegerFormat (VkFormat format)
{
const auto tcuFormat = mapVkFormat(format);
return (tcuFormat.type == tcu::TextureFormat::UNSIGNED_INT64 || tcuFormat.type == tcu::TextureFormat::SIGNED_INT64);
}
const PlanarFormatDescription& getYCbCrPlanarFormatDescription (VkFormat format)
{
using tcu::TextureFormat;
const deUint32 chanR = PlanarFormatDescription::CHANNEL_R;
const deUint32 chanG = PlanarFormatDescription::CHANNEL_G;
const deUint32 chanB = PlanarFormatDescription::CHANNEL_B;
const deUint32 chanA = PlanarFormatDescription::CHANNEL_A;
const deUint8 unorm = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
if (format >= VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT && format <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT)
{
static const PlanarFormatDescription s_formatInfo[] =
{
// VK_FORMAT_G8_B8R8_2PLANE_444_UNORM
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 2, 1, 1, VK_FORMAT_R8G8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 8, 8, 2 }, // R
{ 0, unorm, 0, 8, 1 }, // G
{ 1, unorm, 0, 8, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 4, 1, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 22, 10, 4 }, // R
{ 0, unorm, 6, 10, 2 }, // G
{ 1, unorm, 6, 10, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 4, 1, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 20, 12, 4 }, // R
{ 0, unorm, 4, 12, 2 }, // G
{ 1, unorm, 4, 12, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 4, 1, 1, VK_FORMAT_R16G16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 16, 16, 4 }, // R
{ 0, unorm, 0, 16, 2 }, // G
{ 1, unorm, 0, 16, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
};
const size_t offset = (size_t)VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT;
DE_ASSERT(de::inBounds<size_t>((size_t)format, offset, offset+(size_t)DE_LENGTH_OF_ARRAY(s_formatInfo)));
return s_formatInfo[(size_t)format-offset];
}
static const PlanarFormatDescription s_formatInfo[] =
{
// VK_FORMAT_G8B8G8R8_422_UNORM
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_G8B8G8R8_422_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 24, 8, 4 }, // R
{ 0, unorm, 0, 8, 2 }, // G
{ 0, unorm, 8, 8, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_B8G8R8G8_422_UNORM
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_B8G8R8G8_422_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 16, 8, 4 }, // R
{ 0, unorm, 8, 8, 2 }, // G
{ 0, unorm, 0, 8, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 1, 2, 2, VK_FORMAT_R8_UNORM },
{ 1, 2, 2, VK_FORMAT_R8_UNORM },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 0, 8, 1 }, // R
{ 0, unorm, 0, 8, 1 }, // G
{ 1, unorm, 0, 8, 1 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G8_B8R8_2PLANE_420_UNORM
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 2, 2, 2, VK_FORMAT_R8G8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 8, 8, 2 }, // R
{ 0, unorm, 0, 8, 1 }, // G
{ 1, unorm, 0, 8, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 1, 2, 1, VK_FORMAT_R8_UNORM },
{ 1, 2, 1, VK_FORMAT_R8_UNORM },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 0, 8, 1 }, // R
{ 0, unorm, 0, 8, 1 }, // G
{ 1, unorm, 0, 8, 1 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G8_B8R8_2PLANE_422_UNORM
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 2, 2, 1, VK_FORMAT_R8G8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 8, 8, 2 }, // R
{ 0, unorm, 0, 8, 1 }, // G
{ 1, unorm, 0, 8, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 0, 8, 1 }, // R
{ 0, unorm, 0, 8, 1 }, // G
{ 1, unorm, 0, 8, 1 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_R10X6_UNORM_PACK16
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 6, 10, 2 }, // R
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
}
},
// VK_FORMAT_R10X6G10X6_UNORM_2PACK16
{
1, // planes
chanR|chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 6, 10, 4 }, // R
{ 0, unorm, 22, 10, 4 }, // G
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
}
},
// VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 6, 10, 8 }, // R
{ 0, unorm, 22, 10, 8 }, // G
{ 0, unorm, 38, 10, 8 }, // B
{ 0, unorm, 54, 10, 8 }, // A
}
},
// VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 54, 10, 8 }, // R
{ 0, unorm, 6, 10, 4 }, // G
{ 0, unorm, 22, 10, 8 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 38, 10, 8 }, // R
{ 0, unorm, 22, 10, 4 }, // G
{ 0, unorm, 6, 10, 8 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 2, 2, 2, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 2, 2, 2, VK_FORMAT_R10X6_UNORM_PACK16 },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 6, 10, 2 }, // R
{ 0, unorm, 6, 10, 2 }, // G
{ 1, unorm, 6, 10, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 4, 2, 2, VK_FORMAT_R10X6G10X6_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 22, 10, 4 }, // R
{ 0, unorm, 6, 10, 2 }, // G
{ 1, unorm, 6, 10, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 2, 2, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 2, 2, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 6, 10, 2 }, // R
{ 0, unorm, 6, 10, 2 }, // G
{ 1, unorm, 6, 10, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 4, 2, 1, VK_FORMAT_R10X6G10X6_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 22, 10, 4 }, // R
{ 0, unorm, 6, 10, 2 }, // G
{ 1, unorm, 6, 10, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
{ 2, 1, 1, VK_FORMAT_R10X6_UNORM_PACK16 },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 6, 10, 2 }, // R
{ 0, unorm, 6, 10, 2 }, // G
{ 1, unorm, 6, 10, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_R12X4_UNORM_PACK16
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 4, 12, 2 }, // R
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
}
},
// VK_FORMAT_R12X4G12X4_UNORM_2PACK16
{
1, // planes
chanR|chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 4, 12, 4 }, // R
{ 0, unorm, 20, 12, 4 }, // G
{ 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0 },
}
},
// VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 4, 12, 8 }, // R
{ 0, unorm, 20, 12, 8 }, // G
{ 0, unorm, 36, 12, 8 }, // B
{ 0, unorm, 52, 12, 8 }, // A
}
},
// VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 52, 12, 8 }, // R
{ 0, unorm, 4, 12, 4 }, // G
{ 0, unorm, 20, 12, 8 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 36, 12, 8 }, // R
{ 0, unorm, 20, 12, 4 }, // G
{ 0, unorm, 4, 12, 8 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 2, 2, 2, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 2, 2, 2, VK_FORMAT_R12X4_UNORM_PACK16 },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 4, 12, 2 }, // R
{ 0, unorm, 4, 12, 2 }, // G
{ 1, unorm, 4, 12, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 4, 2, 2, VK_FORMAT_R12X4G12X4_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 20, 12, 4 }, // R
{ 0, unorm, 4, 12, 2 }, // G
{ 1, unorm, 4, 12, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 2, 2, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 2, 2, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 4, 12, 2 }, // R
{ 0, unorm, 4, 12, 2 }, // G
{ 1, unorm, 4, 12, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 4, 2, 1, VK_FORMAT_R12X4G12X4_UNORM_2PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 20, 12, 4 }, // R
{ 0, unorm, 4, 12, 2 }, // G
{ 1, unorm, 4, 12, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
{ 2, 1, 1, VK_FORMAT_R12X4_UNORM_PACK16 },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 4, 12, 2 }, // R
{ 0, unorm, 4, 12, 2 }, // G
{ 1, unorm, 4, 12, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16B16G16R16_422_UNORM
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_G16B16G16R16_422_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 48, 16, 8 }, // R
{ 0, unorm, 0, 16, 4 }, // G
{ 0, unorm, 16, 16, 8 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_B16G16R16G16_422_UNORM
{
1, // planes
chanR|chanG|chanB,
2,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_B16G16R16G16_422_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 32, 16, 8 }, // R
{ 0, unorm, 16, 16, 4 }, // G
{ 0, unorm, 0, 16, 8 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 2, 2, 2, VK_FORMAT_R16_UNORM },
{ 2, 2, 2, VK_FORMAT_R16_UNORM },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 0, 16, 2 }, // R
{ 0, unorm, 0, 16, 2 }, // G
{ 1, unorm, 0, 16, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16_B16R16_2PLANE_420_UNORM
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 4, 2, 2, VK_FORMAT_R16G16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 16, 16, 4 }, // R
{ 0, unorm, 0, 16, 2 }, // G
{ 1, unorm, 0, 16, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 2, 2, 1, VK_FORMAT_R16_UNORM },
{ 2, 2, 1, VK_FORMAT_R16_UNORM },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 0, 16, 2 }, // R
{ 0, unorm, 0, 16, 2 }, // G
{ 1, unorm, 0, 16, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16_B16R16_2PLANE_422_UNORM
{
2, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 4, 2, 1, VK_FORMAT_R16G16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 1, unorm, 16, 16, 4 }, // R
{ 0, unorm, 0, 16, 2 }, // G
{ 1, unorm, 0, 16, 4 }, // B
{ 0, 0, 0, 0, 0 }
}
},
// VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
{
3, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
},
{
// Plane Type Offs Size Stride
{ 2, unorm, 0, 16, 2 }, // R
{ 0, unorm, 0, 16, 2 }, // G
{ 1, unorm, 0, 16, 2 }, // B
{ 0, 0, 0, 0, 0 }
}
},
};
const size_t offset = (size_t)VK_FORMAT_G8B8G8R8_422_UNORM;
DE_ASSERT(de::inBounds<size_t>((size_t)format, offset, offset+(size_t)DE_LENGTH_OF_ARRAY(s_formatInfo)));
return s_formatInfo[(size_t)format-offset];
}
PlanarFormatDescription getCorePlanarFormatDescription (VkFormat format)
{
const deUint8 snorm = (deUint8)tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
const deUint8 unorm = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
const deUint8 sint = (deUint8)tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER;
const deUint8 uint = (deUint8)tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
const deUint8 sfloat = (deUint8)tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
const deUint8 chanR = (deUint8)PlanarFormatDescription::CHANNEL_R;
const deUint8 chanG = (deUint8)PlanarFormatDescription::CHANNEL_G;
const deUint8 chanB = (deUint8)PlanarFormatDescription::CHANNEL_B;
const deUint8 chanA = (deUint8)PlanarFormatDescription::CHANNEL_A;
DE_ASSERT(de::inBounds<deUint32>(format, VK_FORMAT_UNDEFINED+1, VK_CORE_FORMAT_LAST));
#if (DE_ENDIANNESS != DE_LITTLE_ENDIAN)
# error "Big-endian is not supported"
#endif
switch (format)
{
case VK_FORMAT_R8_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 8, 1 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8_SNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_SNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, snorm, 0, 8, 1 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R8G8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 8, 2 }, // R
{ 0, unorm, 8, 8, 2 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8_SNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R8G8_SNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, snorm, 0, 8, 2 }, // R
{ 0, snorm, 8, 8, 2 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 16, 2 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16_SNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_SNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, snorm, 0, 16, 2 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R16G16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 16, 4 }, // R
{ 0, unorm, 16, 16, 4 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16_SNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R16G16_SNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, snorm, 0, 16, 4 }, // R
{ 0, snorm, 16, 16, 4 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_B10G11R11_UFLOAT_PACK32 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 11, 4 }, // R
{ 0, unorm, 11, 11, 4 }, // G
{ 0, unorm, 22, 10, 4 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R4G4_UNORM_PACK8:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R4G4_UNORM_PACK8 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 4, 4, 1 }, // R
{ 0, unorm, 0, 4, 1 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R4G4B4A4_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 12, 4, 2 }, // R
{ 0, unorm, 8, 4, 2 }, // G
{ 0, unorm, 4, 4, 2 }, // B
{ 0, unorm, 0, 4, 2 } // A
}
};
return desc;
}
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_B4G4R4A4_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 4, 4, 2 }, // R
{ 0, unorm, 8, 4, 2 }, // G
{ 0, unorm, 12, 4, 2 }, // B
{ 0, unorm, 0, 4, 2 } // A
}
};
return desc;
}
case VK_FORMAT_R5G6B5_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R5G6B5_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 11, 5, 2 }, // R
{ 0, unorm, 5, 6, 2 }, // G
{ 0, unorm, 0, 5, 2 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_B5G6R5_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_B5G6R5_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 5, 2 }, // R
{ 0, unorm, 5, 6, 2 }, // G
{ 0, unorm, 11, 5, 2 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R5G5B5A1_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 11, 5, 2 }, // R
{ 0, unorm, 6, 5, 2 }, // G
{ 0, unorm, 1, 5, 2 }, // B
{ 0, unorm, 0, 1, 2 } // A
}
};
return desc;
}
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_B5G5R5A1_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 1, 5, 2 }, // R
{ 0, unorm, 6, 5, 2 }, // G
{ 0, unorm, 11, 5, 2 }, // B
{ 0, unorm, 0, 1, 2 } // A
}
};
return desc;
}
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_A1R5G5B5_UNORM_PACK16 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 10, 5, 2 }, // R
{ 0, unorm, 5, 5, 2 }, // G
{ 0, unorm, 0, 5, 2 }, // B
{ 0, unorm, 15, 1, 2 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8B8_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 3, 1, 1, VK_FORMAT_R8G8B8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 8, 3 }, // R
{ 0, unorm, 8, 8, 3 }, // G
{ 0, unorm, 16, 8, 3 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_B8G8R8_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 3, 1, 1, VK_FORMAT_B8G8R8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 16, 8, 3 }, // R
{ 0, unorm, 8, 8, 3 }, // G
{ 0, unorm, 0, 8, 3 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R8G8B8A8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 8, 4 }, // R
{ 0, unorm, 8, 8, 4 }, // G
{ 0, unorm, 16, 8, 4 }, // B
{ 0, unorm, 24, 8, 4 } // A
}
};
return desc;
}
case VK_FORMAT_B8G8R8A8_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_B8G8R8A8_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 16, 8, 4 }, // R
{ 0, unorm, 8, 8, 4 }, // G
{ 0, unorm, 0, 8, 4 }, // B
{ 0, unorm, 24, 8, 4 } // A
}
};
return desc;
}
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_A2R10G10B10_UNORM_PACK32 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 20, 10, 4 }, // R
{ 0, unorm, 10, 10, 4 }, // G
{ 0, unorm, 0, 10, 4 }, // B
{ 0, unorm, 30, 2, 4 } // A
}
};
return desc;
}
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 10, 4 }, // R
{ 0, unorm, 10, 10, 4 }, // G
{ 0, unorm, 20, 10, 4 }, // B
{ 0, unorm, 30, 2, 4 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16B16_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 6, 1, 1, VK_FORMAT_R16G16B16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 16, 6 }, // R
{ 0, unorm, 16, 16, 6 }, // G
{ 0, unorm, 32, 16, 6 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16B16A16_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R16G16B16A16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 16, 8 }, // R
{ 0, unorm, 16, 16, 8 }, // G
{ 0, unorm, 32, 16, 8 }, // B
{ 0, unorm, 48, 16, 8 } // A
}
};
return desc;
}
case VK_FORMAT_R8_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 8, 1 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 16, 2 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R32_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R32_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 32, 4 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R64_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R64_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 64, 8 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R8G8_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 8, 2 }, // R
{ 0, sint, 8, 8, 2 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R16G16_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 16, 4 }, // R
{ 0, sint, 16, 16, 4 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R32G32_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R32G32_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 32, 8 }, // R
{ 0, sint, 32, 32, 8 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8B8A8_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R8G8B8A8_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 8, 4 }, // R
{ 0, sint, 8, 8, 4 }, // G
{ 0, sint, 16, 8, 4 }, // B
{ 0, sint, 24, 8, 4 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16B16A16_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R16G16B16A16_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 16, 8 }, // R
{ 0, sint, 16, 16, 8 }, // G
{ 0, sint, 32, 16, 8 }, // B
{ 0, sint, 48, 16, 8 } // A
}
};
return desc;
}
case VK_FORMAT_R32G32B32A32_SINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 16, 1, 1, VK_FORMAT_R32G32B32A32_SINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sint, 0, 32, 16 }, // R
{ 0, sint, 32, 32, 16 }, // G
{ 0, sint, 64, 32, 16 }, // B
{ 0, sint, 96, 32, 16 } // A
}
};
return desc;
}
case VK_FORMAT_R8_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_R8_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 8, 1 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R16_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 16, 2 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R32_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R32_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 32, 4 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R64_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R64_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 64, 8 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_R8G8_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 8, 2 }, // R
{ 0, uint, 8, 8, 2 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R16G16_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 16, 4 }, // R
{ 0, uint, 16, 16, 4 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R32G32_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R32G32_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 32, 8 }, // R
{ 0, uint, 32, 32, 8 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8B8A8_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R8G8B8A8_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 8, 4 }, // R
{ 0, uint, 8, 8, 4 }, // G
{ 0, uint, 16, 8, 4 }, // B
{ 0, uint, 24, 8, 4 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16B16A16_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R16G16B16A16_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 16, 8 }, // R
{ 0, uint, 16, 16, 8 }, // G
{ 0, uint, 32, 16, 8 }, // B
{ 0, uint, 48, 16, 8 } // A
}
};
return desc;
}
case VK_FORMAT_R32G32B32A32_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 16, 1, 1, VK_FORMAT_R32G32B32A32_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 32, 16 }, // R
{ 0, uint, 32, 32, 16 }, // G
{ 0, uint, 64, 32, 16 }, // B
{ 0, uint, 96, 32, 16 } // A
}
};
return desc;
}
case VK_FORMAT_R8G8B8A8_SNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R8G8B8A8_SNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, snorm, 0, 8, 4 }, // R
{ 0, snorm, 8, 8, 4 }, // G
{ 0, snorm, 16, 8, 4 }, // B
{ 0, snorm, 24, 8, 4 } // A
}
};
return desc;
}
case VK_FORMAT_R16G16B16A16_SNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR | chanG | chanB | chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 8, 1, 1, VK_FORMAT_R16G16B16A16_SNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, snorm, 0, 16, 8 }, // R
{ 0, snorm, 16, 16, 8 }, // G
{ 0, snorm, 32, 16, 8 }, // B
{ 0, snorm, 48, 16, 8 } // A
}
};
return desc;
}
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_D32_SFLOAT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 4, 1, 1, VK_FORMAT_R32_SFLOAT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sfloat, 0, 32, 4 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_D16_UNORM:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_D16_UNORM },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 16, 2 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_S8_UINT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 1, 1, 1, VK_FORMAT_S8_UINT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED},
},
{
// Plane Type Offs Size Stride
{ 0, uint, 0, 8, 1 }, // R
{ 0, 0, 0, 0, 0 }, // G
{ 0, 0, 0, 0, 0 }, // B
{ 0, 0, 0, 0, 0 } // A
}
};
return desc;
}
case VK_FORMAT_R32G32B32A32_SFLOAT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 16, 1, 1, VK_FORMAT_R32G32B32A32_SFLOAT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, sfloat, 0, 32, 16 }, // R
{ 0, sfloat, 32, 32, 16 }, // G
{ 0, sfloat, 64, 32, 16 }, // B
{ 0, sfloat, 96, 32, 16 }, // A
}
};
return desc;
}
case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 8, 4, 2 }, // R
{ 0, unorm, 4, 4, 2 }, // G
{ 0, unorm, 0, 4, 2 }, // B
{ 0, unorm, 12, 4, 2 } // A
}
};
return desc;
}
case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT:
{
const PlanarFormatDescription desc =
{
1, // planes
chanR|chanG|chanB|chanA,
1,1,
{
// Size WDiv HDiv planeCompatibleFormat
{ 2, 1, 1, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
{ 0, 0, 0, VK_FORMAT_UNDEFINED },
},
{
// Plane Type Offs Size Stride
{ 0, unorm, 0, 4, 2 }, // R
{ 0, unorm, 4, 4, 2 }, // G
{ 0, unorm, 8, 4, 2 }, // B
{ 0, unorm, 12, 4, 2 } // A
}
};
return desc;
}
default:
TCU_THROW(InternalError, "Not implemented");
}
}
PlanarFormatDescription getPlanarFormatDescription (VkFormat format)
{
if (isYCbCrFormat(format))
return getYCbCrPlanarFormatDescription(format);
else
return getCorePlanarFormatDescription(format);
}
int getPlaneCount (VkFormat format)
{
switch (format)
{
case VK_FORMAT_G8B8G8R8_422_UNORM:
case VK_FORMAT_B8G8R8G8_422_UNORM:
case VK_FORMAT_R10X6_UNORM_PACK16:
case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
case VK_FORMAT_R12X4_UNORM_PACK16:
case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
case VK_FORMAT_G16B16G16R16_422_UNORM:
case VK_FORMAT_B16G16R16G16_422_UNORM:
return 1;
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT:
case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT:
return 2;
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return 3;
default:
DE_FATAL("Not YCbCr format");
return 0;
}
}
deUint32 getMipmapCount(VkFormat format, const vk::PlanarFormatDescription& formatDescription, const VkImageFormatProperties& imageFormatProperties, const VkExtent3D& extent)
{
if (isYCbCrFormat(format))
return 1;
tcu::UVec3 imageAlignment = getImageSizeAlignment(formatDescription);
deUint32 mipmapEdge = std::max(std::max(extent.width, extent.height), extent.depth);
if (imageAlignment.x() > 1)
mipmapEdge = std::min(mipmapEdge, extent.width / imageAlignment.x());
if (imageAlignment.y() > 1)
mipmapEdge = std::min(mipmapEdge, extent.height / imageAlignment.y());
if (imageAlignment.z() > 1)
mipmapEdge = std::min(mipmapEdge, extent.depth / imageAlignment.z());
return std::min(static_cast<deUint32>(deFloatLog2(static_cast<float>(mipmapEdge))) + 1u, imageFormatProperties.maxMipLevels);
}
deUint32 getPlaneSizeInBytes (const PlanarFormatDescription& formatInfo,
const VkExtent3D& baseExtents,
const deUint32 planeNdx,
const deUint32 mipmapLevel,
const deUint32 mipmapMemoryAlignment)
{
VkExtent3D imageExtent = getPlaneExtent(formatInfo, baseExtents, planeNdx, mipmapLevel);
imageExtent.width /= formatInfo.blockWidth;
imageExtent.height /= formatInfo.blockHeight;
return deAlign32( formatInfo.planes[planeNdx].elementSizeBytes * imageExtent.width * imageExtent.height * imageExtent.depth, mipmapMemoryAlignment);
}
deUint32 getPlaneSizeInBytes (const PlanarFormatDescription& formatInfo,
const tcu::UVec2& baseExtents,
const deUint32 planeNdx,
const deUint32 mipmapLevel,
const deUint32 mipmapMemoryAlignment)
{
tcu::UVec2 mipExtents = getPlaneExtent(formatInfo, baseExtents, planeNdx, mipmapLevel) / tcu::UVec2(formatInfo.blockWidth, formatInfo.blockHeight);
return deAlign32( formatInfo.planes[planeNdx].elementSizeBytes * mipExtents.x() * mipExtents.y(), mipmapMemoryAlignment);
}
VkExtent3D getPlaneExtent(const PlanarFormatDescription& formatInfo,
const VkExtent3D& baseExtents,
const deUint32 planeNdx,
const deUint32 mipmapLevel)
{
deUint32 widthDivisor = formatInfo.planes[planeNdx].widthDivisor;
deUint32 heightDivisor = formatInfo.planes[planeNdx].heightDivisor;
deUint32 depthDivisor = 1u;
VkExtent3D mip0Extents { baseExtents.width / widthDivisor, baseExtents.height / heightDivisor, baseExtents.depth / depthDivisor };
return mipLevelExtents(mip0Extents, mipmapLevel);
}
tcu::UVec2 getPlaneExtent(const PlanarFormatDescription& formatInfo,
const tcu::UVec2& baseExtents,
const deUint32 planeNdx,
const deUint32 mipmapLevel)
{
deUint32 widthDivisor = formatInfo.planes[planeNdx].widthDivisor;
deUint32 heightDivisor = formatInfo.planes[planeNdx].heightDivisor;
tcu::UVec2 mip0Extents { baseExtents.x() / widthDivisor, baseExtents.y() / heightDivisor };
return tcu::UVec2
{
std::max(mip0Extents.x() >> mipmapLevel, 1u),
std::max(mip0Extents.y() >> mipmapLevel, 1u)
};
}
tcu::UVec3 getImageSizeAlignment(VkFormat format)
{
return getImageSizeAlignment(getPlanarFormatDescription(format));
}
tcu::UVec3 getImageSizeAlignment(const PlanarFormatDescription& formatInfo)
{
tcu::UVec3 imgAlignment{ formatInfo.blockWidth, formatInfo.blockHeight, 1 };
for (deUint32 planeNdx = 0; planeNdx < formatInfo.numPlanes; ++planeNdx)
{
imgAlignment.x() = std::max(imgAlignment.x(), static_cast<deUint32>(formatInfo.planes[planeNdx].widthDivisor));
imgAlignment.y() = std::max(imgAlignment.y(), static_cast<deUint32>(formatInfo.planes[planeNdx].heightDivisor));
}
return imgAlignment;
}
tcu::UVec2 getBlockExtent(VkFormat format)
{
return getBlockExtent(getPlanarFormatDescription(format));
}
tcu::UVec2 getBlockExtent(const PlanarFormatDescription& formatInfo)
{
return tcu::UVec2{ formatInfo.blockWidth, formatInfo.blockHeight };
}
VkFormat getPlaneCompatibleFormat(VkFormat format, deUint32 planeNdx)
{
return getPlaneCompatibleFormat(getPlanarFormatDescription(format), planeNdx);
}
VkFormat getPlaneCompatibleFormat(const PlanarFormatDescription& formatInfo, deUint32 planeNdx)
{
DE_ASSERT(planeNdx < formatInfo.numPlanes);
return formatInfo.planes[planeNdx].planeCompatibleFormat;
}
VkImageAspectFlagBits getPlaneAspect (deUint32 planeNdx)
{
DE_ASSERT(de::inBounds(planeNdx, 0u, 3u));
return (VkImageAspectFlagBits)(VK_IMAGE_ASPECT_PLANE_0_BIT << planeNdx);
}
deUint32 getAspectPlaneNdx (VkImageAspectFlagBits flags)
{
switch (flags)
{
case VK_IMAGE_ASPECT_PLANE_0_BIT: return 0;
case VK_IMAGE_ASPECT_PLANE_1_BIT: return 1;
case VK_IMAGE_ASPECT_PLANE_2_BIT: return 2;
default:
DE_FATAL("Invalid plane aspect");
return 0;
}
}
bool isChromaSubsampled (VkFormat format)
{
switch (format)
{
case VK_FORMAT_G8B8G8R8_422_UNORM:
case VK_FORMAT_B8G8R8G8_422_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
case VK_FORMAT_G16B16G16R16_422_UNORM:
case VK_FORMAT_B16G16R16G16_422_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
return true;
default:
return false;
}
}
bool isSupportedByFramework (VkFormat format)
{
if (format == VK_FORMAT_UNDEFINED || format > VK_CORE_FORMAT_LAST)
return false;
switch (format)
{
case VK_FORMAT_R64_UINT:
case VK_FORMAT_R64_SINT:
case VK_FORMAT_R64_SFLOAT:
case VK_FORMAT_R64G64_UINT:
case VK_FORMAT_R64G64_SINT:
case VK_FORMAT_R64G64_SFLOAT:
case VK_FORMAT_R64G64B64_UINT:
case VK_FORMAT_R64G64B64_SINT:
case VK_FORMAT_R64G64B64_SFLOAT:
case VK_FORMAT_R64G64B64A64_UINT:
case VK_FORMAT_R64G64B64A64_SINT:
case VK_FORMAT_R64G64B64A64_SFLOAT:
// \todo [2016-12-01 pyry] Support 64-bit channel types
return false;
case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
case VK_FORMAT_BC2_UNORM_BLOCK:
case VK_FORMAT_BC2_SRGB_BLOCK:
case VK_FORMAT_BC3_UNORM_BLOCK:
case VK_FORMAT_BC3_SRGB_BLOCK:
case VK_FORMAT_BC4_UNORM_BLOCK:
case VK_FORMAT_BC4_SNORM_BLOCK:
case VK_FORMAT_BC5_UNORM_BLOCK:
case VK_FORMAT_BC5_SNORM_BLOCK:
case VK_FORMAT_BC6H_UFLOAT_BLOCK:
case VK_FORMAT_BC6H_SFLOAT_BLOCK:
case VK_FORMAT_BC7_UNORM_BLOCK:
case VK_FORMAT_BC7_SRGB_BLOCK:
return false;
default:
return true;
}
}
void checkImageSupport (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, const VkImageCreateInfo& imageCreateInfo)
{
VkImageFormatProperties imageFormatProperties;
if (vki.getPhysicalDeviceImageFormatProperties(physicalDevice, imageCreateInfo.format, imageCreateInfo.imageType,
imageCreateInfo.tiling, imageCreateInfo.usage, imageCreateInfo.flags,
&imageFormatProperties))
{
TCU_THROW(NotSupportedError, "Image format not supported.");
}
if (((VkSampleCountFlagBits)imageFormatProperties.sampleCounts & imageCreateInfo.samples) == 0)
{
TCU_THROW(NotSupportedError, "Sample count not supported.");
}
if (imageFormatProperties.maxArrayLayers < imageCreateInfo.arrayLayers)
{
TCU_THROW(NotSupportedError, "Layer count not supported.");
}
}
VkFormat mapTextureFormat (const tcu::TextureFormat& format)
{
DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST < (1<<16));
DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST < (1<<16));
#define PACK_FMT(ORDER, TYPE) ((int(ORDER) << 16) | int(TYPE))
#define FMT_CASE(ORDER, TYPE) PACK_FMT(tcu::TextureFormat::ORDER, tcu::TextureFormat::TYPE)
// update this mapping if VkFormat changes
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (PACK_FMT(format.order, format.type))
{
case FMT_CASE(RG, UNORM_BYTE_44): return VK_FORMAT_R4G4_UNORM_PACK8;
case FMT_CASE(RGB, UNORM_SHORT_565): return VK_FORMAT_R5G6B5_UNORM_PACK16;
case FMT_CASE(RGBA, UNORM_SHORT_4444): return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
case FMT_CASE(RGBA, UNORM_SHORT_5551): return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
case FMT_CASE(BGR, UNORM_SHORT_565): return VK_FORMAT_B5G6R5_UNORM_PACK16;
case FMT_CASE(BGRA, UNORM_SHORT_4444): return VK_FORMAT_B4G4R4A4_UNORM_PACK16;
case FMT_CASE(BGRA, UNORM_SHORT_5551): return VK_FORMAT_B5G5R5A1_UNORM_PACK16;
case FMT_CASE(ARGB, UNORM_SHORT_1555): return VK_FORMAT_A1R5G5B5_UNORM_PACK16;
case FMT_CASE(R, UNORM_INT8): return VK_FORMAT_R8_UNORM;
case FMT_CASE(R, SNORM_INT8): return VK_FORMAT_R8_SNORM;
case FMT_CASE(R, UNSIGNED_INT8): return VK_FORMAT_R8_UINT;
case FMT_CASE(R, SIGNED_INT8): return VK_FORMAT_R8_SINT;
case FMT_CASE(sR, UNORM_INT8): return VK_FORMAT_R8_SRGB;
case FMT_CASE(RG, UNORM_INT8): return VK_FORMAT_R8G8_UNORM;
case FMT_CASE(RG, SNORM_INT8): return VK_FORMAT_R8G8_SNORM;
case FMT_CASE(RG, UNSIGNED_INT8): return VK_FORMAT_R8G8_UINT;
case FMT_CASE(RG, SIGNED_INT8): return VK_FORMAT_R8G8_SINT;
case FMT_CASE(sRG, UNORM_INT8): return VK_FORMAT_R8G8_SRGB;
case FMT_CASE(RGB, UNORM_INT8): return VK_FORMAT_R8G8B8_UNORM;
case FMT_CASE(RGB, SNORM_INT8): return VK_FORMAT_R8G8B8_SNORM;
case FMT_CASE(RGB, UNSIGNED_INT8): return VK_FORMAT_R8G8B8_UINT;
case FMT_CASE(RGB, SIGNED_INT8): return VK_FORMAT_R8G8B8_SINT;
case FMT_CASE(sRGB, UNORM_INT8): return VK_FORMAT_R8G8B8_SRGB;
case FMT_CASE(RGBA, UNORM_INT8): return VK_FORMAT_R8G8B8A8_UNORM;
case FMT_CASE(RGBA, SNORM_INT8): return VK_FORMAT_R8G8B8A8_SNORM;
case FMT_CASE(RGBA, UNSIGNED_INT8): return VK_FORMAT_R8G8B8A8_UINT;
case FMT_CASE(RGBA, SIGNED_INT8): return VK_FORMAT_R8G8B8A8_SINT;
case FMT_CASE(sRGBA, UNORM_INT8): return VK_FORMAT_R8G8B8A8_SRGB;
case FMT_CASE(RGBA, UNORM_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
case FMT_CASE(RGBA, SNORM_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_SNORM_PACK32;
case FMT_CASE(RGBA, UNSIGNED_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_UINT_PACK32;
case FMT_CASE(RGBA, SIGNED_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_SINT_PACK32;
case FMT_CASE(R, UNORM_INT16): return VK_FORMAT_R16_UNORM;
case FMT_CASE(R, SNORM_INT16): return VK_FORMAT_R16_SNORM;
case FMT_CASE(R, UNSIGNED_INT16): return VK_FORMAT_R16_UINT;
case FMT_CASE(R, SIGNED_INT16): return VK_FORMAT_R16_SINT;
case FMT_CASE(R, HALF_FLOAT): return VK_FORMAT_R16_SFLOAT;
case FMT_CASE(RG, UNORM_INT16): return VK_FORMAT_R16G16_UNORM;
case FMT_CASE(RG, SNORM_INT16): return VK_FORMAT_R16G16_SNORM;
case FMT_CASE(RG, UNSIGNED_INT16): return VK_FORMAT_R16G16_UINT;
case FMT_CASE(RG, SIGNED_INT16): return VK_FORMAT_R16G16_SINT;
case FMT_CASE(RG, HALF_FLOAT): return VK_FORMAT_R16G16_SFLOAT;
case FMT_CASE(RGB, UNORM_INT16): return VK_FORMAT_R16G16B16_UNORM;
case FMT_CASE(RGB, SNORM_INT16): return VK_FORMAT_R16G16B16_SNORM;
case FMT_CASE(RGB, UNSIGNED_INT16): return VK_FORMAT_R16G16B16_UINT;
case FMT_CASE(RGB, SIGNED_INT16): return VK_FORMAT_R16G16B16_SINT;
case FMT_CASE(RGB, HALF_FLOAT): return VK_FORMAT_R16G16B16_SFLOAT;
case FMT_CASE(RGBA, UNORM_INT16): return VK_FORMAT_R16G16B16A16_UNORM;
case FMT_CASE(RGBA, SNORM_INT16): return VK_FORMAT_R16G16B16A16_SNORM;
case FMT_CASE(RGBA, UNSIGNED_INT16): return VK_FORMAT_R16G16B16A16_UINT;
case FMT_CASE(RGBA, SIGNED_INT16): return VK_FORMAT_R16G16B16A16_SINT;
case FMT_CASE(RGBA, HALF_FLOAT): return VK_FORMAT_R16G16B16A16_SFLOAT;
case FMT_CASE(R, UNSIGNED_INT32): return VK_FORMAT_R32_UINT;
case FMT_CASE(R, SIGNED_INT32): return VK_FORMAT_R32_SINT;
case FMT_CASE(R, UNSIGNED_INT64): return VK_FORMAT_R64_UINT;
case FMT_CASE(R, SIGNED_INT64): return VK_FORMAT_R64_SINT;
case FMT_CASE(R, FLOAT): return VK_FORMAT_R32_SFLOAT;
case FMT_CASE(RG, UNSIGNED_INT32): return VK_FORMAT_R32G32_UINT;
case FMT_CASE(RG, SIGNED_INT32): return VK_FORMAT_R32G32_SINT;
case FMT_CASE(RG, FLOAT): return VK_FORMAT_R32G32_SFLOAT;
case FMT_CASE(RGB, UNSIGNED_INT32): return VK_FORMAT_R32G32B32_UINT;
case FMT_CASE(RGB, SIGNED_INT32): return VK_FORMAT_R32G32B32_SINT;
case FMT_CASE(RGB, FLOAT): return VK_FORMAT_R32G32B32_SFLOAT;
case FMT_CASE(RGBA, UNSIGNED_INT32): return VK_FORMAT_R32G32B32A32_UINT;
case FMT_CASE(RGBA, SIGNED_INT32): return VK_FORMAT_R32G32B32A32_SINT;
case FMT_CASE(RGBA, FLOAT): return VK_FORMAT_R32G32B32A32_SFLOAT;
case FMT_CASE(R, FLOAT64): return VK_FORMAT_R64_SFLOAT;
case FMT_CASE(RG, FLOAT64): return VK_FORMAT_R64G64_SFLOAT;
case FMT_CASE(RGB, FLOAT64): return VK_FORMAT_R64G64B64_SFLOAT;
case FMT_CASE(RGBA, FLOAT64): return VK_FORMAT_R64G64B64A64_SFLOAT;
case FMT_CASE(RGB, UNSIGNED_INT_11F_11F_10F_REV): return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
case FMT_CASE(RGB, UNSIGNED_INT_999_E5_REV): return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
case FMT_CASE(BGR, UNORM_INT8): return VK_FORMAT_B8G8R8_UNORM;
case FMT_CASE(BGR, SNORM_INT8): return VK_FORMAT_B8G8R8_SNORM;
case FMT_CASE(BGR, UNSIGNED_INT8): return VK_FORMAT_B8G8R8_UINT;
case FMT_CASE(BGR, SIGNED_INT8): return VK_FORMAT_B8G8R8_SINT;
case FMT_CASE(sBGR, UNORM_INT8): return VK_FORMAT_B8G8R8_SRGB;
case FMT_CASE(BGRA, UNORM_INT8): return VK_FORMAT_B8G8R8A8_UNORM;
case FMT_CASE(BGRA, SNORM_INT8): return VK_FORMAT_B8G8R8A8_SNORM;
case FMT_CASE(BGRA, UNSIGNED_INT8): return VK_FORMAT_B8G8R8A8_UINT;
case FMT_CASE(BGRA, SIGNED_INT8): return VK_FORMAT_B8G8R8A8_SINT;
case FMT_CASE(sBGRA, UNORM_INT8): return VK_FORMAT_B8G8R8A8_SRGB;
case FMT_CASE(BGRA, UNORM_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
case FMT_CASE(BGRA, SNORM_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_SNORM_PACK32;
case FMT_CASE(BGRA, UNSIGNED_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_UINT_PACK32;
case FMT_CASE(BGRA, SIGNED_INT_1010102_REV): return VK_FORMAT_A2R10G10B10_SINT_PACK32;
case FMT_CASE(D, UNORM_INT16): return VK_FORMAT_D16_UNORM;
case FMT_CASE(D, UNSIGNED_INT_24_8_REV): return VK_FORMAT_X8_D24_UNORM_PACK32;
case FMT_CASE(D, FLOAT): return VK_FORMAT_D32_SFLOAT;
case FMT_CASE(S, UNSIGNED_INT8): return VK_FORMAT_S8_UINT;
case FMT_CASE(DS, UNSIGNED_INT_16_8_8): return VK_FORMAT_D16_UNORM_S8_UINT;
case FMT_CASE(DS, UNSIGNED_INT_24_8_REV): return VK_FORMAT_D24_UNORM_S8_UINT;
case FMT_CASE(DS, FLOAT_UNSIGNED_INT_24_8_REV): return VK_FORMAT_D32_SFLOAT_S8_UINT;
case FMT_CASE(R, UNORM_SHORT_10): return VK_FORMAT_R10X6_UNORM_PACK16;
case FMT_CASE(RG, UNORM_SHORT_10): return VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
case FMT_CASE(RGBA, UNORM_SHORT_10): return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
case FMT_CASE(R, UNORM_SHORT_12): return VK_FORMAT_R12X4_UNORM_PACK16;
case FMT_CASE(RG, UNORM_SHORT_12): return VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
case FMT_CASE(RGBA, UNORM_SHORT_12): return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
case FMT_CASE(R, USCALED_INT8): return VK_FORMAT_R8_USCALED;
case FMT_CASE(RG, USCALED_INT8): return VK_FORMAT_R8G8_USCALED;
case FMT_CASE(RGB, USCALED_INT8): return VK_FORMAT_R8G8B8_USCALED;
case FMT_CASE(RGBA, USCALED_INT8): return VK_FORMAT_R8G8B8A8_USCALED;
case FMT_CASE(R, USCALED_INT16): return VK_FORMAT_R16_USCALED;
case FMT_CASE(RG, USCALED_INT16): return VK_FORMAT_R16G16_USCALED;
case FMT_CASE(RGB, USCALED_INT16): return VK_FORMAT_R16G16B16_USCALED;
case FMT_CASE(RGBA, USCALED_INT16): return VK_FORMAT_R16G16B16A16_USCALED;
case FMT_CASE(R, SSCALED_INT8): return VK_FORMAT_R8_SSCALED;
case FMT_CASE(RG, SSCALED_INT8): return VK_FORMAT_R8G8_SSCALED;
case FMT_CASE(RGB, SSCALED_INT8): return VK_FORMAT_R8G8B8_SSCALED;
case FMT_CASE(RGBA, SSCALED_INT8): return VK_FORMAT_R8G8B8A8_SSCALED;
case FMT_CASE(R, SSCALED_INT16): return VK_FORMAT_R16_SSCALED;
case FMT_CASE(RG, SSCALED_INT16): return VK_FORMAT_R16G16_SSCALED;
case FMT_CASE(RGB, SSCALED_INT16): return VK_FORMAT_R16G16B16_SSCALED;
case FMT_CASE(RGBA, SSCALED_INT16): return VK_FORMAT_R16G16B16A16_SSCALED;
case FMT_CASE(RGBA, USCALED_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_USCALED_PACK32;
case FMT_CASE(RGBA, SSCALED_INT_1010102_REV): return VK_FORMAT_A2B10G10R10_SSCALED_PACK32;
case FMT_CASE(ARGB, UNORM_SHORT_4444): return VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT;
case FMT_CASE(ABGR, UNORM_SHORT_4444): return VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT;
default:
TCU_THROW(InternalError, "Unknown texture format");
}
#undef PACK_FMT
#undef FMT_CASE
}
VkFormat mapCompressedTextureFormat (const tcu::CompressedTexFormat format)
{
// update this mapping if CompressedTexFormat changes
DE_STATIC_ASSERT(tcu::COMPRESSEDTEXFORMAT_LAST == 55);
switch (format)
{
case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8: return VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8: return VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: return VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: return VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8: return VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8: return VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_EAC_R11: return VK_FORMAT_EAC_R11_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11: return VK_FORMAT_EAC_R11_SNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_EAC_RG11: return VK_FORMAT_EAC_R11G11_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11: return VK_FORMAT_EAC_R11G11_SNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA: return VK_FORMAT_ASTC_4x4_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8: return VK_FORMAT_ASTC_4x4_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA: return VK_FORMAT_ASTC_5x4_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8: return VK_FORMAT_ASTC_5x4_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA: return VK_FORMAT_ASTC_5x5_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_5x5_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA: return VK_FORMAT_ASTC_6x5_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_6x5_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA: return VK_FORMAT_ASTC_6x6_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8: return VK_FORMAT_ASTC_6x6_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA: return VK_FORMAT_ASTC_8x5_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_8x5_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA: return VK_FORMAT_ASTC_8x6_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8: return VK_FORMAT_ASTC_8x6_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA: return VK_FORMAT_ASTC_8x8_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8: return VK_FORMAT_ASTC_8x8_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA: return VK_FORMAT_ASTC_10x5_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x5_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA: return VK_FORMAT_ASTC_10x6_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x6_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA: return VK_FORMAT_ASTC_10x8_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x8_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA: return VK_FORMAT_ASTC_10x10_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8: return VK_FORMAT_ASTC_10x10_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA: return VK_FORMAT_ASTC_12x10_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8: return VK_FORMAT_ASTC_12x10_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA: return VK_FORMAT_ASTC_12x12_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8: return VK_FORMAT_ASTC_12x12_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK: return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK: return VK_FORMAT_BC1_RGB_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK: return VK_FORMAT_BC1_RGBA_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK: return VK_FORMAT_BC1_RGBA_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK: return VK_FORMAT_BC2_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK: return VK_FORMAT_BC2_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK: return VK_FORMAT_BC3_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK: return VK_FORMAT_BC3_SRGB_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK: return VK_FORMAT_BC4_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK: return VK_FORMAT_BC4_SNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK: return VK_FORMAT_BC5_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK: return VK_FORMAT_BC5_SNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK: return VK_FORMAT_BC6H_UFLOAT_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK: return VK_FORMAT_BC6H_SFLOAT_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK: return VK_FORMAT_BC7_UNORM_BLOCK;
case tcu::COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK: return VK_FORMAT_BC7_SRGB_BLOCK;
default:
TCU_THROW(InternalError, "Unknown texture format");
return VK_FORMAT_UNDEFINED;
}
}
tcu::TextureFormat mapVkFormat (VkFormat format)
{
using tcu::TextureFormat;
// update this mapping if VkFormat changes
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (format)
{
case VK_FORMAT_R4G4_UNORM_PACK8: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_BYTE_44);
case VK_FORMAT_R5G6B5_UNORM_PACK16: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_SHORT_565);
case VK_FORMAT_R4G4B4A4_UNORM_PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_4444);
case VK_FORMAT_R5G5B5A1_UNORM_PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551);
case VK_FORMAT_B5G6R5_UNORM_PACK16: return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_SHORT_565);
case VK_FORMAT_B4G4R4A4_UNORM_PACK16: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_4444);
case VK_FORMAT_B5G5R5A1_UNORM_PACK16: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_SHORT_5551);
case VK_FORMAT_A1R5G5B5_UNORM_PACK16: return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_1555);
case VK_FORMAT_R8_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT8);
case VK_FORMAT_R8_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::USCALED_INT8);
case VK_FORMAT_R8_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SSCALED_INT8);
case VK_FORMAT_R8_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_R8_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT8);
case VK_FORMAT_R8_SRGB: return TextureFormat(TextureFormat::sR, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8G8_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8G8_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT8);
case VK_FORMAT_R8G8_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::USCALED_INT8);
case VK_FORMAT_R8G8_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SSCALED_INT8);
case VK_FORMAT_R8G8_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_R8G8_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT8);
case VK_FORMAT_R8G8_SRGB: return TextureFormat(TextureFormat::sRG, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8G8B8_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8G8B8_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT8);
case VK_FORMAT_R8G8B8_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::USCALED_INT8);
case VK_FORMAT_R8G8B8_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SSCALED_INT8);
case VK_FORMAT_R8G8B8_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_R8G8B8_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT8);
case VK_FORMAT_R8G8B8_SRGB: return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8G8B8A8_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
case VK_FORMAT_R8G8B8A8_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8);
case VK_FORMAT_R8G8B8A8_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT8);
case VK_FORMAT_R8G8B8A8_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT8);
case VK_FORMAT_R8G8B8A8_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_R8G8B8A8_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8);
case VK_FORMAT_R8G8B8A8_SRGB: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
case VK_FORMAT_R16_UNORM: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16);
case VK_FORMAT_R16_SNORM: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16);
case VK_FORMAT_R16_USCALED: return TextureFormat(TextureFormat::R, TextureFormat::USCALED_INT16);
case VK_FORMAT_R16_SSCALED: return TextureFormat(TextureFormat::R, TextureFormat::SSCALED_INT16);
case VK_FORMAT_R16_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT16);
case VK_FORMAT_R16_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT16);
case VK_FORMAT_R16_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::HALF_FLOAT);
case VK_FORMAT_R16G16_UNORM: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16);
case VK_FORMAT_R16G16_SNORM: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16);
case VK_FORMAT_R16G16_USCALED: return TextureFormat(TextureFormat::RG, TextureFormat::USCALED_INT16);
case VK_FORMAT_R16G16_SSCALED: return TextureFormat(TextureFormat::RG, TextureFormat::SSCALED_INT16);
case VK_FORMAT_R16G16_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT16);
case VK_FORMAT_R16G16_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT16);
case VK_FORMAT_R16G16_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::HALF_FLOAT);
case VK_FORMAT_R16G16B16_UNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT16);
case VK_FORMAT_R16G16B16_SNORM: return TextureFormat(TextureFormat::RGB, TextureFormat::SNORM_INT16);
case VK_FORMAT_R16G16B16_USCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::USCALED_INT16);
case VK_FORMAT_R16G16B16_SSCALED: return TextureFormat(TextureFormat::RGB, TextureFormat::SSCALED_INT16);
case VK_FORMAT_R16G16B16_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT16);
case VK_FORMAT_R16G16B16_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT16);
case VK_FORMAT_R16G16B16_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT);
case VK_FORMAT_R16G16B16A16_UNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT16);
case VK_FORMAT_R16G16B16A16_SNORM: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT16);
case VK_FORMAT_R16G16B16A16_USCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT16);
case VK_FORMAT_R16G16B16A16_SSCALED: return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT16);
case VK_FORMAT_R16G16B16A16_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT16);
case VK_FORMAT_R16G16B16A16_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT16);
case VK_FORMAT_R16G16B16A16_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT);
case VK_FORMAT_R32_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT32);
case VK_FORMAT_R32_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT32);
case VK_FORMAT_R32_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT);
case VK_FORMAT_R32G32_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT32);
case VK_FORMAT_R32G32_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT32);
case VK_FORMAT_R32G32_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT);
case VK_FORMAT_R32G32B32_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT32);
case VK_FORMAT_R32G32B32_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT32);
case VK_FORMAT_R32G32B32_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT);
case VK_FORMAT_R32G32B32A32_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32);
case VK_FORMAT_R32G32B32A32_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32);
case VK_FORMAT_R32G32B32A32_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT);
case VK_FORMAT_R64_UINT: return TextureFormat(TextureFormat::R, TextureFormat::UNSIGNED_INT64);
case VK_FORMAT_R64G64_UINT: return TextureFormat(TextureFormat::RG, TextureFormat::UNSIGNED_INT64);
case VK_FORMAT_R64G64B64_UINT: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT64);
case VK_FORMAT_R64G64B64A64_UINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT64);
case VK_FORMAT_R64_SINT: return TextureFormat(TextureFormat::R, TextureFormat::SIGNED_INT64);
case VK_FORMAT_R64G64_SINT: return TextureFormat(TextureFormat::RG, TextureFormat::SIGNED_INT64);
case VK_FORMAT_R64G64B64_SINT: return TextureFormat(TextureFormat::RGB, TextureFormat::SIGNED_INT64);
case VK_FORMAT_R64G64B64A64_SINT: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT64);
case VK_FORMAT_R64_SFLOAT: return TextureFormat(TextureFormat::R, TextureFormat::FLOAT64);
case VK_FORMAT_R64G64_SFLOAT: return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT64);
case VK_FORMAT_R64G64B64_SFLOAT: return TextureFormat(TextureFormat::RGB, TextureFormat::FLOAT64);
case VK_FORMAT_R64G64B64A64_SFLOAT: return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT64);
case VK_FORMAT_B10G11R11_UFLOAT_PACK32: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_11F_11F_10F_REV);
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: return TextureFormat(TextureFormat::RGB, TextureFormat::UNSIGNED_INT_999_E5_REV);
case VK_FORMAT_B8G8R8_UNORM: return TextureFormat(TextureFormat::BGR, TextureFormat::UNORM_INT8);
case VK_FORMAT_B8G8R8_SNORM: return TextureFormat(TextureFormat::BGR, TextureFormat::SNORM_INT8);
case VK_FORMAT_B8G8R8_USCALED: return TextureFormat(TextureFormat::BGR, TextureFormat::USCALED_INT8);
case VK_FORMAT_B8G8R8_SSCALED: return TextureFormat(TextureFormat::BGR, TextureFormat::SSCALED_INT8);
case VK_FORMAT_B8G8R8_UINT: return TextureFormat(TextureFormat::BGR, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_B8G8R8_SINT: return TextureFormat(TextureFormat::BGR, TextureFormat::SIGNED_INT8);
case VK_FORMAT_B8G8R8_SRGB: return TextureFormat(TextureFormat::sBGR, TextureFormat::UNORM_INT8);
case VK_FORMAT_B8G8R8A8_UNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT8);
case VK_FORMAT_B8G8R8A8_SNORM: return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT8);
case VK_FORMAT_B8G8R8A8_USCALED: return TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT8);
case VK_FORMAT_B8G8R8A8_SSCALED: return TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT8);
case VK_FORMAT_B8G8R8A8_UINT: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_B8G8R8A8_SINT: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT8);
case VK_FORMAT_B8G8R8A8_SRGB: return TextureFormat(TextureFormat::sBGRA, TextureFormat::UNORM_INT8);
case VK_FORMAT_D16_UNORM: return TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16);
case VK_FORMAT_X8_D24_UNORM_PACK32: return TextureFormat(TextureFormat::D, TextureFormat::UNSIGNED_INT_24_8_REV);
case VK_FORMAT_D32_SFLOAT: return TextureFormat(TextureFormat::D, TextureFormat::FLOAT);
case VK_FORMAT_S8_UINT: return TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8);
// \note There is no standard interleaved memory layout for DS formats; buffer-image copies
// will always operate on either D or S aspect only. See Khronos bug 12998
case VK_FORMAT_D16_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_16_8_8);
case VK_FORMAT_D24_UNORM_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::UNSIGNED_INT_24_8_REV);
case VK_FORMAT_D32_SFLOAT_S8_UINT: return TextureFormat(TextureFormat::DS, TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV);
#if (DE_ENDIANNESS == DE_LITTLE_ENDIAN)
case VK_FORMAT_A8B8G8R8_UNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
case VK_FORMAT_A8B8G8R8_SNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT8);
case VK_FORMAT_A8B8G8R8_USCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT8);
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT8);
case VK_FORMAT_A8B8G8R8_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT8);
case VK_FORMAT_A8B8G8R8_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT8);
case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
#else
# error "Big-endian not supported"
#endif
case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNORM_INT_1010102_REV);
case VK_FORMAT_A2R10G10B10_SNORM_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SNORM_INT_1010102_REV);
case VK_FORMAT_A2R10G10B10_USCALED_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT_1010102_REV);
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT_1010102_REV);
case VK_FORMAT_A2R10G10B10_UINT_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV);
case VK_FORMAT_A2R10G10B10_SINT_PACK32: return TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_UNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_SNORM_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SNORM_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_USCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_UINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV);
case VK_FORMAT_A2B10G10R10_SINT_PACK32: return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV);
// YCbCr formats that can be mapped
case VK_FORMAT_R10X6_UNORM_PACK16: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_10);
case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_10);
case VK_FORMAT_R12X4_UNORM_PACK16: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_SHORT_12);
case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_12);
case VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: return TextureFormat(TextureFormat::ARGB, TextureFormat::UNORM_SHORT_4444);
case VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: return TextureFormat(TextureFormat::ABGR, TextureFormat::UNORM_SHORT_4444);
default:
TCU_THROW(InternalError, "Unknown image format");
}
}
tcu::CompressedTexFormat mapVkCompressedFormat (VkFormat format)
{
// update this mapping if VkFormat changes
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (format)
{
case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8;
case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8;
case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8;
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8;
case VK_FORMAT_EAC_R11_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_R11;
case VK_FORMAT_EAC_R11_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11;
case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_RG11;
case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11;
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA;
case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA;
case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA;
case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA;
case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA;
case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA;
case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA;
case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA;
case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA;
case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA;
case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA;
case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA;
case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA;
case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8;
case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA;
case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8;
case VK_FORMAT_BC1_RGB_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK;
case VK_FORMAT_BC1_RGB_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK;
case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK;
case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK;
case VK_FORMAT_BC2_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK;
case VK_FORMAT_BC2_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK;
case VK_FORMAT_BC3_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK;
case VK_FORMAT_BC3_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK;
case VK_FORMAT_BC4_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK;
case VK_FORMAT_BC4_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK;
case VK_FORMAT_BC5_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK;
case VK_FORMAT_BC5_SNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK;
case VK_FORMAT_BC6H_UFLOAT_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK;
case VK_FORMAT_BC6H_SFLOAT_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK;
case VK_FORMAT_BC7_UNORM_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK;
case VK_FORMAT_BC7_SRGB_BLOCK: return tcu::COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK;
default:
TCU_THROW(InternalError, "Unknown image format");
return tcu::COMPRESSEDTEXFORMAT_LAST;
}
}
static bool isScaledFormat (VkFormat format)
{
// update this mapping if VkFormat changes
DE_STATIC_ASSERT(VK_CORE_FORMAT_LAST == 185);
switch (format)
{
case VK_FORMAT_R8_USCALED:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8G8_USCALED:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8B8_USCALED:
case VK_FORMAT_R8G8B8_SSCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VK_FORMAT_R16_USCALED:
case VK_FORMAT_R16_SSCALED:
case VK_FORMAT_R16G16_USCALED:
case VK_FORMAT_R16G16_SSCALED:
case VK_FORMAT_R16G16B16_USCALED:
case VK_FORMAT_R16G16B16_SSCALED:
case VK_FORMAT_R16G16B16A16_USCALED:
case VK_FORMAT_R16G16B16A16_SSCALED:
case VK_FORMAT_B8G8R8_USCALED:
case VK_FORMAT_B8G8R8_SSCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
return true;
default:
return false;
}
}
static bool fullTextureFormatRoundTripSupported (VkFormat format)
{
if (isScaledFormat(format))
{
// *SCALED formats get mapped to correspoding (u)int formats since
// accessing them through (float) getPixel/setPixel has same behavior
// as in shader access in Vulkan.
// Unfortunately full round-trip between tcu::TextureFormat and VkFormat
// for most SCALED formats is not supported though.
const tcu::TextureFormat tcuFormat = mapVkFormat(format);
switch (tcuFormat.type)
{
case tcu::TextureFormat::UNSIGNED_INT8:
case tcu::TextureFormat::UNSIGNED_INT16:
case tcu::TextureFormat::UNSIGNED_INT32:
case tcu::TextureFormat::SIGNED_INT8:
case tcu::TextureFormat::SIGNED_INT16:
case tcu::TextureFormat::SIGNED_INT32:
case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
case tcu::TextureFormat::SIGNED_INT_1010102_REV:
return false;
default:
return true;
}
}
else
{
switch (format)
{
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
case VK_FORMAT_A8B8G8R8_SINT_PACK32:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
return false; // These map to regular byte array formats
default:
break;
}
return (format != VK_FORMAT_UNDEFINED);
}
}
tcu::TextureFormat getChannelAccessFormat (tcu::TextureChannelClass type,
deUint32 offsetBits,
deUint32 sizeBits)
{
using tcu::TextureFormat;
if (offsetBits == 0)
{
static const TextureFormat::ChannelType s_size8[tcu::TEXTURECHANNELCLASS_LAST] =
{
TextureFormat::SNORM_INT8, // snorm
TextureFormat::UNORM_INT8, // unorm
TextureFormat::SIGNED_INT8, // sint
TextureFormat::UNSIGNED_INT8, // uint
TextureFormat::CHANNELTYPE_LAST, // float
};
static const TextureFormat::ChannelType s_size16[tcu::TEXTURECHANNELCLASS_LAST] =
{
TextureFormat::SNORM_INT16, // snorm
TextureFormat::UNORM_INT16, // unorm
TextureFormat::SIGNED_INT16, // sint
TextureFormat::UNSIGNED_INT16, // uint
TextureFormat::HALF_FLOAT, // float
};
static const TextureFormat::ChannelType s_size32[tcu::TEXTURECHANNELCLASS_LAST] =
{
TextureFormat::SNORM_INT32, // snorm
TextureFormat::UNORM_INT32, // unorm
TextureFormat::SIGNED_INT32, // sint
TextureFormat::UNSIGNED_INT32, // uint
TextureFormat::FLOAT, // float
};
static const TextureFormat::ChannelType s_size64[tcu::TEXTURECHANNELCLASS_LAST] =
{
TextureFormat::CHANNELTYPE_LAST, // snorm
TextureFormat::CHANNELTYPE_LAST, // unorm
TextureFormat::SIGNED_INT64, // sint
TextureFormat::UNSIGNED_INT64, // uint
TextureFormat::FLOAT64, // float
};
TextureFormat::ChannelType chnType = TextureFormat::CHANNELTYPE_LAST;
if (sizeBits == 8)
chnType = s_size8[type];
else if (sizeBits == 16)
chnType = s_size16[type];
else if (sizeBits == 32)
chnType = s_size32[type];
else if (sizeBits == 64)
chnType = s_size64[type];
if (chnType != TextureFormat::CHANNELTYPE_LAST)
return TextureFormat(TextureFormat::R, chnType);
}
else
{
if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT &&
offsetBits == 6 &&
sizeBits == 10)
return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_10);
else if (type == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT &&
offsetBits == 4 &&
sizeBits == 12)
return TextureFormat(TextureFormat::R, TextureFormat::UNORM_SHORT_12);
}
TCU_THROW(InternalError, "Channel access format is not supported");
}
tcu::PixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
const tcu::UVec2& size,
const deUint32* planeRowPitches,
void* const* planePtrs,
deUint32 channelNdx)
{
DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
const deUint32 planeNdx = formatInfo.channels[channelNdx].planeNdx;
const deUint32 planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
const deUint32 valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
const deUint32 pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
DE_ASSERT(size.x() % (formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor) == 0);
DE_ASSERT(size.y() % (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor) == 0);
const deUint32 accessHeight = size.y() / ( formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor );
const deUint32 elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
const deUint32 rowPitch = planeRowPitches[planeNdx];
DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
tcu::IVec3 texDivider(
std::max(formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor * pixelStrideBytes / elementSizeBytes, 1u),
std::max(formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor * pixelStrideBytes / elementSizeBytes, 1u),
1);
return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
valueOffsetBits,
formatInfo.channels[channelNdx].sizeBits),
tcu::IVec3((int)size.x(), (int)size.y(), 1),
tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, (int)(accessHeight*rowPitch)),
texDivider,
(deUint8*)planePtrs[planeNdx] + planeOffsetBytes);
}
tcu::ConstPixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
const tcu::UVec2& size,
const deUint32* planeRowPitches,
const void* const* planePtrs,
deUint32 channelNdx)
{
return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void* const*>(planePtrs), channelNdx);
}
tcu::PixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
const tcu::UVec3& size,
const deUint32* planeRowPitches,
void* const* planePtrs,
deUint32 channelNdx)
{
DE_ASSERT(formatInfo.hasChannelNdx(channelNdx));
const deUint32 planeNdx = formatInfo.channels[channelNdx].planeNdx;
const deUint32 planeOffsetBytes = formatInfo.channels[channelNdx].offsetBits / 8;
const deUint32 valueOffsetBits = formatInfo.channels[channelNdx].offsetBits % 8;
const deUint32 pixelStrideBytes = formatInfo.channels[channelNdx].strideBytes;
DE_ASSERT(size.x() % (formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor) == 0);
DE_ASSERT(size.y() % (formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor) == 0);
const deUint32 accessHeight = size.y() / ( formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor );
const deUint32 elementSizeBytes = formatInfo.planes[planeNdx].elementSizeBytes;
const deUint32 rowPitch = planeRowPitches[planeNdx];
DE_ASSERT(elementSizeBytes % pixelStrideBytes == 0);
tcu::IVec3 texDivider(
std::max(formatInfo.blockWidth * formatInfo.planes[planeNdx].widthDivisor * pixelStrideBytes / elementSizeBytes, 1u),
std::max(formatInfo.blockHeight * formatInfo.planes[planeNdx].heightDivisor * pixelStrideBytes / elementSizeBytes, 1u),
1);
return tcu::PixelBufferAccess(getChannelAccessFormat((tcu::TextureChannelClass)formatInfo.channels[channelNdx].type,
valueOffsetBits,
formatInfo.channels[channelNdx].sizeBits),
tcu::IVec3((int)size.x(), (int)size.y(), (int)size.z()),
tcu::IVec3((int)pixelStrideBytes, (int)rowPitch, (int)(accessHeight*rowPitch)),
texDivider,
(deUint8*)planePtrs[planeNdx] + planeOffsetBytes);
}
tcu::ConstPixelBufferAccess getChannelAccess (const PlanarFormatDescription& formatInfo,
const tcu::UVec3& size,
const deUint32* planeRowPitches,
const void* const* planePtrs,
deUint32 channelNdx)
{
return getChannelAccess(formatInfo, size, planeRowPitches, const_cast<void* const*>(planePtrs), channelNdx);
}
void imageUtilSelfTest (void)
{
for (int formatNdx = 0; formatNdx < VK_CORE_FORMAT_LAST; formatNdx++)
{
const VkFormat format = (VkFormat)formatNdx;
if (format == VK_FORMAT_R64_UINT ||
format == VK_FORMAT_R64_SINT ||
format == VK_FORMAT_R64G64_UINT ||
format == VK_FORMAT_R64G64_SINT ||
format == VK_FORMAT_R64G64B64_UINT ||
format == VK_FORMAT_R64G64B64_SINT ||
format == VK_FORMAT_R64G64B64A64_UINT ||
format == VK_FORMAT_R64G64B64A64_SINT)
continue; // \todo [2015-12-05 pyry] Add framework support for (u)int64 channel type
if (format != VK_FORMAT_UNDEFINED && !isCompressedFormat(format))
{
const tcu::TextureFormat tcuFormat = mapVkFormat(format);
const VkFormat remappedFormat = mapTextureFormat(tcuFormat);
DE_TEST_ASSERT(isValid(tcuFormat));
if (fullTextureFormatRoundTripSupported(format))
DE_TEST_ASSERT(format == remappedFormat);
}
}
for (int formatNdx = VK_FORMAT_G8B8G8R8_422_UNORM; formatNdx <= VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM; formatNdx++)
{
const VkFormat format = (VkFormat)formatNdx;
const PlanarFormatDescription& info = getPlanarFormatDescription(format);
DE_TEST_ASSERT(isYCbCrFormat(format));
DE_TEST_ASSERT(de::inRange<deUint8>(info.numPlanes, 1u, 3u));
DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
}
for (int formatNdx = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT; formatNdx <= VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT; formatNdx++)
{
const VkFormat format = (VkFormat)formatNdx;
const PlanarFormatDescription& info = getPlanarFormatDescription(format);
DE_TEST_ASSERT(isYCbCrFormat(format));
DE_TEST_ASSERT(de::inRange<deUint8>(info.numPlanes, 1u, 3u));
DE_TEST_ASSERT(info.numPlanes == getPlaneCount(format));
}
}
struct CompressedFormatParameters
{
VkFormat format;
deUint32 blockBytes;
deUint32 blockWidth;
deUint32 blockHeight;
};
CompressedFormatParameters compressedFormatParameters[VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_BC1_RGB_UNORM_BLOCK + 1] =
{
{ VK_FORMAT_BC1_RGB_UNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_BC1_RGB_SRGB_BLOCK, 8, 4, 4 },
{ VK_FORMAT_BC1_RGBA_UNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_BC1_RGBA_SRGB_BLOCK, 8, 4, 4 },
{ VK_FORMAT_BC2_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC2_SRGB_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC3_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC3_SRGB_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC4_UNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_BC4_SNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_BC5_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC5_SNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC6H_UFLOAT_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC6H_SFLOAT_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC7_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_BC7_SRGB_BLOCK, 16, 4, 4 },
{ VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, 8, 4, 4 },
{ VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, 8, 4, 4 },
{ VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, 16, 4, 4 },
{ VK_FORMAT_EAC_R11_UNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_EAC_R11_SNORM_BLOCK, 8, 4, 4 },
{ VK_FORMAT_EAC_R11G11_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_EAC_R11G11_SNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_ASTC_4x4_UNORM_BLOCK, 16, 4, 4 },
{ VK_FORMAT_ASTC_4x4_SRGB_BLOCK, 16, 4, 4 },
{ VK_FORMAT_ASTC_5x4_UNORM_BLOCK, 16, 5, 4 },
{ VK_FORMAT_ASTC_5x4_SRGB_BLOCK, 16, 5, 4 },
{ VK_FORMAT_ASTC_5x5_UNORM_BLOCK, 16, 5, 5 },
{ VK_FORMAT_ASTC_5x5_SRGB_BLOCK, 16, 5, 5 },
{ VK_FORMAT_ASTC_6x5_UNORM_BLOCK, 16, 6, 5 },
{ VK_FORMAT_ASTC_6x5_SRGB_BLOCK, 16, 6, 5 },
{ VK_FORMAT_ASTC_6x6_UNORM_BLOCK, 16, 6, 6 },
{ VK_FORMAT_ASTC_6x6_SRGB_BLOCK, 16, 6, 6 },
{ VK_FORMAT_ASTC_8x5_UNORM_BLOCK, 16, 8, 5 },
{ VK_FORMAT_ASTC_8x5_SRGB_BLOCK, 16, 8, 5 },
{ VK_FORMAT_ASTC_8x6_UNORM_BLOCK, 16, 8, 6 },
{ VK_FORMAT_ASTC_8x6_SRGB_BLOCK, 16, 8, 6 },
{ VK_FORMAT_ASTC_8x8_UNORM_BLOCK, 16, 8, 8 },
{ VK_FORMAT_ASTC_8x8_SRGB_BLOCK, 16, 8, 8 },
{ VK_FORMAT_ASTC_10x5_UNORM_BLOCK, 16, 10, 5 },
{ VK_FORMAT_ASTC_10x5_SRGB_BLOCK, 16, 10, 5 },
{ VK_FORMAT_ASTC_10x6_UNORM_BLOCK, 16, 10, 6 },
{ VK_FORMAT_ASTC_10x6_SRGB_BLOCK, 16, 10, 6 },
{ VK_FORMAT_ASTC_10x8_UNORM_BLOCK, 16, 10, 8 },
{ VK_FORMAT_ASTC_10x8_SRGB_BLOCK, 16, 10, 8 },
{ VK_FORMAT_ASTC_10x10_UNORM_BLOCK, 16, 10, 10 },
{ VK_FORMAT_ASTC_10x10_SRGB_BLOCK, 16, 10, 10 },
{ VK_FORMAT_ASTC_12x10_UNORM_BLOCK, 16, 12, 10 },
{ VK_FORMAT_ASTC_12x10_SRGB_BLOCK, 16, 12, 10 },
{ VK_FORMAT_ASTC_12x12_UNORM_BLOCK, 16, 12, 12 },
{ VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 16, 12, 12 }
};
deUint32 getFormatComponentWidth (const VkFormat format, const deUint32 componentNdx)
{
const tcu::TextureFormat tcuFormat (mapVkFormat(format));
const deUint32 componentCount (tcu::getNumUsedChannels(tcuFormat.order));
if (componentNdx >= componentCount)
DE_FATAL("Component index out of range");
else
{
switch (tcuFormat.type)
{
case tcu::TextureFormat::UNORM_INT8:
case tcu::TextureFormat::SNORM_INT8:
case tcu::TextureFormat::UNSIGNED_INT8:
case tcu::TextureFormat::SIGNED_INT8:
return 8;
case tcu::TextureFormat::UNORM_SHORT_10:
return 10;
case tcu::TextureFormat::UNORM_SHORT_12:
return 12;
case tcu::TextureFormat::UNORM_INT16:
case tcu::TextureFormat::SNORM_INT16:
case tcu::TextureFormat::UNSIGNED_INT16:
case tcu::TextureFormat::SIGNED_INT16:
return 16;
case tcu::TextureFormat::UNORM_INT24:
case tcu::TextureFormat::UNSIGNED_INT24:
return 24;
case tcu::TextureFormat::UNORM_INT32:
case tcu::TextureFormat::SNORM_INT32:
case tcu::TextureFormat::UNSIGNED_INT32:
case tcu::TextureFormat::SIGNED_INT32:
case tcu::TextureFormat::FLOAT:
return 32;
case tcu::TextureFormat::FLOAT64:
case tcu::TextureFormat::UNSIGNED_INT64:
case tcu::TextureFormat::SIGNED_INT64:
return 64;
// Packed formats
case tcu::TextureFormat::UNORM_SHORT_4444:
case tcu::TextureFormat::UNSIGNED_SHORT_4444:
return 4;
case tcu::TextureFormat::UNORM_SHORT_565:
case tcu::TextureFormat::UNSIGNED_SHORT_565:
return (componentNdx == 1 ? 6 : 5);
case tcu::TextureFormat::UNSIGNED_INT_24_8:
case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
return (componentNdx == 0 ? 24 : 8);
case tcu::TextureFormat::UNORM_SHORT_1555:
return (componentNdx == 0 ? 1 : 5);
case tcu::TextureFormat::UNORM_INT_1010102_REV:
case tcu::TextureFormat::SNORM_INT_1010102_REV:
case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
case tcu::TextureFormat::SIGNED_INT_1010102_REV:
return (componentNdx == 3 ? 2 : 10);
default:
DE_FATAL("Format unimplemented");
}
}
return 0;
}
float getRepresentableDiffUnorm (const VkFormat format, const deUint32 componentNdx)
{
const deUint32 size (getFormatComponentWidth(format, componentNdx));
return 1.0f / float((1 << (size)) - 1);
}
float getRepresentableDiffSnorm (const VkFormat format, const deUint32 componentNdx)
{
const deUint32 size (getFormatComponentWidth(format, componentNdx));
return 1.0f / float((1 << (size - 1)) - 1);
}
deUint32 getBlockSizeInBytes (const VkFormat compressedFormat)
{
deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
return compressedFormatParameters[formatNdx].blockBytes;
}
deUint32 getBlockWidth (const VkFormat compressedFormat)
{
deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
return compressedFormatParameters[formatNdx].blockWidth;
}
deUint32 getBlockHeight (const VkFormat compressedFormat)
{
deUint32 formatNdx = static_cast<deUint32>(compressedFormat - VK_FORMAT_BC1_RGB_UNORM_BLOCK);
DE_ASSERT(deInRange32(formatNdx, 0, DE_LENGTH_OF_ARRAY(compressedFormatParameters)));
DE_ASSERT(compressedFormatParameters[formatNdx].format == compressedFormat);
return compressedFormatParameters[formatNdx].blockHeight;
}
VkFilter mapFilterMode (tcu::Sampler::FilterMode filterMode)
{
DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 9);
switch (filterMode)
{
case tcu::Sampler::NEAREST: return VK_FILTER_NEAREST;
case tcu::Sampler::LINEAR: return VK_FILTER_LINEAR;
case tcu::Sampler::CUBIC: return VK_FILTER_CUBIC_EXT;
case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_FILTER_NEAREST;
case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_FILTER_NEAREST;
case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_FILTER_LINEAR;
case tcu::Sampler::LINEAR_MIPMAP_LINEAR: return VK_FILTER_LINEAR;
case tcu::Sampler::CUBIC_MIPMAP_NEAREST: return VK_FILTER_CUBIC_EXT;
case tcu::Sampler::CUBIC_MIPMAP_LINEAR: return VK_FILTER_CUBIC_EXT;
default:
DE_FATAL("Illegal filter mode");
return (VkFilter)0;
}
}
VkSamplerMipmapMode mapMipmapMode (tcu::Sampler::FilterMode filterMode)
{
DE_STATIC_ASSERT(tcu::Sampler::FILTERMODE_LAST == 9);
// \note VkSamplerCreateInfo doesn't have a flag for disabling mipmapping. Instead
// minLod = 0 and maxLod = 0.25 should be used to match OpenGL NEAREST and LINEAR
// filtering mode behavior.
switch (filterMode)
{
case tcu::Sampler::NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::LINEAR: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::CUBIC: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::NEAREST_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::NEAREST_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR;
case tcu::Sampler::LINEAR_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::LINEAR_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR;
case tcu::Sampler::CUBIC_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case tcu::Sampler::CUBIC_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR;
default:
DE_FATAL("Illegal filter mode");
return (VkSamplerMipmapMode)0;
}
}
VkSamplerAddressMode mapWrapMode (tcu::Sampler::WrapMode wrapMode)
{
switch (wrapMode)
{
case tcu::Sampler::CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
case tcu::Sampler::CLAMP_TO_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
case tcu::Sampler::REPEAT_GL: return VK_SAMPLER_ADDRESS_MODE_REPEAT;
case tcu::Sampler::MIRRORED_REPEAT_GL: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
case tcu::Sampler::MIRRORED_ONCE: return VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
default:
DE_FATAL("Wrap mode can't be mapped to Vulkan");
return (vk::VkSamplerAddressMode)0;
}
}
vk::VkCompareOp mapCompareMode (tcu::Sampler::CompareMode mode)
{
switch (mode)
{
case tcu::Sampler::COMPAREMODE_NONE: return vk::VK_COMPARE_OP_NEVER;
case tcu::Sampler::COMPAREMODE_LESS: return vk::VK_COMPARE_OP_LESS;
case tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL: return vk::VK_COMPARE_OP_LESS_OR_EQUAL;
case tcu::Sampler::COMPAREMODE_GREATER: return vk::VK_COMPARE_OP_GREATER;
case tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL: return vk::VK_COMPARE_OP_GREATER_OR_EQUAL;
case tcu::Sampler::COMPAREMODE_EQUAL: return vk::VK_COMPARE_OP_EQUAL;
case tcu::Sampler::COMPAREMODE_NOT_EQUAL: return vk::VK_COMPARE_OP_NOT_EQUAL;
case tcu::Sampler::COMPAREMODE_ALWAYS: return vk::VK_COMPARE_OP_ALWAYS;
case tcu::Sampler::COMPAREMODE_NEVER: return vk::VK_COMPARE_OP_NEVER;
default:
DE_FATAL("Illegal compare mode");
return (vk::VkCompareOp)0;
}
}
static VkBorderColor mapBorderColor (tcu::TextureChannelClass channelClass, const rr::GenericVec4& color)
{
if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
{
const tcu::UVec4 uColor = color.get<deUint32>();
if (uColor == tcu::UVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
else if (uColor == tcu::UVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
else if (uColor == tcu::UVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
else return VK_BORDER_COLOR_INT_CUSTOM_EXT;
}
else if (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)
{
const tcu::IVec4 sColor = color.get<deInt32>();
if (sColor == tcu::IVec4(0, 0, 0, 0)) return VK_BORDER_COLOR_INT_TRANSPARENT_BLACK;
else if (sColor == tcu::IVec4(0, 0, 0, 1)) return VK_BORDER_COLOR_INT_OPAQUE_BLACK;
else if (sColor == tcu::IVec4(1, 1, 1, 1)) return VK_BORDER_COLOR_INT_OPAQUE_WHITE;
else return VK_BORDER_COLOR_INT_CUSTOM_EXT;
}
else
{
const tcu::Vec4 fColor = color.get<float>();
if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f)) return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
else if (fColor == tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK;
else if (fColor == tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f)) return VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
else return VK_BORDER_COLOR_FLOAT_CUSTOM_EXT;
}
// note: never reached
DE_FATAL("Unsupported border color");
return VK_BORDER_COLOR_MAX_ENUM;
}
VkSamplerCreateInfo mapSampler (const tcu::Sampler& sampler, const tcu::TextureFormat& format, float minLod, float maxLod, bool unnormal)
{
const bool compareEnabled = (sampler.compare != tcu::Sampler::COMPAREMODE_NONE);
const VkCompareOp compareOp = (compareEnabled) ? (mapCompareMode(sampler.compare)) : (VK_COMPARE_OP_ALWAYS);
const VkBorderColor borderColor = mapBorderColor(getTextureChannelClass(format.type), sampler.borderColor);
const bool isMipmapEnabled = (sampler.minFilter != tcu::Sampler::NEAREST && sampler.minFilter != tcu::Sampler::LINEAR && sampler.minFilter != tcu::Sampler::CUBIC);
const VkSamplerCreateInfo createInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
DE_NULL,
(VkSamplerCreateFlags)0,
mapFilterMode(sampler.magFilter), // magFilter
mapFilterMode(sampler.minFilter), // minFilter
mapMipmapMode(sampler.minFilter), // mipMode
mapWrapMode(sampler.wrapS), // addressU
mapWrapMode(sampler.wrapT), // addressV
mapWrapMode(sampler.wrapR), // addressW
0.0f, // mipLodBias
VK_FALSE, // anisotropyEnable
1.0f, // maxAnisotropy
(VkBool32)(compareEnabled ? VK_TRUE : VK_FALSE), // compareEnable
compareOp, // compareOp
(isMipmapEnabled ? minLod : 0.0f), // minLod
(isMipmapEnabled ? maxLod : (unnormal ? 0.0f : 0.25f)), // maxLod
borderColor, // borderColor
(VkBool32)(sampler.normalizedCoords ? VK_FALSE : VK_TRUE), // unnormalizedCoords
};
return createInfo;
}
rr::GenericVec4 mapVkColor (const VkClearColorValue& color)
{
rr::GenericVec4 value;
static_assert(sizeof(rr::GenericVec4) == sizeof(VkClearColorValue), "GenericVec4 and VkClearColorValue size mismatch");
deMemcpy(&value, &color, sizeof(rr::GenericVec4));
return value;
}
VkClearColorValue mapVkColor(const rr::GenericVec4& color)
{
VkClearColorValue value;
static_assert(sizeof(rr::GenericVec4) == sizeof(VkClearColorValue), "GenericVec4 and VkClearColorValue size mismatch");
deMemcpy(&value, &color, sizeof(VkClearColorValue));
return value;
}
tcu::Sampler mapVkSampler (const VkSamplerCreateInfo& samplerCreateInfo)
{
// \note minLod & maxLod are not supported by tcu::Sampler. LOD must be clamped
// before passing it to tcu::Texture*::sample*()
tcu::Sampler::ReductionMode reductionMode = tcu::Sampler::WEIGHTED_AVERAGE;
rr::GenericVec4 borderColorValue;
void const *pNext = samplerCreateInfo.pNext;
while (pNext != DE_NULL)
{
const VkStructureType nextType = *reinterpret_cast<const VkStructureType*>(pNext);
switch (nextType)
{
case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
{
const VkSamplerReductionModeCreateInfo reductionModeCreateInfo = *reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(pNext);
reductionMode = mapVkSamplerReductionMode(reductionModeCreateInfo.reductionMode);
pNext = reinterpret_cast<const VkSamplerReductionModeCreateInfo*>(pNext)->pNext;
break;
}
case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
pNext = reinterpret_cast<const VkSamplerYcbcrConversionInfo*>(pNext)->pNext;
break;
case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT:
{
const VkSamplerCustomBorderColorCreateInfoEXT customBorderColorCreateInfo = *reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(pNext);
borderColorValue = mapVkColor(customBorderColorCreateInfo.customBorderColor);
pNext = reinterpret_cast<const VkSamplerCustomBorderColorCreateInfoEXT*>(pNext)->pNext;
break;
}
default:
TCU_FAIL("Unrecognized sType in chained sampler create info");
}
}
tcu::Sampler sampler(mapVkSamplerAddressMode(samplerCreateInfo.addressModeU),
mapVkSamplerAddressMode(samplerCreateInfo.addressModeV),
mapVkSamplerAddressMode(samplerCreateInfo.addressModeW),
mapVkMinTexFilter(samplerCreateInfo.minFilter, samplerCreateInfo.mipmapMode),
mapVkMagTexFilter(samplerCreateInfo.magFilter),
0.0f,
!samplerCreateInfo.unnormalizedCoordinates,
samplerCreateInfo.compareEnable ? mapVkSamplerCompareOp(samplerCreateInfo.compareOp)
: tcu::Sampler::COMPAREMODE_NONE,
0,
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
true,
tcu::Sampler::MODE_DEPTH,
reductionMode);
if (samplerCreateInfo.anisotropyEnable)
TCU_THROW(InternalError, "Anisotropic filtering is not supported by tcu::Sampler");
switch (samplerCreateInfo.borderColor)
{
case VK_BORDER_COLOR_INT_OPAQUE_BLACK:
sampler.borderColor = tcu::UVec4(0,0,0,1);
break;
case VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK:
sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
break;
case VK_BORDER_COLOR_INT_OPAQUE_WHITE:
sampler.borderColor = tcu::UVec4(1, 1, 1, 1);
break;
case VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE:
sampler.borderColor = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);
break;
case VK_BORDER_COLOR_INT_TRANSPARENT_BLACK:
sampler.borderColor = tcu::UVec4(0,0,0,0);
break;
case VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK:
sampler.borderColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f);
break;
case VK_BORDER_COLOR_FLOAT_CUSTOM_EXT:
case VK_BORDER_COLOR_INT_CUSTOM_EXT:
sampler.borderColor = borderColorValue;
break;
default:
DE_ASSERT(false);
break;
}
return sampler;
}
tcu::Sampler::CompareMode mapVkSamplerCompareOp (VkCompareOp compareOp)
{
switch (compareOp)
{
case VK_COMPARE_OP_NEVER: return tcu::Sampler::COMPAREMODE_NEVER;
case VK_COMPARE_OP_LESS: return tcu::Sampler::COMPAREMODE_LESS;
case VK_COMPARE_OP_EQUAL: return tcu::Sampler::COMPAREMODE_EQUAL;
case VK_COMPARE_OP_LESS_OR_EQUAL: return tcu::Sampler::COMPAREMODE_LESS_OR_EQUAL;
case VK_COMPARE_OP_GREATER: return tcu::Sampler::COMPAREMODE_GREATER;
case VK_COMPARE_OP_NOT_EQUAL: return tcu::Sampler::COMPAREMODE_NOT_EQUAL;
case VK_COMPARE_OP_GREATER_OR_EQUAL: return tcu::Sampler::COMPAREMODE_GREATER_OR_EQUAL;
case VK_COMPARE_OP_ALWAYS: return tcu::Sampler::COMPAREMODE_ALWAYS;
default:
break;
}
DE_ASSERT(false);
return tcu::Sampler::COMPAREMODE_LAST;
}
tcu::Sampler::WrapMode mapVkSamplerAddressMode (VkSamplerAddressMode addressMode)
{
switch (addressMode)
{
case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: return tcu::Sampler::CLAMP_TO_EDGE;
case VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: return tcu::Sampler::CLAMP_TO_BORDER;
case VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: return tcu::Sampler::MIRRORED_REPEAT_GL;
case VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: return tcu::Sampler::MIRRORED_ONCE;
case VK_SAMPLER_ADDRESS_MODE_REPEAT: return tcu::Sampler::REPEAT_GL;
default:
break;
}
DE_ASSERT(false);
return tcu::Sampler::WRAPMODE_LAST;
}
tcu::Sampler::ReductionMode mapVkSamplerReductionMode (VkSamplerReductionMode reductionMode)
{
switch (reductionMode)
{
case VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE: return tcu::Sampler::WEIGHTED_AVERAGE;
case VK_SAMPLER_REDUCTION_MODE_MIN: return tcu::Sampler::MIN;
case VK_SAMPLER_REDUCTION_MODE_MAX: return tcu::Sampler::MAX;
default:
break;
}
DE_ASSERT(false);
return tcu::Sampler::REDUCTIONMODE_LAST;
}
tcu::Sampler::FilterMode mapVkMinTexFilter (VkFilter filter, VkSamplerMipmapMode mipMode)
{
switch (filter)
{
case VK_FILTER_LINEAR:
switch (mipMode)
{
case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::LINEAR_MIPMAP_LINEAR;
case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::LINEAR_MIPMAP_NEAREST;
default:
break;
}
break;
case VK_FILTER_NEAREST:
switch (mipMode)
{
case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::NEAREST_MIPMAP_LINEAR;
case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::NEAREST_MIPMAP_NEAREST;
default:
break;
}
break;
case VK_FILTER_CUBIC_EXT:
switch (mipMode)
{
case VK_SAMPLER_MIPMAP_MODE_LINEAR: return tcu::Sampler::CUBIC_MIPMAP_LINEAR;
case VK_SAMPLER_MIPMAP_MODE_NEAREST: return tcu::Sampler::CUBIC_MIPMAP_NEAREST;
default:
break;
}
break;
default:
break;
}
DE_ASSERT(false);
return tcu::Sampler::FILTERMODE_LAST;
}
tcu::Sampler::FilterMode mapVkMagTexFilter (VkFilter filter)
{
switch (filter)
{
case VK_FILTER_LINEAR: return tcu::Sampler::LINEAR;
case VK_FILTER_NEAREST: return tcu::Sampler::NEAREST;
case VK_FILTER_CUBIC_EXT: return tcu::Sampler::CUBIC;
default:
break;
}
DE_ASSERT(false);
return tcu::Sampler::FILTERMODE_LAST;
}
//! Get a format that matches the layout in buffer memory used for a
//! buffer<->image copy on a depth/stencil format.
tcu::TextureFormat getDepthCopyFormat (VkFormat combinedFormat)
{
switch (combinedFormat)
{
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_D32_SFLOAT:
return mapVkFormat(combinedFormat);
case VK_FORMAT_D16_UNORM_S8_UINT:
return mapVkFormat(VK_FORMAT_D16_UNORM);
case VK_FORMAT_D24_UNORM_S8_UINT:
return mapVkFormat(VK_FORMAT_X8_D24_UNORM_PACK32);
case VK_FORMAT_D32_SFLOAT_S8_UINT:
return mapVkFormat(VK_FORMAT_D32_SFLOAT);
case VK_FORMAT_S8_UINT:
default:
DE_FATAL("Unexpected depth/stencil format");
return tcu::TextureFormat();
}
}
//! Get a format that matches the layout in buffer memory used for a
//! buffer<->image copy on a depth/stencil format.
tcu::TextureFormat getStencilCopyFormat (VkFormat combinedFormat)
{
switch (combinedFormat)
{
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_S8_UINT:
return mapVkFormat(VK_FORMAT_S8_UINT);
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_D32_SFLOAT:
default:
DE_FATAL("Unexpected depth/stencil format");
return tcu::TextureFormat();
}
}
VkImageAspectFlags getImageAspectFlags (const tcu::TextureFormat textureFormat)
{
VkImageAspectFlags imageAspectFlags = 0;
if (tcu::hasDepthComponent(textureFormat.order))
imageAspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
if (tcu::hasStencilComponent(textureFormat.order))
imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
if (imageAspectFlags == 0)
imageAspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
return imageAspectFlags;
}
VkExtent3D mipLevelExtents (const VkExtent3D& baseExtents, const deUint32 mipLevel)
{
VkExtent3D result;
result.width = std::max(baseExtents.width >> mipLevel, 1u);
result.height = std::max(baseExtents.height >> mipLevel, 1u);
result.depth = std::max(baseExtents.depth >> mipLevel, 1u);
return result;
}
tcu::UVec3 alignedDivide (const VkExtent3D& extent, const VkExtent3D& divisor)
{
tcu::UVec3 result;
result.x() = extent.width / divisor.width + ((extent.width % divisor.width != 0) ? 1u : 0u);
result.y() = extent.height / divisor.height + ((extent.height % divisor.height != 0) ? 1u : 0u);
result.z() = extent.depth / divisor.depth + ((extent.depth % divisor.depth != 0) ? 1u : 0u);
return result;
}
void copyBufferToImage (const DeviceInterface& vk,
const VkCommandBuffer& cmdBuffer,
const VkBuffer& buffer,
VkDeviceSize bufferSize,
const std::vector<VkBufferImageCopy>& copyRegions,
VkImageAspectFlags imageAspectFlags,
deUint32 mipLevels,
deUint32 arrayLayers,
VkImage destImage,
VkImageLayout destImageLayout,
VkPipelineStageFlags destImageDstStageFlags)
{
// Barriers for copying buffer to image
const VkBufferMemoryBarrier preBufferBarrier =
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_HOST_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
buffer, // VkBuffer buffer;
0u, // VkDeviceSize offset;
bufferSize // VkDeviceSize size;
};
const VkImageMemoryBarrier preImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
destImage, // VkImage image;
{ // VkImageSubresourceRange subresourceRange;
imageAspectFlags, // VkImageAspectFlags aspect;
0u, // deUint32 baseMipLevel;
mipLevels, // deUint32 mipLevels;
0u, // deUint32 baseArraySlice;
arrayLayers // deUint32 arraySize;
}
};
const VkImageMemoryBarrier postImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags dstAccessMask;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
destImageLayout, // VkImageLayout newLayout;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
destImage, // VkImage image;
{ // VkImageSubresourceRange subresourceRange;
imageAspectFlags, // VkImageAspectFlags aspect;
0u, // deUint32 baseMipLevel;
mipLevels, // deUint32 mipLevels;
0u, // deUint32 baseArraySlice;
arrayLayers // deUint32 arraySize;
}
};
// Copy buffer to image
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &preBufferBarrier, 1, &preImageBarrier);
vk.cmdCopyBufferToImage(cmdBuffer, buffer, destImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegions.size(), copyRegions.data());
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, destImageDstStageFlags, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
}
void copyBufferToImage (const DeviceInterface& vk,
VkDevice device,
VkQueue queue,
deUint32 queueFamilyIndex,
const VkBuffer& buffer,
VkDeviceSize bufferSize,
const std::vector<VkBufferImageCopy>& copyRegions,
const VkSemaphore* waitSemaphore,
VkImageAspectFlags imageAspectFlags,
deUint32 mipLevels,
deUint32 arrayLayers,
VkImage destImage,
VkImageLayout destImageLayout,
VkPipelineStageFlags destImageDstStageFlags)
{
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
Move<VkFence> fence = createFence(vk, device);
const VkCommandBufferBeginInfo cmdBufferBeginInfo =
{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
(const VkCommandBufferInheritanceInfo*)DE_NULL,
};
VK_CHECK(vk.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
copyBufferToImage(vk, *cmdBuffer, buffer, bufferSize, copyRegions, imageAspectFlags, mipLevels, arrayLayers, destImage, destImageLayout, destImageDstStageFlags);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const VkPipelineStageFlags pipelineStageFlags = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
const VkSubmitInfo submitInfo =
{
VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
waitSemaphore ? 1u : 0u, // deUint32 waitSemaphoreCount;
waitSemaphore, // const VkSemaphore* pWaitSemaphores;
&pipelineStageFlags, // const VkPipelineStageFlags* pWaitDstStageMask;
1u, // deUint32 commandBufferCount;
&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
0u, // deUint32 signalSemaphoreCount;
DE_NULL // const VkSemaphore* pSignalSemaphores;
};
try
{
VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
}
catch (...)
{
VK_CHECK(vk.deviceWaitIdle(device));
throw;
}
}
void copyImageToBuffer (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
VkImage image,
VkBuffer buffer,
tcu::IVec2 size,
VkAccessFlags srcAccessMask,
VkImageLayout oldLayout,
deUint32 numLayers,
VkImageAspectFlags barrierAspect,
VkImageAspectFlags copyAspect)
{
const VkImageMemoryBarrier imageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
srcAccessMask, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
image, // VkImage image;
makeImageSubresourceRange(barrierAspect, 0u, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
};
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
0u, DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);
const VkImageSubresourceLayers subresource =
{
copyAspect, // VkImageAspectFlags aspectMask;
0u, // deUint32 mipLevel;
0u, // deUint32 baseArrayLayer;
numLayers // deUint32 layerCount;
};
const VkBufferImageCopy region =
{
0ull, // VkDeviceSize bufferOffset;
0u, // deUint32 bufferRowLength;
0u, // deUint32 bufferImageHeight;
subresource, // VkImageSubresourceLayers imageSubresource;
makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
};
vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, &region);
const VkBufferMemoryBarrier bufferBarrier =
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
buffer, // VkBuffer buffer;
0ull, // VkDeviceSize offset;
VK_WHOLE_SIZE // VkDeviceSize size;
};
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
}
void copyImageToBuffer (const DeviceInterface& vk,
vk::VkCommandBuffer cmdBuffer,
vk::VkImage image,
vk::VkBuffer buffer,
vk::VkFormat format,
tcu::IVec2 size,
deUint32 mipLevel,
vk::VkAccessFlags srcAccessMask,
vk::VkImageLayout oldLayout,
deUint32 numLayers,
VkImageAspectFlags barrierAspect,
VkImageAspectFlags copyAspect)
{
const VkImageMemoryBarrier imageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
srcAccessMask, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
image, // VkImage image;
makeImageSubresourceRange(barrierAspect, mipLevel, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
};
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
0u, DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);
const VkImageSubresourceLayers subresource =
{
copyAspect, // VkImageAspectFlags aspectMask;
mipLevel, // deUint32 mipLevel;
0u, // deUint32 baseArrayLayer;
numLayers // deUint32 layerCount;
};
VkDeviceSize offset = 0ull;
deUint32 width = size.x();
deUint32 height = size.y();
deUint32 pixelSize = tcu::getPixelSize(mapVkFormat(format));
for (deUint32 level = 0; level < mipLevel; ++level)
{
offset += (width * height * pixelSize);
height /= 2;
width /= 2;
}
const VkBufferImageCopy region =
{
offset, // VkDeviceSize bufferOffset;
0u, // deUint32 bufferRowLength;
0u, // deUint32 bufferImageHeight;
subresource, // VkImageSubresourceLayers imageSubresource;
makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
makeExtent3D(width, height, 1u) // VkExtent3D imageExtent;
};
vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1u, &region);
const VkBufferMemoryBarrier bufferBarrier =
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
buffer, // VkBuffer buffer;
offset, // VkDeviceSize offset;
VK_WHOLE_SIZE // VkDeviceSize size;
};
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
}
void clearColorImage (const DeviceInterface& vk,
const VkDevice device,
const VkQueue queue,
deUint32 queueFamilyIndex,
VkImage image,
VkClearColorValue clearColor,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags dstStageFlags,
deUint32 baseArrayLayer,
deUint32 layerCount)
{
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
const VkImageSubresourceRange subresourceRange =
{
VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
0u, // deUint32 baseMipLevel
1u, // deUint32 levelCount
baseArrayLayer, // deUint32 baseArrayLayer
layerCount, // deUint32 layerCount
};
const VkImageMemoryBarrier preImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
const VkImageMemoryBarrier postImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
newLayout, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
beginCommandBuffer(vk, *cmdBuffer);
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_HOST_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &preImageBarrier);
vk.cmdClearColorImage(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearColor, 1, &subresourceRange);
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT,
dstStageFlags,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &postImageBarrier);
endCommandBuffer(vk, *cmdBuffer);
submitCommandsAndWait(vk, device, queue, *cmdBuffer);
}
void clearColorImage (const DeviceInterface& vk,
const VkDevice device,
const VkQueue queue,
deUint32 queueFamilyIndex,
VkImage image,
tcu::Vec4 clearColor,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags dstStageFlags,
deUint32 baseArrayLayer,
deUint32 layerCount)
{
clearColorImage(vk, device, queue, queueFamilyIndex, image, makeClearValueColor(clearColor).color, oldLayout, newLayout, dstStageFlags, baseArrayLayer, layerCount);
}
std::vector<VkBufferImageCopy> generateChessboardCopyRegions (deUint32 tileSize,
deUint32 imageWidth,
deUint32 imageHeight,
deUint32 tileIdx,
VkImageAspectFlags aspectMask)
{
std::vector<VkBufferImageCopy> copyRegions;
for (deUint32 x = 0; x < (deUint32)deFloatCeil((float)imageWidth / (float)tileSize); x++)
for (deUint32 y = 0; y < (deUint32)deFloatCeil((float)imageHeight / (float)tileSize); y++)
{
if ((x + tileIdx) % 2 == y % 2) continue;
const deUint32 tileWidth = de::min(tileSize, imageWidth - tileSize * x);
const deUint32 tileHeight = de::min(tileSize, imageHeight - tileSize * y);
const VkOffset3D offset =
{
(deInt32)x * (deInt32)tileWidth, // deInt32 x
(deInt32)y * (deInt32)tileHeight, // deInt32 y
0 // deInt32 z
};
const VkExtent3D extent =
{
tileWidth, // deUint32 width
tileHeight, // deUint32 height
1u // deUint32 depth
};
const VkImageSubresourceLayers subresourceLayers =
{
aspectMask, // VkImageAspectFlags aspectMask
0u, // deUint32 mipLevel
0u, // deUint32 baseArrayLayer
1u, // deUint32 layerCount
};
const VkBufferImageCopy copy =
{
(VkDeviceSize)0, // VkDeviceSize bufferOffset
0u, // deUint32 bufferRowLength
0u, // deUint32 bufferImageHeight
subresourceLayers, // VkImageSubresourceLayers imageSubresource
offset, // VkOffset3D imageOffset
extent // VkExtent3D imageExtent
};
copyRegions.push_back(copy);
}
return copyRegions;
}
void initColorImageChessboardPattern (const DeviceInterface& vk,
const VkDevice device,
const VkQueue queue,
deUint32 queueFamilyIndex,
Allocator& allocator,
VkImage image,
VkFormat format,
tcu::Vec4 colorValue0,
tcu::Vec4 colorValue1,
deUint32 imageWidth,
deUint32 imageHeight,
deUint32 tileSize,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags dstStageFlags)
{
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
const tcu::TextureFormat tcuFormat = mapVkFormat(format);
const tcu::Vec4 colorValues[] = { colorValue0, colorValue1 };
const deUint32 bufferSize = tileSize * tileSize * tcuFormat.getPixelSize();
const VkImageSubresourceRange subresourceRange =
{
VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
0u, // deUint32 baseMipLevel
1u, // deUint32 levelCount
0u, // deUint32 baseArrayLayer
1u // deUint32 layerCount
};
const VkImageMemoryBarrier preImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
const VkImageMemoryBarrier postImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
newLayout, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
// Create staging buffers for both color values
Move<VkBuffer> buffers[2];
de::MovePtr<Allocation> bufferAllocs[2];
const VkBufferCreateInfo bufferParams =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkBufferCreateFlags flags
(VkDeviceSize)bufferSize, // VkDeviceSize size
VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
0u, // deUint32 queueFamilyIndexCount
DE_NULL // const deUint32* pQueueFamilyIndices
};
for (deUint32 bufferIdx = 0; bufferIdx < 2; bufferIdx++)
{
buffers[bufferIdx] = createBuffer(vk, device, &bufferParams);
bufferAllocs[bufferIdx] = allocator.allocate(getBufferMemoryRequirements(vk, device, *buffers[bufferIdx]), MemoryRequirement::HostVisible);
VK_CHECK(vk.bindBufferMemory(device, *buffers[bufferIdx], bufferAllocs[bufferIdx]->getMemory(), bufferAllocs[bufferIdx]->getOffset()));
deUint32* dstPtr = (deUint32*)bufferAllocs[bufferIdx]->getHostPtr();
tcu::PixelBufferAccess access (tcuFormat, tileSize, tileSize, 1, dstPtr);
for (deUint32 x = 0; x < tileSize; x++)
for (deUint32 y = 0; y < tileSize; y++)
access.setPixel(colorValues[bufferIdx], x, y, 0);
flushAlloc(vk, device, *bufferAllocs[bufferIdx]);
}
beginCommandBuffer(vk, *cmdBuffer);
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_HOST_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &preImageBarrier);
for (deUint32 bufferIdx = 0; bufferIdx < 2; bufferIdx++)
{
std::vector<VkBufferImageCopy> copyRegions = generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_COLOR_BIT);
vk.cmdCopyBufferToImage(*cmdBuffer, *buffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegions.size(), copyRegions.data());
}
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT,
dstStageFlags,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &postImageBarrier);
endCommandBuffer(vk, *cmdBuffer);
submitCommandsAndWait(vk, device, queue, *cmdBuffer);
}
void copyDepthStencilImageToBuffers (const DeviceInterface& vk,
VkCommandBuffer cmdBuffer,
VkImage image,
VkBuffer depthBuffer,
VkBuffer stencilBuffer,
tcu::IVec2 size,
VkAccessFlags srcAccessMask,
VkImageLayout oldLayout,
deUint32 numLayers)
{
const VkImageAspectFlags aspect = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
const VkImageMemoryBarrier imageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
srcAccessMask, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_READ_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, // VkImageLayout newLayout;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
image, // VkImage image;
makeImageSubresourceRange(aspect, 0u, 1u, 0, numLayers) // VkImageSubresourceRange subresourceRange;
};
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
0u, DE_NULL, 0u, DE_NULL, 1u, &imageBarrier);
const VkImageSubresourceLayers subresourceDepth =
{
VK_IMAGE_ASPECT_DEPTH_BIT, // VkImageAspectFlags aspectMask;
0u, // deUint32 mipLevel;
0u, // deUint32 baseArrayLayer;
numLayers // deUint32 layerCount;
};
const VkBufferImageCopy regionDepth =
{
0ull, // VkDeviceSize bufferOffset;
0u, // deUint32 bufferRowLength;
0u, // deUint32 bufferImageHeight;
subresourceDepth, // VkImageSubresourceLayers imageSubresource;
makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
};
const VkImageSubresourceLayers subresourceStencil =
{
VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask;
0u, // deUint32 mipLevel;
0u, // deUint32 baseArrayLayer;
numLayers // deUint32 layerCount;
};
const VkBufferImageCopy regionStencil =
{
0ull, // VkDeviceSize bufferOffset;
0u, // deUint32 bufferRowLength;
0u, // deUint32 bufferImageHeight;
subresourceStencil, // VkImageSubresourceLayers imageSubresource;
makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
makeExtent3D(size.x(), size.y(), 1u) // VkExtent3D imageExtent;
};
vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, depthBuffer, 1u, &regionDepth);
vk.cmdCopyImageToBuffer(cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, stencilBuffer, 1u, &regionStencil);
const VkBufferMemoryBarrier bufferBarriers[] =
{
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
depthBuffer, // VkBuffer buffer;
0ull, // VkDeviceSize offset;
VK_WHOLE_SIZE // VkDeviceSize size;
},
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_HOST_READ_BIT, // VkAccessFlags dstAccessMask;
VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
VK_QUEUE_FAMILY_IGNORED, // deUint32 dstQueueFamilyIndex;
stencilBuffer, // VkBuffer buffer;
0ull, // VkDeviceSize offset;
VK_WHOLE_SIZE // VkDeviceSize size;
}
};
vk.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
0u, DE_NULL, 2u, bufferBarriers, 0u, DE_NULL);
}
void clearDepthStencilImage (const DeviceInterface& vk,
const VkDevice device,
const VkQueue queue,
deUint32 queueFamilyIndex,
VkImage image,
float depthValue,
deUint32 stencilValue,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags dstStageFlags)
{
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
const VkClearDepthStencilValue clearValue = makeClearValueDepthStencil(depthValue, stencilValue).depthStencil;
const VkImageSubresourceRange subresourceRange =
{
VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask
0u, // deUint32 baseMipLevel
1u, // deUint32 levelCount
0u, // deUint32 baseArrayLayer
1u // deUint32 layerCount
};
const VkImageMemoryBarrier preImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
const VkImageMemoryBarrier postImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
newLayout, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
beginCommandBuffer(vk, *cmdBuffer);
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_HOST_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &preImageBarrier);
vk.cmdClearDepthStencilImage(*cmdBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearValue, 1, &subresourceRange);
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT,
dstStageFlags,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &postImageBarrier);
endCommandBuffer(vk, *cmdBuffer);
submitCommandsAndWait(vk, device, queue, *cmdBuffer);
}
void initDepthStencilImageChessboardPattern (const DeviceInterface& vk,
const VkDevice device,
const VkQueue queue,
deUint32 queueFamilyIndex,
Allocator& allocator,
VkImage image,
VkFormat format,
float depthValue0,
float depthValue1,
deUint32 stencilValue0,
deUint32 stencilValue1,
deUint32 imageWidth,
deUint32 imageHeight,
deUint32 tileSize,
VkImageLayout oldLayout,
VkImageLayout newLayout,
VkPipelineStageFlags dstStageFlags)
{
Move<VkCommandPool> cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
const deUint32 depthBufferSize = tileSize * tileSize * 4;
const deUint32 stencilBufferSize = tileSize * tileSize;
const float depthValues[] = { depthValue0, depthValue1 };
const deUint32 stencilValues[] = { stencilValue0, stencilValue1 };
const tcu::TextureFormat tcuFormat = mapVkFormat(format);
const VkImageSubresourceRange subresourceRange =
{
VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, // VkImageAspectFlags aspectMask
0u, // deUint32 baseMipLevel
1u, // deUint32 levelCount
0u, // deUint32 baseArrayLayer
1u // deUint32 layerCount
};
const VkImageMemoryBarrier preImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkAccessFlags srcAccessMask;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags dstAccessMask;
oldLayout, // VkImageLayout oldLayout;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
const VkImageMemoryBarrier postImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
DE_NULL, // const void* pNext;
VK_ACCESS_TRANSFER_WRITE_BIT, // VkAccessFlags srcAccessMask;
VK_ACCESS_SHADER_WRITE_BIT, // VkAccessFlags dstAccessMask;
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, // VkImageLayout oldLayout;
newLayout, // VkImageLayout newLayout;
queueFamilyIndex, // deUint32 srcQueueFamilyIndex;
queueFamilyIndex, // deUint32 dstQueueFamilyIndex;
image, // VkImage image;
subresourceRange // VkImageSubresourceRange subresourceRange;
};
// Create staging buffers for depth and stencil values
Move<VkBuffer> depthBuffers[2];
de::MovePtr<Allocation> depthBufferAllocs[2];
Move<VkBuffer> stencilBuffers[2];
de::MovePtr<Allocation> stencilBufferAllocs[2];
const VkBufferCreateInfo depthBufferParams =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkBufferCreateFlags flags
(VkDeviceSize)depthBufferSize, // VkDeviceSize size
VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
0u, // deUint32 queueFamilyIndexCount
DE_NULL // const deUint32* pQueueFamilyIndices
};
const VkBufferCreateInfo stencilBufferParams =
{
VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
0u, // VkBufferCreateFlags flags
(VkDeviceSize)stencilBufferSize, // VkDeviceSize size
VK_BUFFER_USAGE_TRANSFER_SRC_BIT, // VkBufferUsageFlags usage
VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode
0u, // deUint32 queueFamilyIndexCount
DE_NULL // const deUint32* pQueueFamilyIndices
};
for (deUint32 bufferIdx = 0; bufferIdx < 2; bufferIdx++)
{
depthBuffers[bufferIdx] = createBuffer(vk, device, &depthBufferParams);
depthBufferAllocs[bufferIdx] = allocator.allocate(getBufferMemoryRequirements(vk, device, *depthBuffers[bufferIdx]), MemoryRequirement::HostVisible);
VK_CHECK(vk.bindBufferMemory(device, *depthBuffers[bufferIdx], depthBufferAllocs[bufferIdx]->getMemory(), depthBufferAllocs[bufferIdx]->getOffset()));
stencilBuffers[bufferIdx] = createBuffer(vk, device, &stencilBufferParams);
stencilBufferAllocs[bufferIdx] = allocator.allocate(getBufferMemoryRequirements(vk, device, *stencilBuffers[bufferIdx]), MemoryRequirement::HostVisible);
VK_CHECK(vk.bindBufferMemory(device, *stencilBuffers[bufferIdx], stencilBufferAllocs[bufferIdx]->getMemory(), stencilBufferAllocs[bufferIdx]->getOffset()));
deUint32* depthPtr = (deUint32*)depthBufferAllocs[bufferIdx]->getHostPtr();
deUint32* stencilPtr = (deUint32*)stencilBufferAllocs[bufferIdx]->getHostPtr();
if (format == VK_FORMAT_D24_UNORM_S8_UINT)
{
tcu::PixelBufferAccess access(tcuFormat, tileSize, tileSize, 1, depthPtr);
for (deUint32 x = 0; x < tileSize; x++)
for (deUint32 y = 0; y < tileSize; y++)
access.setPixDepth(depthValues[bufferIdx], x, y, 0);
}
else
{
DE_ASSERT(format == VK_FORMAT_D32_SFLOAT_S8_UINT);
for (deUint32 i = 0; i < tileSize * tileSize; i++)
((float*)depthPtr)[i] = depthValues[bufferIdx];
}
deMemset(stencilPtr, stencilValues[bufferIdx], stencilBufferSize);
flushAlloc(vk, device, *depthBufferAllocs[bufferIdx]);
flushAlloc(vk, device, *stencilBufferAllocs[bufferIdx]);
}
beginCommandBuffer(vk, *cmdBuffer);
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_HOST_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &preImageBarrier);
for (deUint32 bufferIdx = 0; bufferIdx < 2; bufferIdx++)
{
std::vector<VkBufferImageCopy> copyRegionsDepth = generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_DEPTH_BIT);
std::vector<VkBufferImageCopy> copyRegionsStencil = generateChessboardCopyRegions(tileSize, imageWidth, imageHeight, bufferIdx, VK_IMAGE_ASPECT_STENCIL_BIT);
vk.cmdCopyBufferToImage(*cmdBuffer, *depthBuffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegionsDepth.size(), copyRegionsDepth.data());
vk.cmdCopyBufferToImage(*cmdBuffer, *stencilBuffers[bufferIdx], image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, (deUint32)copyRegionsStencil.size(), copyRegionsStencil.data());
}
vk.cmdPipelineBarrier(*cmdBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT,
dstStageFlags,
(VkDependencyFlags)0,
0, (const VkMemoryBarrier*)DE_NULL,
0, (const VkBufferMemoryBarrier*)DE_NULL,
1, &postImageBarrier);
endCommandBuffer(vk, *cmdBuffer);
submitCommandsAndWait(vk, device, queue, *cmdBuffer);
}
void allocateAndBindSparseImage (const DeviceInterface& vk,
VkDevice device,
const VkPhysicalDevice physicalDevice,
const InstanceInterface& instance,
const VkImageCreateInfo& imageCreateInfo,
const VkSemaphore& signalSemaphore,
VkQueue queue,
Allocator& allocator,
std::vector<de::SharedPtr<Allocation> >& allocations,
tcu::TextureFormat format,
VkImage destImage)
{
const VkImageAspectFlags imageAspectFlags = getImageAspectFlags(format);
const VkPhysicalDeviceProperties deviceProperties = getPhysicalDeviceProperties(instance, physicalDevice);
const VkPhysicalDeviceMemoryProperties deviceMemoryProperties = getPhysicalDeviceMemoryProperties(instance, physicalDevice);
deUint32 sparseMemoryReqCount = 0;
// Check if the image format supports sparse operations
if (!checkSparseImageFormatSupport(physicalDevice, instance, imageCreateInfo))
TCU_THROW(NotSupportedError, "The image format does not support sparse operations.");
vk.getImageSparseMemoryRequirements(device, destImage, &sparseMemoryReqCount, DE_NULL);
DE_ASSERT(sparseMemoryReqCount != 0);
std::vector<VkSparseImageMemoryRequirements> sparseImageMemoryRequirements;
sparseImageMemoryRequirements.resize(sparseMemoryReqCount);
vk.getImageSparseMemoryRequirements(device, destImage, &sparseMemoryReqCount, &sparseImageMemoryRequirements[0]);
const deUint32 noMatchFound = ~((deUint32)0);
deUint32 aspectIndex = noMatchFound;
for (deUint32 memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx)
{
if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask == imageAspectFlags)
{
aspectIndex = memoryReqNdx;
break;
}
}
deUint32 metadataAspectIndex = noMatchFound;
for (deUint32 memoryReqNdx = 0; memoryReqNdx < sparseMemoryReqCount; ++memoryReqNdx)
{
if (sparseImageMemoryRequirements[memoryReqNdx].formatProperties.aspectMask & VK_IMAGE_ASPECT_METADATA_BIT)
{
metadataAspectIndex = memoryReqNdx;
break;
}
}
if (aspectIndex == noMatchFound)
TCU_THROW(NotSupportedError, "Required image aspect not supported.");
const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vk, device, destImage);
deUint32 memoryType = noMatchFound;
for (deUint32 memoryTypeNdx = 0; memoryTypeNdx < deviceMemoryProperties.memoryTypeCount; ++memoryTypeNdx)
{
if ((memoryRequirements.memoryTypeBits & (1u << memoryTypeNdx)) != 0 &&
MemoryRequirement::Any.matchesHeap(deviceMemoryProperties.memoryTypes[memoryTypeNdx].propertyFlags))
{
memoryType = memoryTypeNdx;
break;
}
}
if (memoryType == noMatchFound)
TCU_THROW(NotSupportedError, "No matching memory type found.");
if (memoryRequirements.size > deviceProperties.limits.sparseAddressSpaceSize)
TCU_THROW(NotSupportedError, "Required memory size for sparse resource exceeds device limits.");
const VkSparseImageMemoryRequirements aspectRequirements = sparseImageMemoryRequirements[aspectIndex];
VkExtent3D blockSize = aspectRequirements.formatProperties.imageGranularity;
std::vector<VkSparseImageMemoryBind> imageResidencyMemoryBinds;
std::vector<VkSparseMemoryBind> imageMipTailMemoryBinds;
for (deUint32 layerNdx = 0; layerNdx < imageCreateInfo.arrayLayers; ++layerNdx)
{
for (deUint32 mipLevelNdx = 0; mipLevelNdx < aspectRequirements.imageMipTailFirstLod; ++mipLevelNdx)
{
const VkExtent3D mipExtent = mipLevelExtents(imageCreateInfo.extent, mipLevelNdx);
const tcu::UVec3 numSparseBinds = alignedDivide(mipExtent, blockSize);
const tcu::UVec3 lastBlockExtent = tcu::UVec3(mipExtent.width % blockSize.width ? mipExtent.width % blockSize.width : blockSize.width,
mipExtent.height % blockSize.height ? mipExtent.height % blockSize.height : blockSize.height,
mipExtent.depth % blockSize.depth ? mipExtent.depth % blockSize.depth : blockSize.depth );
for (deUint32 z = 0; z < numSparseBinds.z(); ++z)
for (deUint32 y = 0; y < numSparseBinds.y(); ++y)
for (deUint32 x = 0; x < numSparseBinds.x(); ++x)
{
const VkMemoryRequirements allocRequirements =
{
// 28.7.5 alignment shows the block size in bytes
memoryRequirements.alignment, // VkDeviceSize size;
memoryRequirements.alignment, // VkDeviceSize alignment;
memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
};
de::SharedPtr<Allocation> allocation(allocator.allocate(allocRequirements, MemoryRequirement::Any).release());
allocations.push_back(allocation);
VkOffset3D offset;
offset.x = x*blockSize.width;
offset.y = y*blockSize.height;
offset.z = z*blockSize.depth;
VkExtent3D extent;
extent.width = (x == numSparseBinds.x() - 1) ? lastBlockExtent.x() : blockSize.width;
extent.height = (y == numSparseBinds.y() - 1) ? lastBlockExtent.y() : blockSize.height;
extent.depth = (z == numSparseBinds.z() - 1) ? lastBlockExtent.z() : blockSize.depth;
const VkSparseImageMemoryBind imageMemoryBind =
{
{
imageAspectFlags, // VkImageAspectFlags aspectMask;
mipLevelNdx, // uint32_t mipLevel;
layerNdx, // uint32_t arrayLayer;
}, // VkImageSubresource subresource;
offset, // VkOffset3D offset;
extent, // VkExtent3D extent;
allocation->getMemory(), // VkDeviceMemory memory;
allocation->getOffset(), // VkDeviceSize memoryOffset;
0u, // VkSparseMemoryBindFlags flags;
};
imageResidencyMemoryBinds.push_back(imageMemoryBind);
}
}
// Handle MIP tail. There are two cases to consider here:
//
// 1) VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is requested by the driver: each layer needs a separate tail.
// 2) otherwise: only one tail is needed.
if (aspectRequirements.imageMipTailSize > 0)
{
if (layerNdx == 0 || (aspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) == 0)
{
const VkMemoryRequirements allocRequirements =
{
aspectRequirements.imageMipTailSize, // VkDeviceSize size;
memoryRequirements.alignment, // VkDeviceSize alignment;
memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
};
const de::SharedPtr<Allocation> allocation(allocator.allocate(allocRequirements, MemoryRequirement::Any).release());
const VkSparseMemoryBind imageMipTailMemoryBind =
{
aspectRequirements.imageMipTailOffset + layerNdx * aspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset;
aspectRequirements.imageMipTailSize, // VkDeviceSize size;
allocation->getMemory(), // VkDeviceMemory memory;
allocation->getOffset(), // VkDeviceSize memoryOffset;
0u, // VkSparseMemoryBindFlags flags;
};
allocations.push_back(allocation);
imageMipTailMemoryBinds.push_back(imageMipTailMemoryBind);
}
}
// Handle Metadata. Similarly to MIP tail in aspectRequirements, there are two cases to consider here:
//
// 1) VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT is requested by the driver: each layer needs a separate tail.
// 2) otherwise:
if (metadataAspectIndex != noMatchFound)
{
const VkSparseImageMemoryRequirements metadataAspectRequirements = sparseImageMemoryRequirements[metadataAspectIndex];
if (layerNdx == 0 || (metadataAspectRequirements.formatProperties.flags & VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT) == 0)
{
const VkMemoryRequirements metadataAllocRequirements =
{
metadataAspectRequirements.imageMipTailSize, // VkDeviceSize size;
memoryRequirements.alignment, // VkDeviceSize alignment;
memoryRequirements.memoryTypeBits, // uint32_t memoryTypeBits;
};
const de::SharedPtr<Allocation> metadataAllocation(allocator.allocate(metadataAllocRequirements, MemoryRequirement::Any).release());
const VkSparseMemoryBind metadataMipTailMemoryBind =
{
metadataAspectRequirements.imageMipTailOffset +
layerNdx * metadataAspectRequirements.imageMipTailStride, // VkDeviceSize resourceOffset;
metadataAspectRequirements.imageMipTailSize, // VkDeviceSize size;
metadataAllocation->getMemory(), // VkDeviceMemory memory;
metadataAllocation->getOffset(), // VkDeviceSize memoryOffset;
VK_SPARSE_MEMORY_BIND_METADATA_BIT // VkSparseMemoryBindFlags flags;
};
allocations.push_back(metadataAllocation);
imageMipTailMemoryBinds.push_back(metadataMipTailMemoryBind);
}
}
}
VkBindSparseInfo bindSparseInfo =
{
VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, //VkStructureType sType;
DE_NULL, //const void* pNext;
0u, //deUint32 waitSemaphoreCount;
DE_NULL, //const VkSemaphore* pWaitSemaphores;
0u, //deUint32 bufferBindCount;
DE_NULL, //const VkSparseBufferMemoryBindInfo* pBufferBinds;
0u, //deUint32 imageOpaqueBindCount;
DE_NULL, //const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
0u, //deUint32 imageBindCount;
DE_NULL, //const VkSparseImageMemoryBindInfo* pImageBinds;
1u, //deUint32 signalSemaphoreCount;
&signalSemaphore //const VkSemaphore* pSignalSemaphores;
};
VkSparseImageMemoryBindInfo imageResidencyBindInfo;
VkSparseImageOpaqueMemoryBindInfo imageMipTailBindInfo;
if (imageResidencyMemoryBinds.size() > 0)
{
imageResidencyBindInfo.image = destImage;
imageResidencyBindInfo.bindCount = static_cast<deUint32>(imageResidencyMemoryBinds.size());
imageResidencyBindInfo.pBinds = &imageResidencyMemoryBinds[0];
bindSparseInfo.imageBindCount = 1u;
bindSparseInfo.pImageBinds = &imageResidencyBindInfo;
}
if (imageMipTailMemoryBinds.size() > 0)
{
imageMipTailBindInfo.image = destImage;
imageMipTailBindInfo.bindCount = static_cast<deUint32>(imageMipTailMemoryBinds.size());
imageMipTailBindInfo.pBinds = &imageMipTailMemoryBinds[0];
bindSparseInfo.imageOpaqueBindCount = 1u;
bindSparseInfo.pImageOpaqueBinds = &imageMipTailBindInfo;
}
VK_CHECK(vk.queueBindSparse(queue, 1u, &bindSparseInfo, DE_NULL));
}
bool checkSparseImageFormatSupport (const VkPhysicalDevice physicalDevice,
const InstanceInterface& instance,
const VkFormat format,
const VkImageType imageType,
const VkSampleCountFlagBits sampleCount,
const VkImageUsageFlags usageFlags,
const VkImageTiling imageTiling)
{
const auto propVec = getPhysicalDeviceSparseImageFormatProperties(instance, physicalDevice, format, imageType, sampleCount, usageFlags, imageTiling);
return (propVec.size() != 0);
}
bool checkSparseImageFormatSupport (const VkPhysicalDevice physicalDevice,
const InstanceInterface& instance,
const VkImageCreateInfo& imageCreateInfo)
{
return checkSparseImageFormatSupport(physicalDevice, instance, imageCreateInfo.format, imageCreateInfo.imageType, imageCreateInfo.samples, imageCreateInfo.usage, imageCreateInfo.tiling);
}
} // vk