Fix validation errors in AHB tests

AHB protected memory tests were also removed as the test
tried to use protected memory without creating a device
and queue that would support protected operations.

VK-GL-CTS Issue: 2508

Affects:

dEQP-VK.api.external.memory.android_hardware_buffer.*

Components: Vulkan
Change-Id: I307e7450d06d20b6497f2a529e5724ae0538e5a9

diff --git a/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp
index 30e70d9..37d35bf 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiExternalMemoryTests.cpp
@@ -3750,6 +3750,10 @@ tcu::TestStatus testImageQueries (Context& context, vk::VkExternalMemoryHandleTy
 
                        if (deviceHasDedicated)
                        {
+                               // Memory requirements cannot be queried without binding the image.
+                               if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
+                                       continue;
+
                                const vk::Unique<vk::VkImage>                           image                                           (createExternalImage(*vkd, *device, queueFamilyIndex, externalType, format, 16u, 16u, tiling, createFlag, usageFlag));
                                const vk::VkMemoryDedicatedRequirements         reqs                                            (getMemoryDedicatedRequirements(*vkd, *device, *image));
                                const bool                                                                      propertiesRequiresDedicated     = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
@@ -3795,7 +3799,7 @@ tcu::TestStatus testImageBindExportImportBind (Context&                                   context,
        const deUint32                                                  queueFamilyIndex        (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
        const vk::Unique<vk::VkDevice>                  device                          (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
        const vk::DeviceDriver                                  vkd                                     (vkp, instance, *device);
-       const vk::VkImageUsageFlags                             usage                           = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+       const vk::VkImageUsageFlags                             usage                           = vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT | (config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID ? vk::VK_IMAGE_USAGE_SAMPLED_BIT : 0);
        const vk::VkFormat                                              format                          = vk::VK_FORMAT_R8G8B8A8_UNORM;
        const deUint32                                                  width                           = 64u;
        const deUint32                                                  height                          = 64u;
@@ -3804,7 +3808,7 @@ tcu::TestStatus testImageBindExportImportBind (Context&                                   context,
        checkImageSupport(vki, physicalDevice, config.externalType, 0u, usage, format, tiling, config.dedicated);
 
        const vk::Unique<vk::VkImage>                   imageA                                  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA));
+       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA, config.externalType));
        const deUint32                                                  exportedMemoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
        const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements.size, exportedMemoryTypeIndex, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0));
        NativeHandle                                                    handle;
@@ -3815,9 +3819,10 @@ tcu::TestStatus testImageBindExportImportBind (Context&                                  context,
 
        {
                const vk::Unique<vk::VkImage>                   imageB  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+               const deUint32                                                  idx             = config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID ? ~0u : exportedMemoryTypeIndex;
                const vk::Unique<vk::VkDeviceMemory>    memoryB (config.dedicated
-                                                                                                                ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, exportedMemoryTypeIndex, handle)
-                                                                                                                : importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
+                                                                                                                ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, idx, handle)
+                                                                                                                : importMemory(vkd, *device, requirements, config.externalType, idx, handle));
 
                VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
        }
@@ -3835,7 +3840,7 @@ tcu::TestStatus testImageExportBindImportBind (Context&                                   context,
        const deUint32                                                  queueFamilyIndex        (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
        const vk::Unique<vk::VkDevice>                  device                          (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
        const vk::DeviceDriver                                  vkd                                     (vkp, instance, *device);
-       const vk::VkImageUsageFlags                             usage                           = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+       const vk::VkImageUsageFlags                             usage                           = vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT | (config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID ? vk::VK_IMAGE_USAGE_SAMPLED_BIT : 0);
        const vk::VkFormat                                              format                          = vk::VK_FORMAT_R8G8B8A8_UNORM;
        const deUint32                                                  width                           = 64u;
        const deUint32                                                  height                          = 64u;
@@ -3844,19 +3849,29 @@ tcu::TestStatus testImageExportBindImportBind (Context&                                 context,
        checkImageSupport(vki, physicalDevice, config.externalType, 0u, usage, format, tiling, config.dedicated);
 
        const vk::Unique<vk::VkImage>                   imageA                                  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA));
+       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA, config.externalType));
        const deUint32                                                  exportedMemoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
        const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements.size, exportedMemoryTypeIndex, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0));
        NativeHandle                                                    handle;
 
