Add export/import drm modifier test

This CL adds a test to export/import images using modifiers.

To simulate exporting from a client and importing in another one the test is organaized as following:
- an image is upload to srcImage (no modifiers)
- srcImage is blitted to dstImage (with modifiers)
- the memory underlaying dstImage is exported
- the memory is reimported and an image importedSrcImage (with modifiers) is bound to it
- importedSrcImage is blit to outImage

At the end the test verifies that the conetnts of srcImage and outImage are the same.

These tests were run against mesa/intel with
https://gitlab.freedesktop.org/chadversary/mesa/-/tree/anv-drm-format-mod applied on top.

Components: Vulkan

Change-Id: I01c20397c1b49eb355efda3a6e199572cb56652b
Affects: dEQP-VK.drm_format_modifiers.export_import.*

diff --git a/android/cts/master/vk-master-2020-03-01.txt b/android/cts/master/vk-master-2020-03-01.txt
index 5717474..d1e1cec 100644 (file)
--- a/android/cts/master/vk-master-2020-03-01.txt
+++ b/android/cts/master/vk-master-2020-03-01.txt
@@ -268146,3 +268146,126 @@ dEQP-VK.drm_format_modifiers.create_list_modifiers.r64g64b64a64_sint
 dEQP-VK.drm_format_modifiers.create_list_modifiers.r64g64b64a64_sfloat
 dEQP-VK.drm_format_modifiers.create_list_modifiers.b10g11r11_ufloat_pack32
 dEQP-VK.drm_format_modifiers.create_list_modifiers.e5b9g9r9_ufloat_pack32
+dEQP-VK.drm_format_modifiers.export_import.r4g4_unorm_pack8
+dEQP-VK.drm_format_modifiers.export_import.r4g4b4a4_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b4g4r4a4_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r5g6b5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b5g6r5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r5g5b5a1_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b5g5r5a1_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.a1r5g5b5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_srgb
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_unorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_snorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_uint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_sint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_srgb
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_unorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_snorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_uint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_sint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_srgb
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_srgb_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.r16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.b10g11r11_ufloat_pack32
+dEQP-VK.drm_format_modifiers.export_import.e5b9g9r9_ufloat_pack32

diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt
index bcf4a17..d3c6b34 100644 (file)
--- a/android/cts/master/vk-master.txt
+++ b/android/cts/master/vk-master.txt
@@ -678339,3 +678339,126 @@ dEQP-VK.drm_format_modifiers.create_list_modifiers.r64g64b64a64_sint
 dEQP-VK.drm_format_modifiers.create_list_modifiers.r64g64b64a64_sfloat
 dEQP-VK.drm_format_modifiers.create_list_modifiers.b10g11r11_ufloat_pack32
 dEQP-VK.drm_format_modifiers.create_list_modifiers.e5b9g9r9_ufloat_pack32
+dEQP-VK.drm_format_modifiers.export_import.r4g4_unorm_pack8
+dEQP-VK.drm_format_modifiers.export_import.r4g4b4a4_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b4g4r4a4_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r5g6b5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b5g6r5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r5g5b5a1_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b5g5r5a1_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.a1r5g5b5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_srgb
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_unorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_snorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_uint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_sint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_srgb
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_unorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_snorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_uint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_sint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_srgb
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_srgb_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.r16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.b10g11r11_ufloat_pack32
+dEQP-VK.drm_format_modifiers.export_import.e5b9g9r9_ufloat_pack32

diff --git a/external/vulkancts/modules/vulkan/modifiers/vktModifiersTests.cpp b/external/vulkancts/modules/vulkan/modifiers/vktModifiersTests.cpp
index 3e6f3be..e5a3d0c 100644 (file)
--- a/external/vulkancts/modules/vulkan/modifiers/vktModifiersTests.cpp
+++ b/external/vulkancts/modules/vulkan/modifiers/vktModifiersTests.cpp
@@ -25,13 +25,20 @@
 #include "vktTestCase.hpp"
 #include "vktTestGroupUtil.hpp"
 #include "vktTestCaseUtil.hpp"
