VK_KHR_maintenance2: extended_usage_bit tests

Add tests:
 * dEQP-VK.image.extended_usage_bit.*

Components: Vulkan

VK-GL-CTS issue: 614

Change-Id: Ied6251e642746d5f37aa7b2fe3f262061f765f8f

diff --git a/AndroidGen.mk b/AndroidGen.mk
index cfebc33..eb61741 100644 (file)
--- a/AndroidGen.mk
+++ b/AndroidGen.mk
@@ -123,6 +123,7 @@ LOCAL_SRC_FILES := \
        external/vulkancts/modules/vulkan/image/vktImageTests.cpp \
        external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp \
        external/vulkancts/modules/vulkan/image/vktImageTexture.cpp \
+       external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp \
        external/vulkancts/modules/vulkan/memory/vktMemoryAllocationTests.cpp \
        external/vulkancts/modules/vulkan/memory/vktMemoryBindingTests.cpp \
        external/vulkancts/modules/vulkan/memory/vktMemoryMappingTests.cpp \

diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt
index 2548847..53d110b 100644 (file)
--- a/android/cts/master/vk-master.txt
+++ b/android/cts/master/vk-master.txt
@@ -210173,6 +210173,222 @@ dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_un
 dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_srgb_block.r32g32b32a32_uint
 dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_srgb_block.r32g32b32a32_sint
 dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_srgb_block.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r32_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r32_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r8_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r8_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r16_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r32_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r32_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r8_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r8_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r16_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r32_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r32_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32b32a32_sfloat
 dEQP-VK.wsi.android.surface.create
 dEQP-VK.wsi.android.surface.create_custom_allocator
 dEQP-VK.wsi.android.surface.create_simulate_oom

diff --git a/external/vulkancts/modules/vulkan/image/CMakeLists.txt b/external/vulkancts/modules/vulkan/image/CMakeLists.txt
index a655dfe..529691c 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/CMakeLists.txt
+++ b/external/vulkancts/modules/vulkan/image/CMakeLists.txt
@@ -23,6 +23,8 @@ set(DEQP_VK_IMAGE_SRCS
        vktImageCompressionTranscodingSupport.hpp
        vktImageLoadStoreUtil.cpp
        vktImageLoadStoreUtil.hpp
+       vktImageTranscodingSupportTests.cpp
+       vktImageTranscodingSupportTests.hpp
        )
 
 set(DEQP_VK_IMAGE_LIBS

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageTests.cpp
index 7e5d48d..e702412 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageTests.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageTests.cpp
@@ -30,6 +30,7 @@
 #include "vktTestGroupUtil.hpp"
 #include "vktImageAtomicOperationTests.hpp"
 #include "vktImageCompressionTranscodingSupport.hpp"
+#include "vktImageTranscodingSupportTests.hpp"
 
 namespace vkt
 {
@@ -52,6 +53,7 @@ void createChildren (tcu::TestCaseGroup* imageTests)
        imageTests->addChild(createImageSizeTests(testCtx));
        imageTests->addChild(createImageAtomicOperationTests(testCtx));
        imageTests->addChild(createImageCompressionTranscodingTests(testCtx));
+       imageTests->addChild(createImageTranscodingSupportTests(testCtx));
 }
 
 } // anonymous

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp
index 8dd9ea9..dbdb50d 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.cpp
@@ -1129,6 +1129,119 @@ const char* getGlslFormatType (const vk::VkFormat format)
        }
 }
 