-       getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
-       VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
+       if (config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID && config.dedicated)
+       {
+               // AHB required the image memory to be bound first.
+               VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
+               getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
+       }
+       else
+       {
+               getMemoryNative(vkd, *device, *memoryA, config.externalType, handle);
+               VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
+       }
 
        {
                const vk::Unique<vk::VkImage>                   imageB  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+               const deUint32                                                  idx             = config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID ? ~0u : exportedMemoryTypeIndex;
                const vk::Unique<vk::VkDeviceMemory>    memoryB (config.dedicated
-                                                                                                                ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, exportedMemoryTypeIndex, handle)
-                                                                                                                : importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
+                                                                                                                ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, idx, handle)
+                                                                                                                : importMemory(vkd, *device, requirements, config.externalType, idx, handle));
 
                VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
        }
@@ -3874,7 +3889,7 @@ tcu::TestStatus testImageExportImportBindBind (Context&                                   context,
        const deUint32                                                  queueFamilyIndex        (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
        const vk::Unique<vk::VkDevice>                  device                          (createTestDevice(context, vkp, instance, vki, physicalDevice, 0u, config.externalType, 0u, queueFamilyIndex, config.dedicated));
        const vk::DeviceDriver                                  vkd                                     (vkp, instance, *device);
-       const vk::VkImageUsageFlags                             usage                           = vk::VK_BUFFER_USAGE_TRANSFER_SRC_BIT|vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+       const vk::VkImageUsageFlags                             usage                           = vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT | vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT | (config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID ? vk::VK_IMAGE_USAGE_SAMPLED_BIT : 0);
        const vk::VkFormat                                              format                          = vk::VK_FORMAT_R8G8B8A8_UNORM;
        const deUint32                                                  width                           = 64u;
        const deUint32                                                  height                          = 64u;
@@ -3882,9 +3897,15 @@ tcu::TestStatus testImageExportImportBindBind (Context&                                  context,
 
        checkImageSupport(vki, physicalDevice, config.externalType, 0u, usage, format, tiling, config.dedicated);
 
+       if (config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID && config.dedicated)
+       {
+               // AHB required the image memory to be bound first, which is not possible in this test.
+               TCU_THROW(NotSupportedError, "Unsupported for Android Hardware Buffer");
+       }
+
        // \note Image is only allocated to get memory requirements
        const vk::Unique<vk::VkImage>                   imageA                                  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
-       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA));
+       const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *imageA, config.externalType));
        const deUint32                                                  exportedMemoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
        const vk::Unique<vk::VkDeviceMemory>    memoryA                                 (allocateExportableMemory(vkd, *device, requirements.size, exportedMemoryTypeIndex, config.externalType, config.dedicated ? *imageA : (vk::VkImage)0));
        NativeHandle                                                    handle;
@@ -3893,9 +3914,10 @@ tcu::TestStatus testImageExportImportBindBind (Context&                                  context,
 
        {
                const vk::Unique<vk::VkImage>                   imageB  (createExternalImage(vkd, *device, queueFamilyIndex, config.externalType, format, width, height, tiling, 0u, usage));
+               const deUint32                                                  idx             = config.externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID ? ~0u : exportedMemoryTypeIndex;
                const vk::Unique<vk::VkDeviceMemory>    memoryB (config.dedicated
-                                                                                                                ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, exportedMemoryTypeIndex, handle)
-                                                                                                                : importMemory(vkd, *device, requirements, config.externalType, exportedMemoryTypeIndex, handle));
+                                                                                                                ? importDedicatedMemory(vkd, *device, *imageB, requirements, config.externalType, idx, handle)
+                                                                                                                : importMemory(vkd, *device, requirements, config.externalType, idx, handle));
 
                VK_CHECK(vkd.bindImageMemory(*device, *imageA, *memoryA, 0u));
                VK_CHECK(vkd.bindImageMemory(*device, *imageB, *memoryB, 0u));