+#include "vktExternalMemoryUtil.hpp"
+#include "vktImageTestsUtil.hpp"
 #include "vkRefUtil.hpp"
 #include "vkBufferWithMemory.hpp"
+#include "vkBarrierUtil.hpp"
 #include "vkCmdUtil.hpp"
 #include "vkObjUtil.hpp"
 #include "vkImageUtil.hpp"
 #include "vkTypeUtil.hpp"
 #include "tcuTestLog.hpp"
+#include "tcuTexture.hpp"
+#include "tcuTextureUtil.hpp"
+#include "tcuImageIO.hpp"
+#include "tcuImageCompare.hpp"
 #include "deUniquePtr.hpp"
 #include "deStringUtil.hpp"
 
@@ -71,9 +78,13 @@ std::vector<VkDrmFormatModifierPropertiesEXT> getDrmFormatModifiers (const Insta
                                                                                                                                         VkPhysicalDevice                       physicalDevice,
                                                                                                                                         VkFormat                                       format)
 {
-       VkDrmFormatModifierPropertiesListEXT                    modifierProperties {};
+       VkDrmFormatModifierPropertiesListEXT                    modifierProperties;
+       deMemset(&modifierProperties, 0, sizeof(modifierProperties));
+
        modifierProperties.sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT;
-       VkFormatProperties2                                                             formatProperties {};
+       VkFormatProperties2                                                             formatProperties;
+       deMemset(&formatProperties, 0, sizeof(formatProperties));
+
        std::vector<VkDrmFormatModifierPropertiesEXT>   drmFormatModifiers;
        formatProperties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
        formatProperties.pNext = &modifierProperties;
@@ -88,6 +99,113 @@ std::vector<VkDrmFormatModifierPropertiesEXT> getDrmFormatModifiers (const Insta
        return drmFormatModifiers;
 }
 
+VkImageFormatProperties2 verifyHandleTypeForFormatModifier (const InstanceInterface&   vki,
+                                                                                                                         VkPhysicalDevice                      physicalDevice,
+                                                                                                                         const VkFormat                        format,
+                                                                                                                         const VkImageType                     imageType,
+                                                                                                                         const VkImageUsageFlags       imageUsages,
+                                                                                                                         const VkExternalMemoryHandleTypeFlags handleType,
+                                                                                                                         const deUint64                        drmFormatModifier)
+{
+       const VkPhysicalDeviceImageDrmFormatModifierInfoEXT     imageFormatModifierInfo =
+       {
+               VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
+               DE_NULL,
+               drmFormatModifier,
+               VK_SHARING_MODE_EXCLUSIVE,
+               0,
+               DE_NULL,
+       };
+       const VkPhysicalDeviceExternalImageFormatInfo externalImageFormatInfo =
+       {
+               VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+               &imageFormatModifierInfo,
+               (VkExternalMemoryHandleTypeFlagBits)handleType,
+       };
+       const VkPhysicalDeviceImageFormatInfo2                          imageFormatInfo                 =
+       {
+               VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+               &externalImageFormatInfo,
+               format,
+               imageType,
+               VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT,
+               imageUsages,
+               0,
+       };
+       VkExternalImageFormatProperties externalImageProperties;
+       deMemset(&externalImageProperties, 0, sizeof(externalImageProperties));
+       externalImageProperties.sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
+       externalImageProperties.sType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
+
+       VkImageFormatProperties2                                                        imageProperties;
+       deMemset(&imageProperties, 0, sizeof(imageProperties));
+       imageProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+       imageProperties.pNext = &externalImageProperties;
+       if (vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &imageProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
+       {
+               TCU_THROW(NotSupportedError, de::toString(format) + " does not support any DRM modifiers");
+       };
+       if ((externalImageProperties.externalMemoryProperties.compatibleHandleTypes & handleType) != handleType)
+       {
+               TCU_THROW(NotSupportedError, de::toString(format) + " does not support the expected memory handle type");
+       }
+
+       return imageProperties;
+}
+
+void checkExportImportExtensions (Context& context, VkFormat format)
+{
+       // tcuTexture.cpp getChannelSize, that is used by intThresholdCompare does not support the following formats.
+       // TODO: Add tcuTexture.cpp support for the following formats.
+       const VkFormat                                  skippedFormats[]                                =
+       {
+               VK_FORMAT_B10G11R11_UFLOAT_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,
+       };
+
+       if (std::find(std::begin(skippedFormats), std::end(skippedFormats), format) != std::end(skippedFormats))
+               TCU_THROW(NotSupportedError, de::toString(format) + " can't be checked for correctness");
+
+       if (!context.isDeviceFunctionalitySupported("VK_KHR_external_memory_fd"))
+               TCU_THROW(NotSupportedError, "VK_KHR_external_memory_fd not supported");
+       checkModifiersSupported(context, format);
+
+       const InstanceInterface&                                                vki                                     = context.getInstanceInterface();
+       std::vector<VkDrmFormatModifierPropertiesEXT>   drmFormatModifiers      = getDrmFormatModifiers(vki, context.getPhysicalDevice(), format);
+
+       if (drmFormatModifiers.size() < 1)
+               TCU_THROW(NotSupportedError, de::toString(format) + " does not support any DRM modifiers");
+       bool                                                                                            featureCompatible                               = false;
+       for (deUint32 m = 0; m < drmFormatModifiers.size(); m++)
+       {
+               const VkFormatFeatureFlags                                                      testFeatures            = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
+               if ((drmFormatModifiers[m].drmFormatModifierTilingFeatures & testFeatures) != testFeatures)
+                       continue;
+               verifyHandleTypeForFormatModifier(vki, context.getPhysicalDevice(), format,
+                                                                                                                                                       VK_IMAGE_TYPE_2D,
+                                                                                                                                                       VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                                                                                                                                       VK_IMAGE_USAGE_SAMPLED_BIT,
+                                                                                                                                                       VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+                                                                                                                                                       drmFormatModifiers[m].drmFormatModifier);
+
+               featureCompatible = true;
+       }
+       if (!featureCompatible)
+               TCU_THROW(NotSupportedError, "Could not find a format modifier supporting required transfer features for " + de::toString(format));
+}
+
+
 VkImageFormatProperties2 getImageFormatPropertiesForModifier (const InstanceInterface& vki,
                                                                                                                          VkPhysicalDevice                      physicalDevice,
                                                                                                                          const VkFormat*                       formats,
@@ -122,9 +240,9 @@ VkImageFormatProperties2 getImageFormatPropertiesForModifier (const InstanceInte
                imageUsages,
                0,
        };
-       VkImageFormatProperties2                                                        imageProperties {};
+       VkImageFormatProperties2                                                        imageProperties;
+       deMemset(&imageProperties, 0, sizeof(imageProperties));
        imageProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
-
        if (vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &imageProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
        {
                TCU_THROW(NotSupportedError, de::toString(formats[0]) + " does not support any DRM modifiers");
@@ -161,10 +279,39 @@ tcu::TestStatus listModifiersCase (Context& context, VkFormat format)
        return tcu::TestStatus::pass("OK");
 }
 
+Move<VkImage> createImageNoModifiers (const DeviceInterface&                   vkd,
+                                                                                                const VkDevice                                 device,
+                                                                                                const VkImageUsageFlags                imageUsages,
+                                                                                                const VkFormat                                 format,
+                                                                                                const UVec2&                                   size)
+{
+       const VkImageCreateInfo                                                 createInfo      =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+               DE_NULL,
+               0,
+               VK_IMAGE_TYPE_2D,
+               format,
+               makeExtent3D(size.x(), size.y(), 1u),
+               1u,             // mipLevels
+               1u,             // arrayLayers
+               VK_SAMPLE_COUNT_1_BIT,
+               VK_IMAGE_TILING_OPTIMAL,
+               imageUsages,
+               VK_SHARING_MODE_EXCLUSIVE,
+               0u,
+               (const deUint32*)DE_NULL,
+               VK_IMAGE_LAYOUT_PREINITIALIZED,
+       };
+
+       return createImage(vkd, device, &createInfo);
+}
+
 Move<VkImage> createImageWithDrmFormatModifiers (const DeviceInterface&                        vkd,
                                                                                                 const VkDevice                                 device,
                                                                                                 const VkImageType                              imageType,
                                                                                                 const VkImageUsageFlags                imageUsages,
+                                                                                                const VkExternalMemoryHandleTypeFlags          externalMemoryHandleTypeFlags,
                                                                                                 const std::vector<VkFormat>                                    formats,
                                                                                                 const UVec2&                                   size,
                                                                                                 const std::vector<deUint64>&   drmFormatModifiers)
@@ -176,10 +323,24 @@ Move<VkImage> createImageWithDrmFormatModifiers (const DeviceInterface&                   vkd,
                (deUint32)drmFormatModifiers.size(),
                drmFormatModifiers.data(),
        };
+
+       const VkExternalMemoryImageCreateInfo externalMemoryCreateInfo =
+       {
+               VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+               &modifierListCreateInfo,
+               externalMemoryHandleTypeFlags,
+       };
+
+       const void* pNext = &externalMemoryCreateInfo;
+       if (!externalMemoryHandleTypeFlags)
+       {
+               pNext = &modifierListCreateInfo;
+       }
+
        const VkImageFormatListCreateInfoKHR                    imageFormatListInfo                     =
        {
                VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR,
-               &modifierListCreateInfo,
+               pNext,
                static_cast<deUint32>(formats.size()),
                formats.data(),
        };
@@ -231,6 +392,7 @@ tcu::TestStatus createImageListModifiersCase (Context& context, const VkFormat f
                        Move<VkImage>                                           image           (createImageWithDrmFormatModifiers(vkd, device, VK_IMAGE_TYPE_2D,
                                                                                                                                                                                                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
                                                                                                                                                                                                 VK_IMAGE_USAGE_SAMPLED_BIT,
+                                                                                                                                                                                                0,
                                                                                                                                                                                                 {format}, UVec2(64, 64), modifiers));
 
 
@@ -252,6 +414,281 @@ tcu::TestStatus createImageListModifiersCase (Context& context, const VkFormat f
        return tcu::TestStatus::pass("OK");
 }
 
+deUint32 chooseMemoryType(deUint32 bits)
+{
+       DE_ASSERT(bits != 0);
+
+       for (deUint32 memoryTypeIndex = 0; (1u << memoryTypeIndex) <= bits; memoryTypeIndex++)
+       {
+               if ((bits & (1u << memoryTypeIndex)) != 0)
+                       return memoryTypeIndex;
+       }
+
+       DE_FATAL("No supported memory types");
+       return -1;
+}
+
+bool exportImportMemoryExplicitModifiersCase (Context& context, const VkFormat format, const VkDrmFormatModifierPropertiesEXT& modifier)
+{
+       const InstanceInterface&                                                vki                                     = context.getInstanceInterface();
+       const DeviceInterface&                                                  vkd                                     = context.getDeviceInterface();
+       const VkDevice                                                                  device                          = context.getDevice();
+
+
+       verifyHandleTypeForFormatModifier(vki, context.getPhysicalDevice(), format,
+                                                                                                                                               VK_IMAGE_TYPE_2D,
+                                                                                                                                               VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                                                                                                                               VK_IMAGE_USAGE_SAMPLED_BIT,
+                                                                                                                                               VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+                                                                                                                                               modifier.drmFormatModifier);
+       std::vector<deUint64>                                   modifiers;
+       modifiers.push_back(modifier.drmFormatModifier);
+
+
+       const UVec2                                                                     imageSize               (64, 64);
+       const tcu::TextureFormat referenceTextureFormat (mapVkFormat(format));
+       deUint32 bufferSize = 1<<16;
+       const de::UniquePtr<BufferWithMemory>           inputBuffer             (new BufferWithMemory(vkd, device, context.getDefaultAllocator(),
+                                                                                                                                                                                                                                                                                                                       makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
+                                                                                                                                                                               MemoryRequirement::HostVisible));
+       tcu::PixelBufferAccess                          referenceImage  (referenceTextureFormat, imageSize.x(), imageSize.y(), 1, inputBuffer->getAllocation().getHostPtr());
+       const de::UniquePtr<BufferWithMemory>           outputBuffer            (new BufferWithMemory(vkd, device, context.getDefaultAllocator(),
+                                                                                                                                                                                                                                                                                                                       makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT),
+                                                                                                                                                                               MemoryRequirement::HostVisible));
+       Unique<VkCommandPool>                   cmdPool                         (createCommandPool(vkd, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, context.getUniversalQueueFamilyIndex(), DE_NULL));
+       vkt::ExternalMemoryUtil::NativeHandle                                                           inputImageMemFd;
+
+       const tcu::TextureFormatInfo                            formatInfo              (tcu::getTextureFormatInfo(referenceTextureFormat));
+       tcu::fillWithComponentGradients(referenceImage, formatInfo.valueMin, formatInfo.valueMax);
+
+       flushAlloc(vkd, device, inputBuffer->getAllocation());
+
+       Move<VkImage>                                           srcImage                (createImageNoModifiers(vkd, device,
+                                                                                                                                                                                                VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                                                                                                                                                                VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+                                                                                                                                                                                                format, UVec2(64, 64)));
+       VkMemoryRequirements srcImageMemoryReq = getImageMemoryRequirements(vkd, device, *srcImage);
+       const vk::VkMemoryAllocateInfo  allocationInfo  =
+       {
+               vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+               DE_NULL,
+               srcImageMemoryReq.size,
+               chooseMemoryType(srcImageMemoryReq.memoryTypeBits),
+       };
+       vk::Move<vk::VkDeviceMemory>    srcMemory                       (vk::allocateMemory(vkd, device, &allocationInfo));
+       VK_CHECK(vkd.bindImageMemory(device, *srcImage, *srcMemory, 0));
+
+
+       Unique<VkCommandBuffer>                 cmdBuffer                       (allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+       const VkCommandBufferBeginInfo  cmdBufferBeginInfo      =
+       {
+               VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
+               DE_NULL,
+               VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+               (const VkCommandBufferInheritanceInfo*)DE_NULL,
+       };
+
+       VK_CHECK(vkd.beginCommandBuffer(*cmdBuffer, &cmdBufferBeginInfo));
+
+       {
+               const VkImageAspectFlags                aspect                          = VK_IMAGE_ASPECT_COLOR_BIT;
+               std::vector<VkBufferImageCopy>  copies;
+
+               copies.push_back(image::makeBufferImageCopy(makeExtent3D(imageSize.x(), imageSize.y(), 1u), 1u));
+               copyBufferToImage(vkd, *cmdBuffer, inputBuffer->get(), bufferSize,
+                                                                                       copies, aspect, 1, 1, *srcImage,
+                                                                                       VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+
+       }
+
+       Move<VkImage>                                           dstImage                (createImageWithDrmFormatModifiers(vkd, device, VK_IMAGE_TYPE_2D,
+                                                                                                                                                                                                                                                                                                VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                                                                                                                                                                                                                                                                VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+                                                                                                                                                                                                                                                                                                VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+                                                                                                                                                                                                                                                                                                {format}, UVec2(64, 64), modifiers));
+       VkMemoryRequirements dstImageMemoryReq = getImageMemoryRequirements(vkd, device, *dstImage);
+       vk::Move<vk::VkDeviceMemory>    dstMemory                       (vkt::ExternalMemoryUtil::allocateExportableMemory(vkd, device,
+                                                                                                                                                                                                                                                                                                                                                                                                dstImageMemoryReq.size,
+                                                                                                                                                                                                                                                                                                                                                                                                chooseMemoryType(dstImageMemoryReq.memoryTypeBits),
+                                                                                                                                                                                                                                                                                                                                                                                                VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+                                                                                                                                                                                                                                                                                                                                                                                                *dstImage));
+
+       VK_CHECK(vkd.bindImageMemory(device, *dstImage, *dstMemory, 0));
+       const VkImageMemoryBarrier              srcImageBarrier         =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
+               DE_NULL,                                                                        // const void*                          pNext;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
+               VK_IMAGE_LAYOUT_UNDEFINED,              // VkImageLayout                        oldLayout;
+               VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                   // VkImageLayout                        newLayout;
+               VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
+               VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
+               *srcImage,                                              // VkImage                                      image;
+               {                                                                                       // VkImageSubresourceRange      subresourceRange;
+                       VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
+                       0u,                                                             // deUint32                             baseMipLevel;
+                       1u,                                                             // deUint32                             mipLevels;
+                       0u,                                                             // deUint32                             baseArraySlice;
+                       1u                                                              // deUint32                             arraySize;
+               }
+       };
+       const VkImageMemoryBarrier              dstImageBarrier         =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
+               DE_NULL,                                                                        // const void*                          pNext;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
+               VK_IMAGE_LAYOUT_UNDEFINED,              // VkImageLayout                        oldLayout;
+               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        newLayout;
+               VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
+               VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
+               *dstImage,                                              // VkImage                                      image;
+               {                                                                                       // VkImageSubresourceRange      subresourceRange;
+                       VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
+                       0u,                                                             // deUint32                             baseMipLevel;
+                       1u,                                                             // deUint32                             mipLevels;
+                       0u,                                                             // deUint32                             baseArraySlice;
+                       1u                                                              // deUint32                             arraySize;
+               }
+       };
+       vkd.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &srcImageBarrier);
+       vkd.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &dstImageBarrier);
+
+       VkImageBlit             imageBlit
+       {
+               {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
+               {{0,0,0}, {64,64,1}},
+               {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
+               {{0,0,0}, {64,64,1}},
+       };
+       vkd.cmdBlitImage(*cmdBuffer, *srcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit, VK_FILTER_NEAREST);
+
+       VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
+       submitCommandsAndWait(vkd, device, context.getUniversalQueue(), *cmdBuffer);
+       VkImageDrmFormatModifierPropertiesEXT   properties;
+       deMemset(&properties, 0, sizeof(properties));
+       properties.sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT;
+       VK_CHECK(vkd.getImageDrmFormatModifierPropertiesEXT(device, *dstImage, &properties));
+       TCU_CHECK(properties.drmFormatModifier == modifiers.front());
+       inputImageMemFd = vkt::ExternalMemoryUtil::getMemoryFd(vkd, device, *dstMemory, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT);
+
+       Move<VkImage>                           importedSrcImage                (createImageWithDrmFormatModifiers(vkd, device, VK_IMAGE_TYPE_2D,
+                                                                                                                                                                                                                                                                                                                VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                                                                                                                                                                                                                                                                                VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+                                                                                                                                                                                                                                                                                                                VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+                                                                                                                                                                                                                                                                                                                {format}, UVec2(64, 64), modifiers));
+
+       VkMemoryRequirements importedSrcImageMemoryReq = getImageMemoryRequirements(vkd, device, *importedSrcImage);
+
+       Move<VkDeviceMemory>                                            importedMemory (vkt::ExternalMemoryUtil::importMemory(vkd, device,
+                                                                                                                                                                                                       importedSrcImageMemoryReq,
+                                                                                                                                                                                                       VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+                                                                                                                                                                                                       ~0u, inputImageMemFd));
+       VK_CHECK(vkd.bindImageMemory(device, *importedSrcImage, *importedMemory, 0));
+
+       Move<VkImage>                                           outImage                (createImageNoModifiers(vkd, device,
+                                                                                                                                                                                                                                                       VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                                                                                                                                                                                                                                                       VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
+                                                                                                                                                                                                                                                       format, UVec2(64, 64)));
+       VkMemoryRequirements outImageMemoryReq = getImageMemoryRequirements(vkd, device, *outImage);
+       const vk::VkMemoryAllocateInfo  outAllocationInfo       =
+       {
+               vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+               DE_NULL,
+               outImageMemoryReq.size,
+               chooseMemoryType(outImageMemoryReq.memoryTypeBits),
+       };
+       vk::Move<vk::VkDeviceMemory>    outMemory                       (vk::allocateMemory(vkd, device, &outAllocationInfo));
+       VK_CHECK(vkd.bindImageMemory(device, *outImage, *outMemory, 0));
+
+       Unique<VkCommandBuffer>                 cmdBuffer2                      (allocateCommandBuffer(vkd, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
+       VK_CHECK(vkd.beginCommandBuffer(*cmdBuffer2, &cmdBufferBeginInfo));
+
+       const VkImageMemoryBarrier              importedImageBarrier            =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
+               DE_NULL,                                                                        // const void*                          pNext;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
+               VK_IMAGE_LAYOUT_PREINITIALIZED,         // VkImageLayout                        oldLayout;
+               VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,                   // VkImageLayout                        newLayout;
+               VK_QUEUE_FAMILY_FOREIGN_EXT,                                    // deUint32                                     srcQueueFamilyIndex;
+               context.getUniversalQueueFamilyIndex(),                 // deUint32                                     dstQueueFamilyIndex;
+               *importedSrcImage,                                              // VkImage                                      image;
+               {                                                                                       // VkImageSubresourceRange      subresourceRange;
+                       VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
+                       0u,                                                             // deUint32                             baseMipLevel;
+                       1u,                                                             // deUint32                             mipLevels;
+                       0u,                                                             // deUint32                             baseArraySlice;
+                       1u                                                              // deUint32                             arraySize;
+               }
+       };
+       const VkImageMemoryBarrier              outImageBarrier         =
+       {
+               VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,         // VkStructureType                      sType;
+               DE_NULL,                                                                        // const void*                          pNext;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        srcAccessMask;
+               VK_ACCESS_TRANSFER_WRITE_BIT,                           // VkAccessFlags                        dstAccessMask;
+               VK_IMAGE_LAYOUT_UNDEFINED,              // VkImageLayout                        oldLayout;
+               VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,                   // VkImageLayout                        newLayout;
+               VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     srcQueueFamilyIndex;
+               VK_QUEUE_FAMILY_IGNORED,                                        // deUint32                                     dstQueueFamilyIndex;
+               *outImage,                                              // VkImage                                      image;
+               {                                                                                       // VkImageSubresourceRange      subresourceRange;
+                       VK_IMAGE_ASPECT_COLOR_BIT,      // VkImageAspectFlags   aspectMask;
+                       0u,                                                             // deUint32                             baseMipLevel;
+                       1u,                                                             // deUint32                             mipLevels;
+                       0u,                                                             // deUint32                             baseArraySlice;
+                       1u                                                              // deUint32                             arraySize;
+               }
+       };
+
+       vkd.cmdPipelineBarrier(*cmdBuffer2, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &importedImageBarrier);
+       vkd.cmdPipelineBarrier(*cmdBuffer2, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &outImageBarrier);
+
+       VkImageBlit             imageBlit2
+       {
+               {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
+               {{0,0,0}, {64,64,1}},
+               {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
+               {{0,0,0}, {64,64,1}},
+       };
+       vkd.cmdBlitImage(*cmdBuffer2, *importedSrcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *outImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &imageBlit2, VK_FILTER_NEAREST);
+
+
+       copyImageToBuffer(vkd, *cmdBuffer2, *outImage,
+                                                                               outputBuffer->get(), tcu::IVec2(imageSize.x(), imageSize.y()),
+                                                                               0, VK_IMAGE_LAYOUT_UNDEFINED, 1);
+
+       VK_CHECK(vkd.endCommandBuffer(*cmdBuffer2));
+
+       submitCommandsAndWait(vkd, device, context.getUniversalQueue(), *cmdBuffer2);
+
+
+       tcu::ConstPixelBufferAccess     result  (referenceTextureFormat, imageSize.x(), imageSize.y(), 1, outputBuffer->getAllocation().getHostPtr());
+       const tcu::UVec4 threshold (0u);
+
+       return tcu::intThresholdCompare(context.getTestContext().getLog(), "Compare", "Result comparison", referenceImage, result, threshold, tcu::COMPARE_LOG_RESULT);
+}
+
+tcu::TestStatus exportImportMemoryExplicitModifiersCase (Context& context, const VkFormat format)
+{
+       const InstanceInterface&                                                vki                                     = context.getInstanceInterface();
+       std::vector<VkDrmFormatModifierPropertiesEXT>   drmFormatModifiers      = getDrmFormatModifiers(vki, context.getPhysicalDevice(), format);
+
+       for (deUint32 m = 0; m < drmFormatModifiers.size(); m++)
+       {
+               const VkFormatFeatureFlags                                                      testFeatures            = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
+               if ((drmFormatModifiers[m].drmFormatModifierTilingFeatures & testFeatures) != testFeatures)
+                       continue;
+               if (!exportImportMemoryExplicitModifiersCase(context, format, drmFormatModifiers[m]))
+                       return tcu::TestStatus::fail("Unexpected copy image result");
+       }
+
+       return tcu::TestStatus::pass("OK");
+}
+
 } // anonymous
 
 tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx)
@@ -402,6 +839,15 @@ tcu::TestCaseGroup* createTests (tcu::TestContext& testCtx)
                drmFormatModifiersGroup->addChild(group.release());
        }
 
+       {
+               de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "export_import", "Test exporting/importing images with modifiers"));
+
+               for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
+                       addFunctionCase(group.get(), getFormatCaseName(formats[formatNdx]), "Test exporting/importing images with modifiers", checkExportImportExtensions, exportImportMemoryExplicitModifiersCase, formats[formatNdx]);
+
+               drmFormatModifiersGroup->addChild(group.release());
+       }
+
        return drmFormatModifiersGroup.release();
 }
 