+const char* getGlslAttachmentType (const vk::VkFormat format)
+{
+       const tcu::TextureFormat                textureFormat   = mapVkFormat(format);
+       const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(textureFormat.type);
+
+       switch (channelClass)
+       {
+               case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
+                       return "ivec4";
+
+               case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
+                       return "uvec4";
+
+               case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
+               case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
+               case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
+                       return "vec4";
+
+               default:
+                       DE_FATAL("Unknown channel class");
+                       return "";
+       }
+}
+
+const char* getGlslInputAttachmentType (const vk::VkFormat format)
+{
+       const tcu::TextureFormat                textureFormat   = mapVkFormat(format);
+       const tcu::TextureChannelClass  channelClass    = tcu::getTextureChannelClass(textureFormat.type);
+
+       switch (channelClass)
+       {
+               case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
+                       return "isubpassInput";
+
+               case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
+                       return "usubpassInput";
+
+               case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
+               case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
+               case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
+                       return "subpassInput";
+
+               default:
+                       DE_FATAL("Unknown channel class");
+                       return "";
+       }
+}
+
+bool isPackedType (const vk::VkFormat format)
+{
+       const tcu::TextureFormat        textureFormat   = mapVkFormat(format);
+
+       DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELTYPE_LAST == 40);
+
+       switch (textureFormat.type)
+       {
+               case tcu::TextureFormat::UNORM_BYTE_44:
+               case tcu::TextureFormat::UNORM_SHORT_565:
+               case tcu::TextureFormat::UNORM_SHORT_555:
+               case tcu::TextureFormat::UNORM_SHORT_4444:
+               case tcu::TextureFormat::UNORM_SHORT_5551:
+               case tcu::TextureFormat::UNORM_SHORT_1555:
+               case tcu::TextureFormat::UNORM_INT_101010:
+               case tcu::TextureFormat::SNORM_INT_1010102_REV:
+               case tcu::TextureFormat::UNORM_INT_1010102_REV:
+               case tcu::TextureFormat::UNSIGNED_BYTE_44:
+               case tcu::TextureFormat::UNSIGNED_SHORT_565:
+               case tcu::TextureFormat::UNSIGNED_SHORT_4444:
+               case tcu::TextureFormat::UNSIGNED_SHORT_5551:
+               case tcu::TextureFormat::SIGNED_INT_1010102_REV:
+               case tcu::TextureFormat::UNSIGNED_INT_1010102_REV:
+               case tcu::TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
+               case tcu::TextureFormat::UNSIGNED_INT_999_E5_REV:
+               case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
+               case tcu::TextureFormat::UNSIGNED_INT_24_8:
+               case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
+                       return true;
+
+               default:
+                       return false;
+       }
+}
+
+bool isComponentSwizzled (const vk::VkFormat format)
+{
+       const tcu::TextureFormat        textureFormat   = mapVkFormat(format);
+
+       DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
+
+       switch (textureFormat.order)
+       {
+               case tcu::TextureFormat::ARGB:
+               case tcu::TextureFormat::BGR:
+               case tcu::TextureFormat::BGRA:
+               case tcu::TextureFormat::sBGR:
+               case tcu::TextureFormat::sBGRA:
+                       return true;
+
+               default:
+                       return false;
+       }
+}
+
+int getNumUsedChannels (const vk::VkFormat format)
+{
+       // make sure this function will be checked if type table is updated
+       DE_STATIC_ASSERT(tcu::TextureFormat::CHANNELORDER_LAST == 21);
+
+       const tcu::TextureFormat        textureFormat   = mapVkFormat(format);
+
+       return getNumUsedChannels(textureFormat.order);
+}
+
 std::string getFormatShortString (const VkFormat format)
 {
        const std::string fullName = getFormatName(format);

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp
index 1fee1c4..5ebfa11 100644 (file)
--- a/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp
+++ b/external/vulkancts/modules/vulkan/image/vktImageTestsUtil.hpp
@@ -58,6 +58,11 @@ std::string                          getShaderImageFormatQualifier   (const tcu::TextureFormat& format);
 std::string                            getGlslSamplerType                              (const tcu::TextureFormat& format, vk::VkImageViewType type);
 const char*                            getGlslInputFormatType                  (const vk::VkFormat format);
 const char*                            getGlslFormatType                               (const vk::VkFormat format);
+const char*                            getGlslAttachmentType                   (const vk::VkFormat format);
+const char*                            getGlslInputAttachmentType              (const vk::VkFormat format);
+bool                                   isPackedType                                    (const vk::VkFormat format);
+bool                                   isComponentSwizzled                             (const vk::VkFormat format);
+int                                            getNumUsedChannels                              (const vk::VkFormat format);
 
 class Buffer
 {

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp
new file mode 100644 (file)
index 0000000..4cabe98
--- /dev/null
+++ b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.cpp
@@ -0,0 +1,1171 @@
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 The Khronos Group 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  vktImageTranscodingSupportTests.cpp
+ * \brief Transcoding support tests
+ *//*--------------------------------------------------------------------*/
+
+#include "vktImageTranscodingSupportTests.hpp"
+
+#include "deUniquePtr.hpp"
+#include "deStringUtil.hpp"
+#include "deSharedPtr.hpp"
+#include "deRandom.hpp"
+
+#include "vktTestCaseUtil.hpp"
+#include "vkPrograms.hpp"
+#include "vkImageUtil.hpp"
+#include "vktImageTestsUtil.hpp"
+#include "vkBuilderUtil.hpp"
+#include "vkRef.hpp"
+#include "vkRefUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkQueryUtil.hpp"
+
+#include "tcuTextureUtil.hpp"
+#include "tcuTexture.hpp"
+#include "tcuCompressedTexture.hpp"
+#include "tcuVectorType.hpp"
+#include "tcuResource.hpp"
+#include "tcuImageIO.hpp"
+#include "tcuImageCompare.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuRGBA.hpp"
+#include "tcuSurface.hpp"
+
+#include <vector>
+#include <iomanip>
+
+using namespace vk;
+namespace vkt
+{
+namespace image
+{
+namespace
+{
+using std::string;
+using std::vector;
+using tcu::TestContext;
+using tcu::TestStatus;
+using tcu::UVec3;
+using tcu::IVec3;
+using tcu::CompressedTexFormat;
+using tcu::CompressedTexture;
+using tcu::Resource;
+using tcu::Archive;
+using tcu::ConstPixelBufferAccess;
+using de::MovePtr;
+using de::SharedPtr;
+using de::Random;
+
+enum Operation
+{
+       OPERATION_ATTACHMENT_READ,
+       OPERATION_ATTACHMENT_WRITE,
+       OPERATION_TEXTURE_READ,
+       OPERATION_TEXTURE_WRITE,
+       OPERATION_LAST
+};
+
+struct TestParameters
+{
+       Operation                               operation;
+       UVec3                                   size;
+       ImageType                               imageType;
+       VkImageUsageFlagBits    testedImageUsageFeature;
+       VkFormat                                featuredFormat;
+       VkFormat                                featurelessFormat;
+       VkImageUsageFlags               testedImageUsage;
+       VkImageUsageFlags               pairedImageUsage;
+       const VkFormat*                 compatibleFormats;
+};
+
+const deUint32 SINGLE_LEVEL = 1u;
+const deUint32 SINGLE_LAYER = 1u;
+
+class BasicTranscodingTestInstance : public TestInstance
+{
+public:
+                                                       BasicTranscodingTestInstance    (Context&                               context,
+                                                                                                                        const TestParameters&  parameters);
+       virtual TestStatus              iterate                                                 (void) = 0;
+protected:
+       void                                    generateData                                    (deUint8*                               toFill,
+                                                                                                                        size_t                                 size,
+                                                                                                                        const VkFormat                 format = VK_FORMAT_UNDEFINED);
+       const TestParameters    m_parameters;
+};
+
+BasicTranscodingTestInstance::BasicTranscodingTestInstance (Context& context, const TestParameters& parameters)
+       : TestInstance  (context)
+       , m_parameters  (parameters)
+{
+}
+
+void BasicTranscodingTestInstance::generateData (deUint8* toFill, size_t size, const VkFormat format)
+{
+       const deUint8 pattern[] =
+       {
+               // 64-bit values
+               0x11, 0x11, 0x11, 0x11, 0x22, 0x22, 0x22, 0x22,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00,
+               0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00,
+               0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Positive infinity
+               0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Negative infinity
+               0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,         // Start of a signalling NaN (NANS)
+               0x7F, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a signalling NaN (NANS)
+               0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,         // Start of a signalling NaN (NANS)
+               0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a signalling NaN (NANS)
+               0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Start of a quiet NaN (NANQ)
+               0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of of a quiet NaN (NANQ)
+               0xFF, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,         // Start of a quiet NaN (NANQ)
+               0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,         // End of a quiet NaN (NANQ)
+               // 32-bit values
+               0x7F, 0x80, 0x00, 0x00,                                                         // Positive infinity
+               0xFF, 0x80, 0x00, 0x00,                                                         // Negative infinity
+               0x7F, 0x80, 0x00, 0x01,                                                         // Start of a signalling NaN (NANS)
+               0x7F, 0xBF, 0xFF, 0xFF,                                                         // End of a signalling NaN (NANS)
+               0xFF, 0x80, 0x00, 0x01,                                                         // Start of a signalling NaN (NANS)
+               0xFF, 0xBF, 0xFF, 0xFF,                                                         // End of a signalling NaN (NANS)
+               0x7F, 0xC0, 0x00, 0x00,                                                         // Start of a quiet NaN (NANQ)
+               0x7F, 0xFF, 0xFF, 0xFF,                                                         // End of of a quiet NaN (NANQ)
+               0xFF, 0xC0, 0x00, 0x00,                                                         // Start of a quiet NaN (NANQ)
+               0xFF, 0xFF, 0xFF, 0xFF,                                                         // End of a quiet NaN (NANQ)
+               0xAA, 0xAA, 0xAA, 0xAA,
+               0x55, 0x55, 0x55, 0x55,
+       };
+
+       deUint8*        start           = toFill;
+       size_t          sizeToRnd       = size;
+
+       // Pattern part
+       if (size >= 2 * sizeof(pattern))
+       {
+               // Rotated pattern
+               for (size_t i = 0; i < sizeof(pattern); i++)
+                       start[sizeof(pattern) - i - 1] = pattern[i];
+
+               start           += sizeof(pattern);
+               sizeToRnd       -= sizeof(pattern);
+
+               // Direct pattern
+               deMemcpy(start, pattern, sizeof(pattern));
+
+               start           += sizeof(pattern);
+               sizeToRnd       -= sizeof(pattern);
+       }
+
+       // Random part
+       {
+               DE_ASSERT(sizeToRnd % sizeof(deUint32) == 0);
+
+               deUint32*       start32         = reinterpret_cast<deUint32*>(start);
+               size_t          sizeToRnd32     = sizeToRnd / sizeof(deUint32);
+               Random          rnd                     (static_cast<deUint32>(format));
+
+               for (size_t i = 0; i < sizeToRnd32; i++)
+                       start32[i] = rnd.getUint32();
+       }
+
+       {
+               // Remove certain values that may not be preserved based on the uncompressed view format
+               if (isSnormFormat(m_parameters.featuredFormat))
+               {
+                       tcu::TextureFormat textureFormat = mapVkFormat(m_parameters.featuredFormat);
+
+                       if (textureFormat.type == tcu::TextureFormat::SNORM_INT8)
+                       {
+                               for (size_t i = 0; i < size; i++)
+                               {
+                                       // SNORM fix: due to write operation in SNORM format
+                                       // replaces 0x80 to 0x81, remove these values from test
+                                       if (toFill[i] == 0x80)
+                                               toFill[i] = 0x81;
+                               }
+                       }
+                       else
+                       {
+                               for (size_t i = 0; i < size; i += 2)
+                               {
+                                       // SNORM fix: due to write operation in SNORM format
+                                       // replaces 0x00 0x80 to 0x01 0x80
+                                       if (toFill[i] == 0x00 && toFill[i+1] == 0x80)
+                                               toFill[i+1] = 0x81;
+                               }
+                       }
+               }
+               else if (isFloatFormat(m_parameters.featuredFormat))
+               {
+                       tcu::TextureFormat textureFormat = mapVkFormat(m_parameters.featuredFormat);
+
+                       if (textureFormat.type == tcu::TextureFormat::HALF_FLOAT)
+                       {
+                               for (size_t i = 0; i < size; i += 2)
+                               {
+                                       // HALF_FLOAT fix: remove INF and NaN
+                                       if ((toFill[i+1] & 0x7C) == 0x7C)
+                                               toFill[i+1] = 0x00;
+                               }
+                       }
+                       else if (textureFormat.type == tcu::TextureFormat::FLOAT)
+                       {
+                               for (size_t i = 0; i < size; i += 4)
+                               {
+                                       // HALF_FLOAT fix: remove INF and NaN
+                                       if ((toFill[i+1] & 0x7C) == 0x7C)
+                                               toFill[i+1] = 0x00;
+                               }
+
+                               for (size_t i = 0; i < size; i += 4)
+                               {
+                                       // FLOAT fix: remove INF, NaN, and denorm
+                                       // Little endian fix
+                                       if (((toFill[i+3] & 0x7F) == 0x7F && (toFill[i+2] & 0x80) == 0x80) || ((toFill[i+3] & 0x7F) == 0x00 && (toFill[i+2] & 0x80) == 0x00))
+                                               toFill[i+3] = 0x01;
+                                       // Big endian fix
+                                       if (((toFill[i+0] & 0x7F) == 0x7F && (toFill[i+1] & 0x80) == 0x80) || ((toFill[i+0] & 0x7F) == 0x00 && (toFill[i+1] & 0x80) == 0x00))
+                                               toFill[i+0] = 0x01;
+                               }
+                       }
+               }
+       }
+}
+
+class GraphicsAttachmentsTestInstance : public BasicTranscodingTestInstance
+{
+public:
+                                                                       GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters);
+       virtual TestStatus                              iterate                                                 (void);
+
+protected:
+       VkImageCreateInfo                               makeCreateImageInfo                             (const VkFormat                         format,
+                                                                                                                                        const ImageType                        type,
+                                                                                                                                        const UVec3&                           size,
+                                                                                                                                        const VkImageUsageFlags        usageFlags,
+                                                                                                                                        const bool                                     extendedImageCreateFlag);
+       VkImageViewUsageCreateInfoKHR   makeImageViewUsageCreateInfo    (VkImageUsageFlags                      imageUsageFlags);
+       VkDeviceSize                                    getUncompressedImageData                (const VkFormat                         format,
+                                                                                                                                        const UVec3&                           size,
+                                                                                                                                        std::vector<deUint8>&          data);
+       virtual void                                    transcode                                               (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage);
+       bool                                                    compareAndLog                                   (const void* reference, const void* result, size_t size);
+};
+
+GraphicsAttachmentsTestInstance::GraphicsAttachmentsTestInstance (Context& context, const TestParameters& parameters)
+       : BasicTranscodingTestInstance(context, parameters)
+{
+}
+
+TestStatus GraphicsAttachmentsTestInstance::iterate (void)
+{
+       std::vector<deUint8>    srcData;
+       std::vector<deUint8>    dstData;
+       de::MovePtr<Image>              outputImage;
+
+       transcode(srcData, dstData, outputImage);
+
+       DE_ASSERT(srcData.size() > 0 && srcData.size() == dstData.size());
+
+       if (!compareAndLog(&srcData[0], &dstData[0], srcData.size()))
+               return TestStatus::fail("Output differs from input");
+
+       return TestStatus::pass("Pass");
+}
+
+void GraphicsAttachmentsTestInstance::transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage)
+{
+       const DeviceInterface&                                  vk                                              = m_context.getDeviceInterface();
+       const VkDevice                                                  device                                  = m_context.getDevice();
+       const deUint32                                                  queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
+       const VkQueue                                                   queue                                   = m_context.getUniversalQueue();
+       Allocator&                                                              allocator                               = m_context.getDefaultAllocator();
+
+       const VkImageSubresourceRange                   subresourceRange                = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
+       const VkImageViewUsageCreateInfoKHR*    imageViewUsageNull              = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
+       const VkImageViewUsageCreateInfoKHR             imageViewUsage                  = makeImageViewUsageCreateInfo(m_parameters.testedImageUsage);
+
+       const VkFormat                                                  srcFormat                               = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.featurelessFormat :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.featuredFormat :
+                                                                                                                                         VK_FORMAT_UNDEFINED;
+       const bool                                                              srcExtendedImageCreate  = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? true :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? false :
+                                                                                                                                         false;
+       const VkImageUsageFlags                                 srcImageUsageFlags              = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.testedImageUsage :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.pairedImageUsage :
+                                                                                                                                         0;
+       const VkImageViewUsageCreateInfoKHR*    srcImageViewUsageFlags  = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? &imageViewUsage :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? imageViewUsageNull :
+                                                                                                                                         imageViewUsageNull;
+       const VkDeviceSize                                              srcImageSizeInBytes             = getUncompressedImageData(srcFormat, m_parameters.size, srcData);
+
+       const VkFormat                                                  dstFormat                               = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.featuredFormat :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.featurelessFormat :
+                                                                                                                                         VK_FORMAT_UNDEFINED;
+       const bool                                                              dstExtendedImageCreate  = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? false :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? true :
+                                                                                                                                         false;
+       const VkImageUsageFlags                                 dstImageUsageFlags              = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? m_parameters.pairedImageUsage :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.testedImageUsage :
+                                                                                                                                         0;
+       const VkImageViewUsageCreateInfoKHR*    dstImageViewUsageFlags  = (m_parameters.operation == OPERATION_ATTACHMENT_READ)  ? imageViewUsageNull :
+                                                                                                                                         (m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? &imageViewUsage :
+                                                                                                                                         imageViewUsageNull;
+       const VkDeviceSize                                              dstImageSizeInBytes             = getUncompressedImageSizeInBytes(dstFormat, m_parameters.size);
+
+       const std::vector<tcu::Vec4>                    vertexArray                             = createFullscreenQuad();
+       const deUint32                                                  vertexCount                             = static_cast<deUint32>(vertexArray.size());
+       const size_t                                                    vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
+       const MovePtr<Buffer>                                   vertexBuffer                    = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
+       const Allocation&                                               vertexBufferAlloc               = vertexBuffer->getAllocation();
+       const VkDeviceSize                                              vertexBufferOffset[]    = { 0 };
+
+       const VkBufferCreateInfo                                srcImageBufferInfo              (makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
+       const MovePtr<Buffer>                                   srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
+
+       const VkImageCreateInfo                                 srcImageCreateInfo              = makeCreateImageInfo(srcFormat, m_parameters.imageType, m_parameters.size, srcImageUsageFlags, srcExtendedImageCreate);
+       const MovePtr<Image>                                    srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
+       Move<VkImageView>                                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.featuredFormat, subresourceRange, srcImageViewUsageFlags));
+
+       const VkImageCreateInfo                                 dstImageCreateInfo              = makeCreateImageInfo(dstFormat, m_parameters.imageType, m_parameters.size, dstImageUsageFlags, dstExtendedImageCreate);
+       de::MovePtr<Image>                                              dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
+       Move<VkImageView>                                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.featuredFormat, subresourceRange, dstImageViewUsageFlags));
+
+       const VkBufferCreateInfo                                dstImageBufferInfo              (makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
+       MovePtr<Buffer>                                                 dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
+
+       const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
+       const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
+
+       const Unique<VkRenderPass>                              renderPass                              (makeRenderPass(vk, device, m_parameters.featuredFormat, m_parameters.featuredFormat));
+
+       const Move<VkDescriptorSetLayout>               descriptorSetLayout             (DescriptorSetLayoutBuilder()
+                                                                                                                                               .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
+                                                                                                                                               .build(vk, device));
+       const Move<VkDescriptorPool>                    descriptorPool                  (DescriptorPoolBuilder()
+                                                                                                                                               .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, SINGLE_LAYER)
+                                                                                                                                               .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, SINGLE_LAYER));
+       const Move<VkDescriptorSet>                             descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
+       const VkDescriptorImageInfo                             descriptorSrcImageInfo  (makeDescriptorImageInfo(DE_NULL, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
+
+       const VkExtent2D                                                renderSize                              (makeExtent2D(m_parameters.size[0], m_parameters.size[1]));
+       const Unique<VkPipelineLayout>                  pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
+       const Unique<VkPipeline>                                pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 1u));
+       const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
+       const Unique<VkCommandBuffer>                   cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+       const VkBufferImageCopy                                 srcCopyRegion                   = makeBufferImageCopy(m_parameters.size[0], m_parameters.size[1]);
+       const VkBufferMemoryBarrier                             srcCopyBufferBarrierPre = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
+       const VkImageMemoryBarrier                              srcCopyImageBarrierPre  = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, srcImage->get(), subresourceRange);
+       const VkImageMemoryBarrier                              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
+       const VkBufferImageCopy                                 dstCopyRegion                   = makeBufferImageCopy(m_parameters.size[0], m_parameters.size[1]);
+
+       const VkImageView                                               attachmentBindInfos[]   = { *srcImageView, *dstImageView };
+       const Move<VkFramebuffer>                               framebuffer                             (makeFramebuffer(vk, device, *renderPass, DE_LENGTH_OF_ARRAY(attachmentBindInfos), attachmentBindInfos, renderSize, SINGLE_LAYER));
+
+       DE_ASSERT(srcImageSizeInBytes == dstImageSizeInBytes);
+
+       // Upload vertex data
+       deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
+       flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
+
+       // Upload source image data
+       const Allocation& alloc = srcImageBuffer->getAllocation();
+       deMemcpy(alloc.getHostPtr(), &srcData[0], (size_t)srcImageSizeInBytes);
+       flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
+
+       beginCommandBuffer(vk, *cmdBuffer);
+       vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
+
+       //Copy buffer to image
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrierPre, 1u, &srcCopyImageBarrierPre);
+       vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &srcCopyRegion);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
+
+       beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
+
+       DescriptorSetUpdateBuilder()
+               .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &descriptorSrcImageInfo)
+               .update(vk, device);
+
+       vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
+       vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
+       vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
+
+       vk.cmdEndRenderPass(*cmdBuffer);
+
+       const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
+               VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+               VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
+               dstImage->get(), subresourceRange);
+
+       const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
+               VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
+               dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
+
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
+       vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
+
+       endCommandBuffer(vk, *cmdBuffer);
+
+       submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+
+       const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
+       invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
+       dstData.resize((size_t)dstImageSizeInBytes);
+       deMemcpy(&dstData[0], dstImageBufferAlloc.getHostPtr(), (size_t)dstImageSizeInBytes);
+
+       outputImage = dstImage;
+}
+
+
+VkImageCreateInfo GraphicsAttachmentsTestInstance::makeCreateImageInfo (const VkFormat                         format,
+                                                                                                                                               const ImageType                         type,
+                                                                                                                                               const UVec3&                            size,
+                                                                                                                                               const VkImageUsageFlags         usageFlags,
+                                                                                                                                               const bool                                      extendedImageCreateFlag)
+{
+       const VkImageType                       imageType                               = mapImageType(type);
+       const VkImageCreateFlags        imageCreateFlagsBase    = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+       const VkImageCreateFlags        imageCreateFlagsAddOn   = extendedImageCreateFlag ? VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR | VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR : 0;
+       const VkImageCreateFlags        imageCreateFlags                = imageCreateFlagsBase | imageCreateFlagsAddOn;
+
+       const VkImageCreateInfo createImageInfo =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    // VkStructureType                      sType;
+               DE_NULL,                                                                // const void*                          pNext;
+               imageCreateFlags,                                               // VkImageCreateFlags           flags;
+               imageType,                                                              // VkImageType                          imageType;
+               format,                                                                 // VkFormat                                     format;
+               makeExtent3D(getLayerSize(type, size)), // VkExtent3D                           extent;
+               1u,                                                                             // deUint32                                     mipLevels;
+               1u,                                                                             // deUint32                                     arrayLayers;
+               VK_SAMPLE_COUNT_1_BIT,                                  // VkSampleCountFlagBits        samples;
+               VK_IMAGE_TILING_OPTIMAL,                                // VkImageTiling                        tiling;
+               usageFlags,                                                             // VkImageUsageFlags            usage;
+               VK_SHARING_MODE_EXCLUSIVE,                              // VkSharingMode                        sharingMode;
+               0u,                                                                             // deUint32                                     queueFamilyIndexCount;
+               DE_NULL,                                                                // const deUint32*                      pQueueFamilyIndices;
+               VK_IMAGE_LAYOUT_UNDEFINED,                              // VkImageLayout                        initialLayout;
+       };
+
+       return createImageInfo;
+}
+
+VkImageViewUsageCreateInfoKHR GraphicsAttachmentsTestInstance::makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags)
+{
+       VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR,     //VkStructureType               sType;
+               DE_NULL,                                                                                        //const void*                   pNext;
+               imageUsageFlags,                                                                        //VkImageUsageFlags             usage;
+       };
+
+       return imageViewUsageCreateInfoKHR;
+}
+
+VkDeviceSize GraphicsAttachmentsTestInstance::getUncompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data)
+{
+       tcu::IVec3                              sizeAsIVec3     = tcu::IVec3(static_cast<int>(size[0]), static_cast<int>(size[1]), static_cast<int>(size[2]));
+       VkDeviceSize                    sizeBytes       = getImageSizeBytes(sizeAsIVec3, format);
+
+       data.resize((size_t)sizeBytes);
+       generateData(&data[0], data.size(), format);
+
+       return sizeBytes;
+}
+
+bool GraphicsAttachmentsTestInstance::compareAndLog (const void* reference, const void* result, size_t size)
+{
+       tcu::TestLog&   log                     = m_context.getTestContext().getLog();
+
+       const deUint64* ref64   = reinterpret_cast<const deUint64*>(reference);
+       const deUint64* res64   = reinterpret_cast<const deUint64*>(result);
+       const size_t    sizew   = size / sizeof(deUint64);
+       bool                    equal   = true;
+
+       DE_ASSERT(size % sizeof(deUint64) == 0);
+
+       for (deUint32 ndx = 0u; ndx < static_cast<deUint32>(sizew); ndx++)
+       {
+               if (ref64[ndx] != res64[ndx])
+               {
+                       std::stringstream str;
+
+                       str     << "Difference begins near byte " << ndx * sizeof(deUint64) << "."
+                               << " reference value: 0x" << std::hex << std::setw(2ull * sizeof(deUint64)) << std::setfill('0') << ref64[ndx]
+                               << " result value: 0x" << std::hex << std::setw(2ull * sizeof(deUint64)) << std::setfill('0') << res64[ndx];
+
+                       log.writeMessage(str.str().c_str());
+
+                       equal = false;
+
+                       break;
+               }
+       }
+
+       return equal;
+}
+
+
+class GraphicsTextureTestInstance : public GraphicsAttachmentsTestInstance
+{
+public:
+                                               GraphicsTextureTestInstance             (Context& context, const TestParameters& parameters);
+
+protected:
+       void                            transcode                                               (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage);
+};
+
+GraphicsTextureTestInstance::GraphicsTextureTestInstance (Context& context, const TestParameters& parameters)
+       : GraphicsAttachmentsTestInstance(context, parameters)
+{
+}
+
+void GraphicsTextureTestInstance::transcode (std::vector<deUint8>& srcData, std::vector<deUint8>& dstData, de::MovePtr<Image>& outputImage)
+{
+       const DeviceInterface&                                  vk                                              = m_context.getDeviceInterface();
+       const VkDevice                                                  device                                  = m_context.getDevice();
+       const deUint32                                                  queueFamilyIndex                = m_context.getUniversalQueueFamilyIndex();
+       const VkQueue                                                   queue                                   = m_context.getUniversalQueue();
+       Allocator&                                                              allocator                               = m_context.getDefaultAllocator();
+
+       const VkImageSubresourceRange                   subresourceRange                = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
+       const VkImageViewUsageCreateInfoKHR*    imageViewUsageNull              = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
+       const VkImageViewUsageCreateInfoKHR             imageViewUsage                  = makeImageViewUsageCreateInfo(m_parameters.testedImageUsage);
+
+       const VkFormat                                                  srcFormat                               = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.featurelessFormat :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.featuredFormat :
+                                                                                                                                         VK_FORMAT_UNDEFINED;
+       const bool                                                              srcExtendedImageCreate  = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? true :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? false :
+                                                                                                                                         false;
+       const VkImageUsageFlags                                 srcImageUsageFlags              = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.testedImageUsage :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.pairedImageUsage :
+                                                                                                                                         0;
+       const VkImageViewUsageCreateInfoKHR*    srcImageViewUsage               = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? &imageViewUsage :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? imageViewUsageNull :
+                                                                                                                                         imageViewUsageNull;
+       const VkDeviceSize                                              srcImageSizeInBytes             = getUncompressedImageData(srcFormat, m_parameters.size, srcData);
+
+       const VkFormat                                                  dstFormat                               = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.featuredFormat :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.featurelessFormat :
+                                                                                                                                         VK_FORMAT_UNDEFINED;
+       const bool                                                              dstExtendedImageCreate  = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? false :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? true :
+                                                                                                                                         false;
+       const VkImageUsageFlags                                 dstImageUsageFlags              = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? m_parameters.pairedImageUsage :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.testedImageUsage :
+                                                                                                                                         0;
+       const VkImageViewUsageCreateInfoKHR*    dstImageViewUsage               = (m_parameters.operation == OPERATION_TEXTURE_READ)  ? imageViewUsageNull :
+                                                                                                                                         (m_parameters.operation == OPERATION_TEXTURE_WRITE) ? &imageViewUsage :
+                                                                                                                                         imageViewUsageNull;
+       const VkDeviceSize                                              dstImageSizeInBytes             = getUncompressedImageSizeInBytes(dstFormat, m_parameters.size);
+
+       const std::vector<tcu::Vec4>                    vertexArray                             = createFullscreenQuad();
+       const deUint32                                                  vertexCount                             = static_cast<deUint32>(vertexArray.size());
+       const size_t                                                    vertexBufferSizeInBytes = vertexCount * sizeof(vertexArray[0]);
+       const MovePtr<Buffer>                                   vertexBuffer                    = MovePtr<Buffer>(new Buffer(vk, device, allocator, makeBufferCreateInfo(vertexBufferSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), MemoryRequirement::HostVisible));
+       const Allocation&                                               vertexBufferAlloc               = vertexBuffer->getAllocation();
+       const VkDeviceSize                                              vertexBufferOffset[]    = { 0 };
+
+       const VkBufferCreateInfo                                srcImageBufferInfo              (makeBufferCreateInfo(srcImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_SRC_BIT));
+       const MovePtr<Buffer>                                   srcImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, srcImageBufferInfo, MemoryRequirement::HostVisible));
+
+       const VkImageCreateInfo                                 srcImageCreateInfo              = makeCreateImageInfo(srcFormat, m_parameters.imageType, m_parameters.size, srcImageUsageFlags, srcExtendedImageCreate);
+       const MovePtr<Image>                                    srcImage                                (new Image(vk, device, allocator, srcImageCreateInfo, MemoryRequirement::Any));
+       Move<VkImageView>                                               srcImageView                    (makeImageView(vk, device, srcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.featuredFormat, subresourceRange, srcImageViewUsage));
+
+       const VkImageCreateInfo                                 dstImageCreateInfo              = makeCreateImageInfo(dstFormat, m_parameters.imageType, m_parameters.size, dstImageUsageFlags, dstExtendedImageCreate);
+       de::MovePtr<Image>                                              dstImage                                (new Image(vk, device, allocator, dstImageCreateInfo, MemoryRequirement::Any));
+       Move<VkImageView>                                               dstImageView                    (makeImageView(vk, device, dstImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.featuredFormat, subresourceRange, dstImageViewUsage));
+       const VkImageMemoryBarrier                              dstCopyImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, dstImage->get(), subresourceRange);
+
+       const VkBufferCreateInfo                                dstImageBufferInfo              (makeBufferCreateInfo(dstImageSizeInBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT));
+       MovePtr<Buffer>                                                 dstImageBuffer                  = MovePtr<Buffer>(new Buffer(vk, device, allocator, dstImageBufferInfo, MemoryRequirement::HostVisible));
+
+       const Unique<VkShaderModule>                    vertShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
+       const Unique<VkShaderModule>                    fragShaderModule                (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
+
+       const Unique<VkRenderPass>                              renderPass                              (makeRenderPass(vk, device));
+
+       const Move<VkDescriptorSetLayout>               descriptorSetLayout             (DescriptorSetLayoutBuilder()
+                                                                                                                                               .addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT)
+                                                                                                                                               .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_FRAGMENT_BIT)
+                                                                                                                                               .build(vk, device));
+       const Move<VkDescriptorPool>                    descriptorPool                  (DescriptorPoolBuilder()
+                                                                                                                                               .addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
+                                                                                                                                               .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
+                                                                                                                                               .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
+       const Move<VkDescriptorSet>                             descriptorSet                   (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
+       const VkSamplerCreateInfo                               srcSamplerInfo                  (makeSamplerCreateInfo());
+       const Move<VkSampler>                                   srcSampler                              = vk::createSampler(vk, device, &srcSamplerInfo);
+       const VkDescriptorImageInfo                             descriptorSrcImage              (makeDescriptorImageInfo(*srcSampler, *srcImageView, VK_IMAGE_LAYOUT_GENERAL));
+       const VkDescriptorImageInfo                             descriptorDstImage              (makeDescriptorImageInfo(DE_NULL, *dstImageView, VK_IMAGE_LAYOUT_GENERAL));
+
+       const VkExtent2D                                                renderSize                              (makeExtent2D(m_parameters.size[0], m_parameters.size[1]));
+       const Unique<VkPipelineLayout>                  pipelineLayout                  (makePipelineLayout(vk, device, *descriptorSetLayout));
+       const Unique<VkPipeline>                                pipeline                                (makeGraphicsPipeline(vk, device, *pipelineLayout, *renderPass, *vertShaderModule, *fragShaderModule, renderSize, 0u));
+       const Unique<VkCommandPool>                             cmdPool                                 (createCommandPool(vk, device, VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, queueFamilyIndex));
+       const Unique<VkCommandBuffer>                   cmdBuffer                               (allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+
+       const VkBufferImageCopy                                 srcCopyRegion                   = makeBufferImageCopy(m_parameters.size[0], m_parameters.size[1]);
+       const VkBufferMemoryBarrier                             srcCopyBufferBarrier    = makeBufferMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, srcImageBuffer->get(), 0ull, srcImageSizeInBytes);
+       const VkImageMemoryBarrier                              srcCopyImageBarrier             = makeImageMemoryBarrier(0u, VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
+       const VkImageMemoryBarrier                              srcCopyImageBarrierPost = makeImageMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, srcImage->get(), subresourceRange);
+
+       const VkBufferImageCopy                                 dstCopyRegion                   = makeBufferImageCopy(m_parameters.size[0], m_parameters.size[1]);
+
+       const VkExtent2D                                                framebufferSize                 (makeExtent2D(m_parameters.size[0], m_parameters.size[1]));
+       const Move<VkFramebuffer>                               framebuffer                             (makeFramebuffer(vk, device, *renderPass, 0, DE_NULL, framebufferSize, SINGLE_LAYER));
+
+       DE_ASSERT(srcImageSizeInBytes == dstImageSizeInBytes);
+
+       // Upload vertex data
+       deMemcpy(vertexBufferAlloc.getHostPtr(), &vertexArray[0], vertexBufferSizeInBytes);
+       flushMappedMemoryRange(vk, device, vertexBufferAlloc.getMemory(), vertexBufferAlloc.getOffset(), vertexBufferSizeInBytes);
+
+       // Upload source image data
+       const Allocation& alloc = srcImageBuffer->getAllocation();
+       deMemcpy(alloc.getHostPtr(), &srcData[0], (size_t)srcImageSizeInBytes);
+       flushMappedMemoryRange(vk, device, alloc.getMemory(), alloc.getOffset(), srcImageSizeInBytes);
+
+       beginCommandBuffer(vk, *cmdBuffer);
+       vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
+
+       //Copy buffer to image
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1u, &srcCopyBufferBarrier, 1u, &srcCopyImageBarrier);
+       vk.cmdCopyBufferToImage(*cmdBuffer, srcImageBuffer->get(), srcImage->get(), VK_IMAGE_LAYOUT_GENERAL, 1u, &srcCopyRegion);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1u, &srcCopyImageBarrierPost);
+
+       // Make source image readable
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0u, DE_NULL, 1u, &dstCopyImageBarrier);
+
+       beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer, renderSize);
+       {
+               DescriptorSetUpdateBuilder()
+                       .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &descriptorSrcImage)
+                       .writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(1u), VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &descriptorDstImage)
+                       .update(vk, device);
+
+               vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
+               vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &vertexBuffer->get(), vertexBufferOffset);
+               vk.cmdDraw(*cmdBuffer, vertexCount, 1, 0, 0);
+       }
+       vk.cmdEndRenderPass(*cmdBuffer);
+
+       const VkImageMemoryBarrier prepareForTransferBarrier = makeImageMemoryBarrier(
+               VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+               VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
+               dstImage->get(), subresourceRange);
+
+       const VkBufferMemoryBarrier copyBarrier = makeBufferMemoryBarrier(
+               VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT,
+               dstImageBuffer->get(), 0ull, dstImageSizeInBytes);
+
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &prepareForTransferBarrier);
+       vk.cmdCopyImageToBuffer(*cmdBuffer, dstImage->get(), VK_IMAGE_LAYOUT_GENERAL, dstImageBuffer->get(), 1u, &dstCopyRegion);
+       vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &copyBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
+
+       endCommandBuffer(vk, *cmdBuffer);
+
+       submitCommandsAndWait(vk, device, queue, *cmdBuffer);
+
+       const Allocation& dstImageBufferAlloc = dstImageBuffer->getAllocation();
+       invalidateMappedMemoryRange(vk, device, dstImageBufferAlloc.getMemory(), dstImageBufferAlloc.getOffset(), dstImageSizeInBytes);
+       dstData.resize((size_t)dstImageSizeInBytes);
+       deMemcpy(&dstData[0], dstImageBufferAlloc.getHostPtr(), (size_t)dstImageSizeInBytes);
+
+       outputImage = dstImage;
+}
+
+class ImageTranscodingCase : public TestCase
+{
+public:
+                                                       ImageTranscodingCase            (TestContext&                           testCtx,
+                                                                                                                const std::string&                     name,
+                                                                                                                const std::string&                     desc,
+                                                                                                                const TestParameters&          parameters);
+       void                                    initPrograms                            (SourceCollections&                     programCollection) const;
+       TestInstance*                   createInstance                          (Context&                                       context) const;
+       bool                                    isFormatUsageFlagSupported      (Context&                                       context,
+                                                                                                                const VkFormat                         format,
+                                                                                                                VkImageUsageFlags                      formatUsageFlags) const;
+
+protected:
+       const TestParameters    m_parameters;
+};
+
+ImageTranscodingCase::ImageTranscodingCase (TestContext& testCtx, const std::string& name, const std::string& desc, const TestParameters& parameters)
+       : TestCase                              (testCtx, name, desc)
+       , m_parameters                  (parameters)
+{
+}
+
+void ImageTranscodingCase::initPrograms (vk::SourceCollections&        programCollection) const
+{
+       DE_ASSERT(m_parameters.size.x() > 0);
+       DE_ASSERT(m_parameters.size.y() > 0);
+
+       ImageType       imageTypeForFS = (m_parameters.imageType == IMAGE_TYPE_2D_ARRAY) ? IMAGE_TYPE_2D : m_parameters.imageType;
+
+       // Vertex shader
+       {
+               std::ostringstream src;
+               src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
+                       << "layout(location = 0) in vec4 v_in_position;\n"
+                       << "\n"
+                       << "void main (void)\n"
+                       << "{\n"
+                       << "    gl_Position = v_in_position;\n"
+                       << "}\n";
+
+               programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
+       }
+
+       // Fragment shader
+       {
+               switch(m_parameters.operation)
+               {
+                       case OPERATION_ATTACHMENT_READ:
+                       case OPERATION_ATTACHMENT_WRITE:
+                       {
+                               std::ostringstream      src;
+
+                               const std::string       dstTypeStr      = getGlslAttachmentType(m_parameters.featuredFormat);
+                               const std::string       srcTypeStr      = getGlslInputAttachmentType(m_parameters.featuredFormat);
+
+                               src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
+                                       << "precision highp int;\n"
+                                       << "precision highp float;\n"
+                                       << "\n"
+                                       << "layout (location = 0) out highp " << dstTypeStr << " o_color;\n"
+                                       << "layout (input_attachment_index = 0, set = 0, binding = 0) uniform highp " << srcTypeStr << " inputImage1;\n"
+                                       << "\n"
+                                       << "void main (void)\n"
+                                       << "{\n"
+                                       << "    o_color = " << dstTypeStr << "(subpassLoad(inputImage1));\n"
+                                       << "}\n";
+
+                               programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
+
+                               break;
+                       }
+
+                       case OPERATION_TEXTURE_READ:
+                       case OPERATION_TEXTURE_WRITE:
+                       {
+                               std::ostringstream      src;
+
+                               const std::string       srcSamplerTypeStr               = getGlslSamplerType(mapVkFormat(m_parameters.featuredFormat), mapImageViewType(imageTypeForFS));
+                               const std::string       dstImageTypeStr                 = getShaderImageType(mapVkFormat(m_parameters.featuredFormat), imageTypeForFS);
+                               const std::string       dstFormatQualifierStr   = getShaderImageFormatQualifier(mapVkFormat(m_parameters.featuredFormat));
+
+                               src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n\n"
+                                       << "layout (binding = 0) uniform " << srcSamplerTypeStr << " u_imageIn;\n"
+                                       << "layout (binding = 1, " << dstFormatQualifierStr << ") writeonly uniform " << dstImageTypeStr << " u_imageOut;\n"
+                                       << "\n"
+                                       << "void main (void)\n"
+                                       << "{\n"
+                                       << "    const ivec2 out_pos = ivec2(gl_FragCoord.xy);\n"
+                                       << "    const ivec2 pixels_resolution = ivec2(textureSize(u_imageIn, 0)) - ivec2(1,1);\n"
+                                       << "    const vec2 in_pos = vec2(out_pos) / vec2(pixels_resolution);\n"
+                                       << "    imageStore(u_imageOut, out_pos, texture(u_imageIn, in_pos));\n"
+                                       << "}\n";
+
+                               programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
+
+                               break;
+                       }
+
+                       default:
+                               DE_ASSERT(false);
+               }
+       }
+}
+
+bool ImageTranscodingCase::isFormatUsageFlagSupported (Context& context, const VkFormat format, VkImageUsageFlags formatUsageFlags) const
+{
+       const VkPhysicalDevice          physicalDevice                  = context.getPhysicalDevice();
+       const InstanceInterface&        vk                                              = context.getInstanceInterface();
+       VkImageFormatProperties         imageFormatProperties;
+       const VkResult                          queryResult                             = vk.getPhysicalDeviceImageFormatProperties(
+                                                                                                                       physicalDevice,
+                                                                                                                       format,
+                                                                                                                       mapImageType(m_parameters.imageType),
+                                                                                                                       VK_IMAGE_TILING_OPTIMAL,
+                                                                                                                       formatUsageFlags,
+                                                                                                                       VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,
+                                                                                                                       &imageFormatProperties);
+
+       return (queryResult == VK_SUCCESS);
+}
+
+TestInstance* ImageTranscodingCase::createInstance (Context& context) const
+{
+       VkFormat                                        featuredFormat          = m_parameters.featuredFormat;
+       VkFormat                                        featurelessFormat       = VK_FORMAT_UNDEFINED;
+       bool                                            differenceFound         = false;
+
+       DE_ASSERT(m_parameters.testedImageUsageFeature != 0);
+
+       if (std::find(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2") == context.getDeviceExtensions().end())
+               TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported");
+
+       if (!isFormatUsageFlagSupported(context, featuredFormat, m_parameters.testedImageUsageFeature))
+               TCU_THROW(NotSupportedError, "Test skipped due to feature is not supported by the format");
+
+       if (!isFormatUsageFlagSupported(context, featuredFormat, m_parameters.testedImageUsage | m_parameters.pairedImageUsage))
+               TCU_THROW(NotSupportedError, "Required image usage flags are not supported by the format");
+
+       for (deUint32 i = 0; m_parameters.compatibleFormats[i] != VK_FORMAT_UNDEFINED; i++)
+       {
+               featurelessFormat = m_parameters.compatibleFormats[i];
+
+               if (isSupportedByFramework(featurelessFormat)
+                       && !isFormatUsageFlagSupported(context, featurelessFormat, m_parameters.testedImageUsageFeature)
+                       && isFormatUsageFlagSupported(context, featurelessFormat, m_parameters.testedImageUsage & (~m_parameters.testedImageUsageFeature))
+                       )
+               {
+                       differenceFound = true;
+
+                       break;
+               }
+       }
+
+       if (differenceFound)
+       {
+               TestParameters  calculatedParameters    =
+               {
+                       m_parameters.operation,                                 // Operation                            operation
+                       m_parameters.size,                                              // UVec3                                        size
+                       m_parameters.imageType,                                 // ImageType                            imageType
+                       m_parameters.testedImageUsageFeature,   // VkImageUsageFlagBits         testedImageUsageFeature
+                       m_parameters.featuredFormat,                    // VkFormat                                     featuredFormat
+                       featurelessFormat,                                              // VkFormat                                     featurelessFormat
+                       m_parameters.testedImageUsage,                  // VkImageUsageFlags            testedImageUsage
+                       m_parameters.pairedImageUsage,                  // VkImageUsageFlags            pairedImageUsage
+                       DE_NULL,                                                                // const VkFormat*                      compatibleFormats
+               };
+
+               switch (m_parameters.operation)
+               {
+                       case OPERATION_ATTACHMENT_READ:
+                       case OPERATION_ATTACHMENT_WRITE:
+                               return new GraphicsAttachmentsTestInstance(context, calculatedParameters);
+
+                       case OPERATION_TEXTURE_READ:
+                       case OPERATION_TEXTURE_WRITE:
+                               return new GraphicsTextureTestInstance(context, calculatedParameters);
+
+                       default:
+                               TCU_THROW(InternalError, "Impossible");
+               }
+       }
+       else
+               TCU_THROW(NotSupportedError, "All formats in group contain tested feature. Test is impossible.");
+}
+
+} // anonymous ns
+
+static const VkFormat  compatibleFormatList8Bit[]              =
+{
+       VK_FORMAT_R4G4_UNORM_PACK8,
+       VK_FORMAT_R8_UNORM,
+       VK_FORMAT_R8_SNORM,
+       VK_FORMAT_R8_USCALED,
+       VK_FORMAT_R8_SSCALED,
+       VK_FORMAT_R8_UINT,
+       VK_FORMAT_R8_SINT,
+       VK_FORMAT_R8_SRGB,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList16Bit[]             =
+{
+       VK_FORMAT_R4G4B4A4_UNORM_PACK16,
+       VK_FORMAT_B4G4R4A4_UNORM_PACK16,
+       VK_FORMAT_R5G6B5_UNORM_PACK16,
+       VK_FORMAT_B5G6R5_UNORM_PACK16,
+       VK_FORMAT_R5G5B5A1_UNORM_PACK16,
+       VK_FORMAT_B5G5R5A1_UNORM_PACK16,
+       VK_FORMAT_A1R5G5B5_UNORM_PACK16,
+       VK_FORMAT_R8G8_UNORM,
+       VK_FORMAT_R8G8_SNORM,
+       VK_FORMAT_R8G8_USCALED,
+       VK_FORMAT_R8G8_SSCALED,
+       VK_FORMAT_R8G8_UINT,
+       VK_FORMAT_R8G8_SINT,
+       VK_FORMAT_R8G8_SRGB,
+       VK_FORMAT_R16_UNORM,
+       VK_FORMAT_R16_SNORM,
+       VK_FORMAT_R16_USCALED,
+       VK_FORMAT_R16_SSCALED,
+       VK_FORMAT_R16_UINT,
+       VK_FORMAT_R16_SINT,
+       VK_FORMAT_R16_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList24Bit[]             =
+{
+       VK_FORMAT_R8G8B8_UNORM,
+       VK_FORMAT_R8G8B8_SNORM,
+       VK_FORMAT_R8G8B8_USCALED,
+       VK_FORMAT_R8G8B8_SSCALED,
+       VK_FORMAT_R8G8B8_UINT,
+       VK_FORMAT_R8G8B8_SINT,
+       VK_FORMAT_R8G8B8_SRGB,
+       VK_FORMAT_B8G8R8_UNORM,
+       VK_FORMAT_B8G8R8_SNORM,
+       VK_FORMAT_B8G8R8_USCALED,
+       VK_FORMAT_B8G8R8_SSCALED,
+       VK_FORMAT_B8G8R8_UINT,
+       VK_FORMAT_B8G8R8_SINT,
+       VK_FORMAT_B8G8R8_SRGB,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList32Bit[]             =
+{
+       VK_FORMAT_R8G8B8A8_UNORM,
+       VK_FORMAT_R8G8B8A8_SNORM,
+       VK_FORMAT_R8G8B8A8_USCALED,
+       VK_FORMAT_R8G8B8A8_SSCALED,
+       VK_FORMAT_R8G8B8A8_UINT,
+       VK_FORMAT_R8G8B8A8_SINT,
+       VK_FORMAT_R8G8B8A8_SRGB,
+       VK_FORMAT_B8G8R8A8_UNORM,
+       VK_FORMAT_B8G8R8A8_SNORM,
+       VK_FORMAT_B8G8R8A8_USCALED,
+       VK_FORMAT_B8G8R8A8_SSCALED,
+       VK_FORMAT_B8G8R8A8_UINT,
+       VK_FORMAT_B8G8R8A8_SINT,
+       VK_FORMAT_B8G8R8A8_SRGB,
+       VK_FORMAT_A8B8G8R8_UNORM_PACK32,
+       VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+       VK_FORMAT_A8B8G8R8_USCALED_PACK32,
+       VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
+       VK_FORMAT_A8B8G8R8_UINT_PACK32,
+       VK_FORMAT_A8B8G8R8_SINT_PACK32,
+       VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+       VK_FORMAT_A2R10G10B10_UNORM_PACK32,
+       VK_FORMAT_A2R10G10B10_SNORM_PACK32,
+       VK_FORMAT_A2R10G10B10_USCALED_PACK32,
+       VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
+       VK_FORMAT_A2R10G10B10_UINT_PACK32,
+       VK_FORMAT_A2R10G10B10_SINT_PACK32,
+       VK_FORMAT_A2B10G10R10_UNORM_PACK32,
+       VK_FORMAT_A2B10G10R10_SNORM_PACK32,
+       VK_FORMAT_A2B10G10R10_USCALED_PACK32,
+       VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
+       VK_FORMAT_A2B10G10R10_UINT_PACK32,
+       VK_FORMAT_A2B10G10R10_SINT_PACK32,
+       VK_FORMAT_R16G16_UNORM,
+       VK_FORMAT_R16G16_SNORM,
+       VK_FORMAT_R16G16_USCALED,
+       VK_FORMAT_R16G16_SSCALED,
+       VK_FORMAT_R16G16_UINT,
+       VK_FORMAT_R16G16_SINT,
+       VK_FORMAT_R16G16_SFLOAT,
+       VK_FORMAT_R32_UINT,
+       VK_FORMAT_R32_SINT,
+       VK_FORMAT_R32_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList48Bit[]             =
+{
+       VK_FORMAT_R16G16B16_UNORM,
+       VK_FORMAT_R16G16B16_SNORM,
+       VK_FORMAT_R16G16B16_USCALED,
+       VK_FORMAT_R16G16B16_SSCALED,
+       VK_FORMAT_R16G16B16_UINT,
+       VK_FORMAT_R16G16B16_SINT,
+       VK_FORMAT_R16G16B16_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList64Bit[]             =
+{
+       VK_FORMAT_R16G16B16A16_UNORM,
+       VK_FORMAT_R16G16B16A16_SNORM,
+       VK_FORMAT_R16G16B16A16_USCALED,
+       VK_FORMAT_R16G16B16A16_SSCALED,
+       VK_FORMAT_R16G16B16A16_UINT,
+       VK_FORMAT_R16G16B16A16_SINT,
+       VK_FORMAT_R16G16B16A16_SFLOAT,
+       VK_FORMAT_R32G32_UINT,
+       VK_FORMAT_R32G32_SINT,
+       VK_FORMAT_R32G32_SFLOAT,
+       VK_FORMAT_R64_UINT,
+       VK_FORMAT_R64_SINT,
+       VK_FORMAT_R64_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList96Bit[]             =
+{
+       VK_FORMAT_R32G32B32_UINT,
+       VK_FORMAT_R32G32B32_SINT,
+       VK_FORMAT_R32G32B32_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList128Bit[]    =
+{
+       VK_FORMAT_R32G32B32A32_UINT,
+       VK_FORMAT_R32G32B32A32_SINT,
+       VK_FORMAT_R32G32B32A32_SFLOAT,
+       VK_FORMAT_R64G64_UINT,
+       VK_FORMAT_R64G64_SINT,
+       VK_FORMAT_R64G64_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+const VkFormat compatibleFormatList192Bit[]    =
+{
+       VK_FORMAT_R64G64B64_UINT,
+       VK_FORMAT_R64G64B64_SINT,
+       VK_FORMAT_R64G64B64_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat  compatibleFormatList256Bit[]    =
+{
+       VK_FORMAT_R64G64B64A64_UINT,
+       VK_FORMAT_R64G64B64A64_SINT,
+       VK_FORMAT_R64G64B64A64_SFLOAT,
+
+       VK_FORMAT_UNDEFINED
+};
+
+static const VkFormat* compatibleFormatsList[] =
+{
+       compatibleFormatList8Bit,
+       compatibleFormatList16Bit,
+       compatibleFormatList24Bit,
+       compatibleFormatList32Bit,
+       compatibleFormatList48Bit,
+       compatibleFormatList64Bit,
+       compatibleFormatList96Bit,
+       compatibleFormatList128Bit,
+       compatibleFormatList192Bit,
+       compatibleFormatList256Bit,
+};
+
+tcu::TestCaseGroup* createImageTranscodingSupportTests (tcu::TestContext& testCtx)
+{
+       const std::string                       operationName[OPERATION_LAST]                   =
+       {
+               "attachment_read",
+               "attachment_write",
+               "texture_read",
+               "texture_write",
+       };
+       const VkImageUsageFlagBits      testedImageUsageFlags[OPERATION_LAST]   =
+       {
+               VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+               VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+               VK_IMAGE_USAGE_SAMPLED_BIT,
+               VK_IMAGE_USAGE_STORAGE_BIT,
+       };
+       const VkImageUsageFlagBits      pairedImageUsageFlags[OPERATION_LAST]   =
+       {
+               VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+               VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+               VK_IMAGE_USAGE_STORAGE_BIT,
+               VK_IMAGE_USAGE_SAMPLED_BIT,
+       };
+       VkImageUsageFlags                       baseFlagsAddOn                                                  = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
+
+       MovePtr<tcu::TestCaseGroup>     imageTranscodingTests   (new tcu::TestCaseGroup(testCtx, "extended_usage_bit", "Extended usage bit test cases"));
+
+       for (int operationNdx = OPERATION_ATTACHMENT_READ; operationNdx < OPERATION_LAST; ++operationNdx)
+       {
+               MovePtr<tcu::TestCaseGroup>     imageOperationGroup     (new tcu::TestCaseGroup(testCtx, operationName[operationNdx].c_str(), ""));
+
+               for (deUint32 groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(compatibleFormatsList); groupNdx++)
+               {
+                       for (deUint32 featuredFormatNdx = 0; compatibleFormatsList[groupNdx][featuredFormatNdx] != VK_FORMAT_UNDEFINED; featuredFormatNdx++)
+                       {
+                               const VkFormat  featuredFormat          = compatibleFormatsList[groupNdx][featuredFormatNdx];
+                               const VkFormat  featurelessFormat       = VK_FORMAT_UNDEFINED;                                                                  // Lookup process is in createInstance()
+
+                               if (!isSupportedByFramework(featuredFormat))
+                                       continue;
+
+                               // Cannot handle SRGB in shader layout classifier
+                               if (isSrgbFormat(featuredFormat))
+                                       continue;
+
+                               // Cannot handle packed in shader layout classifier
+                               if (isPackedType(featuredFormat))
+                                       continue;
+
+                               // Cannot handle swizzled component format (i.e. bgr) in shader layout classifier
+                               if (isComponentSwizzled(featuredFormat))
+                                       continue;
+
+                               // Cannot handle three-component images in shader layout classifier
+                               if (getNumUsedChannels(featuredFormat) == 3)
+                                       continue;
+
+                               const std::string               testName        = getFormatShortString(featuredFormat);
+                               const TestParameters    parameters      =
+                               {
+                                       static_cast<Operation>(operationNdx),                                   // Operation                            operation
+                                       UVec3(16u, 16u, 1u),                                                                    // UVec3                                        size
+                                       IMAGE_TYPE_2D,                                                                                  // ImageType                            imageType
+                                       testedImageUsageFlags[operationNdx],                                    // VkImageUsageFlagBits         testedImageUsageFeature
+                                       featuredFormat,                                                                                 // VkFormat                                     featuredFormat
+                                       featurelessFormat,                                                                              // VkFormat                                     featurelessFormat
+                                       baseFlagsAddOn | testedImageUsageFlags[operationNdx],   // VkImageUsageFlags            testedImageUsage
+                                       baseFlagsAddOn | pairedImageUsageFlags[operationNdx],   // VkImageUsageFlags            pairedImageUsage
+                                       compatibleFormatsList[groupNdx]                                                 // const VkFormat*                      compatibleFormats
+                               };
+
+                               imageOperationGroup->addChild(new ImageTranscodingCase(testCtx, testName, "", parameters));
+                       }
+               }
+
+               imageTranscodingTests->addChild(imageOperationGroup.release());
+       }
+
+       return imageTranscodingTests.release();
+}
+
+} // image
+} // vkt

diff --git a/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.hpp b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.hpp
new file mode 100644 (file)
index 0000000..48b3be2
--- /dev/null
+++ b/external/vulkancts/modules/vulkan/image/vktImageTranscodingSupportTests.hpp
@@ -0,0 +1,39 @@
+#ifndef _VKTIMAGETRANSCODINGSUPPORTTESTS_HPP
+#define _VKTIMAGETRANSCODINGSUPPORTTESTS_HPP
+/*------------------------------------------------------------------------
+ * Vulkan Conformance Tests
+ * ------------------------
+ *
+ * Copyright (c) 2017 The Khronos Group 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  vktImageCompressionTranscodingSupport.hpp
+ * \brief Compression transcoding support
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuDefs.hpp"
+#include "tcuTestCase.hpp"
+
+namespace vkt
+{
+namespace image
+{
+
+tcu::TestCaseGroup* createImageTranscodingSupportTests (tcu::TestContext& testCtx);
+
+} // image
+} // vkt
+
+#endif // _VKTIMAGETRANSCODINGSUPPORTTESTS_HPP

diff --git a/external/vulkancts/mustpass/1.0.3/vk-default.txt b/external/vulkancts/mustpass/1.0.3/vk-default.txt
index 8abf142..2ecc9c2 100644 (file)
--- a/external/vulkancts/mustpass/1.0.3/vk-default.txt
+++ b/external/vulkancts/mustpass/1.0.3/vk-default.txt
@@ -210158,6 +210158,222 @@ dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_un
 dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_srgb_block.r32g32b32a32_uint
 dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_srgb_block.r32g32b32a32_sint
 dEQP-VK.image.texel_view_compatible.graphic.extended.texture_write.astc_12x12_srgb_block.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r32_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.attachment_read.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r32_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.attachment_write.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r8_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r8_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r16_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r32_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r32_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.texture_read.r32g32b32a32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r8_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r8_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r16_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r8g8b8a8_sint
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_unorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_snorm_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_uscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_sscaled_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_uint_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.a8b8g8r8_sint_pack32
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r32_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r32_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_unorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_snorm
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_uscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_sscaled
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r16g16b16a16_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32_sfloat
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32b32a32_uint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32b32a32_sint
+dEQP-VK.image.extended_usage_bit.texture_write.r32g32b32a32_sfloat
 dEQP-VK.wsi.xlib.surface.create
 dEQP-VK.wsi.xlib.surface.create_custom_allocator
 dEQP-VK.wsi.xlib.surface.create_simulate_oom