@@ -4059,17 +4081,6 @@ tcu::TestStatus testAndroidHardwareBufferImageFormat  (Context& context, vk::VkF
        TestLog&                                                                          log                             = context.getTestContext().getLog();
        const vk::VkPhysicalDeviceLimits                          limits                          = getPhysicalDeviceProperties(vki, physicalDevice).limits;
 
-       vk::VkPhysicalDeviceProtectedMemoryFeatures             protectedFeatures;
-       protectedFeatures.sType                         = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
-       protectedFeatures.pNext                         = DE_NULL;
-       protectedFeatures.protectedMemory       = VK_FALSE;
-
-       vk::VkPhysicalDeviceFeatures2                                   deviceFeatures;
-       deviceFeatures.sType            = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-       deviceFeatures.pNext            = &protectedFeatures;
-
-       vki.getPhysicalDeviceFeatures2(physicalDevice, &deviceFeatures);
-
        const vk::VkImageUsageFlagBits framebufferUsageFlag = vk::isDepthStencilFormat(format) ? vk::VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
                                                                                                                                                                                   : vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
@@ -4085,7 +4096,6 @@ tcu::TestStatus testAndroidHardwareBufferImageFormat  (Context& context, vk::VkF
        {
                vk::VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
                vk::VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,
-               vk::VK_IMAGE_CREATE_PROTECTED_BIT,
                vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
        };
        const vk::VkImageTiling                                           tilings[]                       =
@@ -4118,9 +4128,6 @@ tcu::TestStatus testAndroidHardwareBufferImageFormat  (Context& context, vk::VkF
                        const size_t    bit     = numOfUsageFlags + createFlagNdx;
                        if ((combo & (one << bit)) == 0)
                                continue;
-                       if (((createFlags[createFlagNdx] & vk::VK_IMAGE_CREATE_PROTECTED_BIT) == vk::VK_IMAGE_CREATE_PROTECTED_BIT ) &&
-                               (protectedFeatures.protectedMemory == VK_FALSE))
-                               continue;
                        createFlag |= createFlags[createFlagNdx];
                        requiredAhbUsage |= ahbApi->vkCreateToAhbUsage(createFlags[createFlagNdx]);
                }
@@ -4216,7 +4223,7 @@ tcu::TestStatus testAndroidHardwareBufferImageFormat  (Context& context, vk::VkF
                        for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(sizes); i++)
                        {
                                const vk::Unique<vk::VkImage>                   image                                   (createExternalImage(vkd, *device, queueFamilyIndex, externalMemoryType, format, sizes[i].width, sizes[i].height, tiling, createFlag, usage));
-                               const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *image));
+                               const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *image, externalMemoryType));
                                const deUint32                                                  exportedMemoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
                                const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vkd, *device, requirements.size, exportedMemoryTypeIndex, externalMemoryType, *image));
                                NativeHandle                                                    handle;
@@ -4237,7 +4244,7 @@ tcu::TestStatus testAndroidHardwareBufferImageFormat  (Context& context, vk::VkF
                        if (properties.imageFormatProperties.maxMipLevels > 1u)
                        {
                                const vk::Unique<vk::VkImage>                   image                                   (createExternalImage(vkd, *device, queueFamilyIndex, externalMemoryType, format, 64u, 64u, tiling, createFlag, usage, properties.imageFormatProperties.maxMipLevels));
-                               const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *image));
+                               const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *image, externalMemoryType));
                                const deUint32                                                  exportedMemoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
                                const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vkd, *device, requirements.size, exportedMemoryTypeIndex, externalMemoryType, *image));
                                NativeHandle                                                    handle;
@@ -4255,7 +4262,7 @@ tcu::TestStatus testAndroidHardwareBufferImageFormat  (Context& context, vk::VkF
                        if ((properties.imageFormatProperties.maxArrayLayers > 1u) && enableMaxLayerTest)
                        {
                                const vk::Unique<vk::VkImage>                   image                                   (createExternalImage(vkd, *device, queueFamilyIndex, externalMemoryType, format, 64u, 64u, tiling, createFlag, usage, 1u, properties.imageFormatProperties.maxArrayLayers));
-                               const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *image));
+                               const vk::VkMemoryRequirements                  requirements                    (getImageMemoryRequirements(vkd, *device, *image, externalMemoryType));
                                const deUint32                                                  exportedMemoryTypeIndex (chooseMemoryType(requirements.memoryTypeBits));
                                const vk::Unique<vk::VkDeviceMemory>    memory                                  (allocateExportableMemory(vkd, *device, requirements.size, exportedMemoryTypeIndex, externalMemoryType, *image));
                                NativeHandle                                                    handle;