diff --git a/external/vulkancts/mustpass/master/vk-default.txt b/external/vulkancts/mustpass/master/vk-default.txt
index 096a7d0..46d56fb 100644 (file)
--- a/external/vulkancts/mustpass/master/vk-default.txt
+++ b/external/vulkancts/mustpass/master/vk-default.txt
@@ -680549,3 +680549,126 @@ dEQP-VK.drm_format_modifiers.create_list_modifiers.r64g64b64a64_sint
 dEQP-VK.drm_format_modifiers.create_list_modifiers.r64g64b64a64_sfloat
 dEQP-VK.drm_format_modifiers.create_list_modifiers.b10g11r11_ufloat_pack32
 dEQP-VK.drm_format_modifiers.create_list_modifiers.e5b9g9r9_ufloat_pack32
+dEQP-VK.drm_format_modifiers.export_import.r4g4_unorm_pack8
+dEQP-VK.drm_format_modifiers.export_import.r4g4b4a4_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b4g4r4a4_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r5g6b5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b5g6r5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r5g5b5a1_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.b5g5r5a1_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.a1r5g5b5_unorm_pack16
+dEQP-VK.drm_format_modifiers.export_import.r8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8_srgb
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_unorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_snorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_uint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_sint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8_srgb
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_unorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_snorm
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_uint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_sint
+dEQP-VK.drm_format_modifiers.export_import.r8g8b8a8_srgb
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_unorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_snorm
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_uscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_sscaled
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_uint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_sint
+dEQP-VK.drm_format_modifiers.export_import.b8g8r8a8_srgb
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a8b8g8r8_srgb_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2r10g10b10_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_unorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_snorm_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_uscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_sscaled_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_uint_pack32
+dEQP-VK.drm_format_modifiers.export_import.a2b10g10r10_sint_pack32
+dEQP-VK.drm_format_modifiers.export_import.r16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_unorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_snorm
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_uscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sscaled
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_uint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sint
+dEQP-VK.drm_format_modifiers.export_import.r16g16b16a16_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_uint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_sint
+dEQP-VK.drm_format_modifiers.export_import.r32g32b32a32_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_uint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_sint
+dEQP-VK.drm_format_modifiers.export_import.r64g64b64a64_sfloat
+dEQP-VK.drm_format_modifiers.export_import.b10g11r11_ufloat_pack32
+dEQP-VK.drm_format_modifiers.export_import.e5b9g9r9_ufloat_pack32