diff --git a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp
index 9559729..9bdb8be 100644 (file)
--- a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp
+++ b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.cpp
@@ -891,7 +891,8 @@ vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface&
 
 deUint32 chooseMemoryType(deUint32 bits)
 {
-       DE_ASSERT(bits != 0);
+       if (bits == 0)
+               return 0;
 
        for (deUint32 memoryTypeIndex = 0; (1u << memoryTypeIndex) <= bits; memoryTypeIndex++)
        {
@@ -918,6 +919,21 @@ deUint32 chooseHostVisibleMemoryType (deUint32 bits, const vk::VkPhysicalDeviceM
        return -1;
 }
 
+vk::VkMemoryRequirements getImageMemoryRequirements (const vk::DeviceInterface& vkd,
+                                                                                                        vk::VkDevice device,
+                                                                                                        vk::VkImage image,
+                                                                                                        vk::VkExternalMemoryHandleTypeFlagBits externalType)
+{
+       if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
+       {
+               return { 0u, 0u, 0u };
+       }
+       else
+       {
+               return vk::getImageMemoryRequirements(vkd, device, image);
+       }
+}
+
 vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface&                                      vkd,
                                                                                                           vk::VkDevice                                                                 device,
                                                                                                           vk::VkDeviceSize                                                             allocationSize,
@@ -1068,6 +1084,16 @@ static vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface&
                ahbApi->describe(handle.getAndroidHardwareBuffer(), DE_NULL, DE_NULL, DE_NULL, &ahbFormat, DE_NULL, DE_NULL);
                DE_ASSERT(ahbApi->ahbFormatIsBlob(ahbFormat) || image != 0);
 
+               vk::VkAndroidHardwareBufferPropertiesANDROID ahbProperties =
+               {
+                       vk::VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+                       DE_NULL,
+                       0u,
+                       0u
+               };
+
+               vkd.getAndroidHardwareBufferPropertiesANDROID(device, handle.getAndroidHardwareBuffer(), &ahbProperties);
+
                vk::VkImportAndroidHardwareBufferInfoANDROID    importInfo =
                {
                        vk::VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
@@ -1085,8 +1111,8 @@ static vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface&
                {
                        vk::VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
                        (isDedicated ? (const void*)&dedicatedInfo : (const void*)&importInfo),
-                       requirements.size,
-                       (memoryTypeIndex == ~0U) ? chooseMemoryType(requirements.memoryTypeBits)  : memoryTypeIndex
+                       ahbProperties.allocationSize,
+                       (memoryTypeIndex == ~0U) ? chooseMemoryType(ahbProperties.memoryTypeBits)  : memoryTypeIndex
                };
                vk::Move<vk::VkDeviceMemory> memory (vk::allocateMemory(vkd, device, &info));
 
@@ -1202,6 +1228,9 @@ vk::Move<vk::VkImage> createExternalImage (const vk::DeviceInterface&                                     vkd,
                                                                                   deUint32                                                                             mipLevels,
                                                                                   deUint32                                                                             arrayLayers)
 {
+       if (createFlags & vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT && arrayLayers < 6u)
+               arrayLayers = 6u;
+
        const vk::VkExternalMemoryImageCreateInfo               externalCreateInfo      =
        {
                vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,

diff --git a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp
index ab1654c..1e7a7b6 100644 (file)
--- a/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp
+++ b/external/vulkancts/modules/vulkan/util/vktExternalMemoryUtil.hpp
@@ -277,6 +277,11 @@ deUint32                                           chooseMemoryType                                        (deUint32                                                                       bits);
 deUint32                                               chooseHostVisibleMemoryType                     (deUint32                                                                       bits,
                                                                                                                                         const vk::VkPhysicalDeviceMemoryProperties     properties);
 
+vk::VkMemoryRequirements               getImageMemoryRequirements                      (const vk::DeviceInterface& vkd,
+                                                                                                                                        vk::VkDevice device,
+                                                                                                                                        vk::VkImage image,
+                                                                                                                                        vk::VkExternalMemoryHandleTypeFlagBits externalType);
+
 // If buffer is not null use dedicated allocation
 vk::Move<vk::VkDeviceMemory>   allocateExportableMemory                        (const vk::DeviceInterface&                                     vkd,
                                                                                                                                         vk::VkDevice                                                           device,