vulkan/tests/libvulkan_test.cpp - platform/frameworks/native - Git at Google


            
            /*

            
             * Copyright (C) 2011 The Android Open Source Project

            
             *

            
             * Licensed under the Apache License, Version 2.0 (the "License");

            
             * you may not use this file except in compliance with the License.

            
             * You may obtain a copy of the License at

            
             *

            
             *      http://www.apache.org/licenses/LICENSE-2.0

            
             *

            
             * Unless required by applicable law or agreed to in writing, software

            
             * distributed under the License is distributed on an "AS IS" BASIS,

            
             * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

            
             * See the License for the specific language governing permissions and

            
             * limitations under the License.

            
             */


            #include <android/log.h>

            
            #include <driver.h>

            
            #include <gmock/gmock.h>

            
            #include <gtest/gtest.h>

            
            #include <media/NdkImageReader.h>

            
            #include <vulkan/vulkan.h>


            #define LOGI(...) \

            
                __android_log_print(ANDROID_LOG_INFO, "libvulkan_test", __VA_ARGS__)

            
            #define LOGE(...) \

            
                __android_log_print(ANDROID_LOG_ERROR, "libvulkan_test", __VA_ARGS__)


            #define VK_CHECK(result) ASSERT_EQ(VK_SUCCESS, result)


            namespace android {


            namespace libvulkantest {


            class AImageReaderVulkanSwapchainTest : public ::testing::Test {

            
               public:

            
                AImageReaderVulkanSwapchainTest() {}


                AImageReader* mReader = nullptr;

            
                ANativeWindow* mWindow = nullptr;

            
                VkInstance mVkInstance = VK_NULL_HANDLE;

            
                VkPhysicalDevice mPhysicalDev = VK_NULL_HANDLE;

            
                VkDevice mDevice = VK_NULL_HANDLE;

            
                VkSurfaceKHR mSurface = VK_NULL_HANDLE;

            
                VkQueue mPresentQueue = VK_NULL_HANDLE;

            
                uint32_t mPresentQueueFamily = UINT32_MAX;

            
                VkSwapchainKHR mSwapchain = VK_NULL_HANDLE;


                void SetUp() override {}


                void TearDown() override {}


                // ------------------------------------------------------

            
                // Helper methods

            
                // ------------------------------------------------------


                void createVulkanInstance(std::vector<const char*>& layers) {

            
                    const char* extensions[] = {

            
                        VK_KHR_SURFACE_EXTENSION_NAME,

            
                        VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,

            
                        VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME,

            
                        VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,

            
                    };


                    VkApplicationInfo appInfo{};

            
                    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

            
                    appInfo.pApplicationName = "AImageReader Vulkan Swapchain Test";

            
                    appInfo.applicationVersion = 1;

            
                    appInfo.pEngineName = "TestEngine";

            
                    appInfo.engineVersion = 1;

            
                    appInfo.apiVersion = VK_API_VERSION_1_0;


                    VkInstanceCreateInfo instInfo{};

            
                    instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

            
                    instInfo.pApplicationInfo = &appInfo;

            
                    instInfo.enabledExtensionCount =

            
                        sizeof(extensions) / sizeof(extensions[0]);

            
                    instInfo.ppEnabledExtensionNames = extensions;

            
                    instInfo.enabledLayerCount = layers.size();

            
                    instInfo.ppEnabledLayerNames = layers.data();

            
                    VkResult res = vkCreateInstance(&instInfo, nullptr, &mVkInstance);

            
                    VK_CHECK(res);

            
                    LOGE("Vulkan instance created");

            
                }


                void createAImageReader(int width, int height, int format, int maxImages) {

            
                    media_status_t status =

            
                        AImageReader_new(width, height, format, maxImages, &mReader);

            
                    ASSERT_EQ(AMEDIA_OK, status) << "Failed to create AImageReader";

            
                    ASSERT_NE(nullptr, mReader) << "AImageReader is null";


                    // Optionally set a listener

            
                    AImageReader_ImageListener listener{};

            
                    listener.context = this;

            
                    listener.onImageAvailable =

            
                        &AImageReaderVulkanSwapchainTest::onImageAvailable;

            
                    AImageReader_setImageListener(mReader, &listener);


                    LOGI("AImageReader created with %dx%d, format=%d", width, height,

            
                         format);

            
                }


                void getANativeWindowFromReader() {

            
                    ASSERT_NE(nullptr, mReader);


                    media_status_t status = AImageReader_getWindow(mReader, &mWindow);

            
                    ASSERT_EQ(AMEDIA_OK, status)

            
                        << "Failed to get ANativeWindow from AImageReader";

            
                    ASSERT_NE(nullptr, mWindow) << "ANativeWindow is null";

            
                    LOGI("ANativeWindow obtained from AImageReader");

            
                }


                void createVulkanSurface() {

            
                    ASSERT_NE((VkInstance)VK_NULL_HANDLE, mVkInstance);

            
                    ASSERT_NE((ANativeWindow*)nullptr, mWindow);


                    VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{};

            
                    surfaceCreateInfo.sType =

            
                        VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;

            
                    surfaceCreateInfo.window = mWindow;


                    VkResult res = vkCreateAndroidSurfaceKHR(

            
                        mVkInstance, &surfaceCreateInfo, nullptr, &mSurface);

            
                    VK_CHECK(res);

            
                    LOGI("Vulkan surface created from ANativeWindow");

            
                }


                void pickPhysicalDeviceAndQueueFamily() {

            
                    ASSERT_NE((VkInstance)VK_NULL_HANDLE, mVkInstance);


                    uint32_t deviceCount = 0;

            
                    vkEnumeratePhysicalDevices(mVkInstance, &deviceCount, nullptr);

            
                    ASSERT_GT(deviceCount, 0U) << "No Vulkan physical devices found!";


                    std::vector<VkPhysicalDevice> devices(deviceCount);

            
                    vkEnumeratePhysicalDevices(mVkInstance, &deviceCount, devices.data());


                    for (auto& dev : devices) {

            
                        uint32_t queueFamilyCount = 0;

            
                        vkGetPhysicalDeviceQueueFamilyProperties(dev, &queueFamilyCount,

            
                                                                 nullptr);

            
                        std::vector<VkQueueFamilyProperties> queueProps(queueFamilyCount);

            
                        vkGetPhysicalDeviceQueueFamilyProperties(dev, &queueFamilyCount,

            
                                                                 queueProps.data());


                        for (uint32_t i = 0; i < queueFamilyCount; i++) {

            
                            VkBool32 support = VK_FALSE;

            
                            vkGetPhysicalDeviceSurfaceSupportKHR(dev, i, mSurface,

            
                                                                 &support);

            
                            if (support == VK_TRUE) {

            
                                // Found a queue family that can present

            
                                mPhysicalDev = dev;

            
                                mPresentQueueFamily = i;


                                LOGI(

            
                                    "Physical device found with queue family %u supporting "

            
                                    "present",

            
                                    i);

            
                                return;

            
                            }

            
                        }

            
                    }


                    FAIL()

            
                        << "No physical device found that supports present to the surface!";

            
                }


                void createDeviceAndGetQueue(std::vector<const char*>& layers,

            
                                             std::vector<const char*> inExtensions = {}) {

            
                    ASSERT_NE((void*)VK_NULL_HANDLE, mPhysicalDev);

            
                    ASSERT_NE(UINT32_MAX, mPresentQueueFamily);


                    float queuePriority = 1.0f;

            
                    VkDeviceQueueCreateInfo queueInfo{};

            
                    queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;

            
                    queueInfo.queueFamilyIndex = mPresentQueueFamily;

            
                    queueInfo.queueCount = 1;

            
                    queueInfo.pQueuePriorities = &queuePriority;


                    VkDeviceCreateInfo deviceInfo{};

            
                    deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

            
                    deviceInfo.queueCreateInfoCount = 1;

            
                    deviceInfo.pQueueCreateInfos = &queueInfo;

            
                    deviceInfo.enabledLayerCount = layers.size();

            
                    deviceInfo.ppEnabledLayerNames = layers.data();


                    std::vector<const char*> extensions = {

            
                        VK_KHR_SWAPCHAIN_EXTENSION_NAME,

            
                    };

            
                    for (auto extension : inExtensions) {

            
                        extensions.push_back(extension);

            
                    }

            
                    deviceInfo.enabledExtensionCount = extensions.size();

            
                    deviceInfo.ppEnabledExtensionNames = extensions.data();


                    VkResult res =

            
                        vkCreateDevice(mPhysicalDev, &deviceInfo, nullptr, &mDevice);

            
                    VK_CHECK(res);

            
                    LOGI("Logical device created");


                    vkGetDeviceQueue(mDevice, mPresentQueueFamily, 0, &mPresentQueue);

            
                    ASSERT_NE((VkQueue)VK_NULL_HANDLE, mPresentQueue);

            
                    LOGI("Acquired present-capable queue");

            
                }


                void createSwapchain() {

            
                    ASSERT_NE((VkDevice)VK_NULL_HANDLE, mDevice);

            
                    ASSERT_NE((VkSurfaceKHR)VK_NULL_HANDLE, mSurface);


                    VkSurfaceCapabilitiesKHR surfaceCaps{};

            
                    VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(

            
                        mPhysicalDev, mSurface, &surfaceCaps));


                    uint32_t formatCount = 0;

            
                    vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface,

            
                                                         &formatCount, nullptr);

            
                    ASSERT_GT(formatCount, 0U);

            
                    std::vector<VkSurfaceFormatKHR> formats(formatCount);

            
                    vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface,

            
                                                         &formatCount, formats.data());


                    VkSurfaceFormatKHR chosenFormat = formats[0];

            
                    LOGI("Chosen surface format: %d", chosenFormat.format);


                    uint32_t presentModeCount = 0;

            
                    vkGetPhysicalDeviceSurfacePresentModesKHR(mPhysicalDev, mSurface,

            
                                                              &presentModeCount, nullptr);

            
                    ASSERT_GT(presentModeCount, 0U);

            
                    std::vector<VkPresentModeKHR> presentModes(presentModeCount);

            
                    vkGetPhysicalDeviceSurfacePresentModesKHR(

            
                        mPhysicalDev, mSurface, &presentModeCount, presentModes.data());


                    VkPresentModeKHR chosenPresentMode = VK_PRESENT_MODE_FIFO_KHR;

            
                    for (auto mode : presentModes) {

            
                        if (mode == VK_PRESENT_MODE_FIFO_KHR) {

            
                            chosenPresentMode = mode;

            
                            break;

            
                        }

            
                    }

            
                    LOGI("Chosen present mode: %d", chosenPresentMode);


                    VkExtent2D swapchainExtent{};

            
                    if (surfaceCaps.currentExtent.width == 0xFFFFFFFF) {

            
                        swapchainExtent.width = 640;   // fallback

            
                        swapchainExtent.height = 480;  // fallback

            
                    } else {

            
                        swapchainExtent = surfaceCaps.currentExtent;

            
                    }

            
                    LOGI("Swapchain extent: %d x %d", swapchainExtent.width,

            
                         swapchainExtent.height);


                    uint32_t desiredImageCount = surfaceCaps.minImageCount + 1;

            
                    if (surfaceCaps.maxImageCount > 0 &&

            
                        desiredImageCount > surfaceCaps.maxImageCount) {

            
                        desiredImageCount = surfaceCaps.maxImageCount;

            
                    }


                    VkSwapchainCreateInfoKHR swapchainInfo{};

            
                    swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;

            
                    swapchainInfo.surface = mSurface;

            
                    swapchainInfo.minImageCount = desiredImageCount;

            
                    swapchainInfo.imageFormat = chosenFormat.format;

            
                    swapchainInfo.imageColorSpace = chosenFormat.colorSpace;

            
                    swapchainInfo.imageExtent = swapchainExtent;

            
                    swapchainInfo.imageArrayLayers = 1;

            
                    swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |

            
                                               VK_IMAGE_USAGE_TRANSFER_SRC_BIT;

            
                    swapchainInfo.preTransform = surfaceCaps.currentTransform;

            
                    swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;

            
                    swapchainInfo.presentMode = chosenPresentMode;

            
                    swapchainInfo.clipped = VK_TRUE;

            
                    swapchainInfo.oldSwapchain = VK_NULL_HANDLE;


                    uint32_t queueFamilyIndices[] = {mPresentQueueFamily};

            
                    swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;

            
                    swapchainInfo.queueFamilyIndexCount = 1;

            
                    swapchainInfo.pQueueFamilyIndices = queueFamilyIndices;


                    VkResult res =

            
                        vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain);

            
                    if (res == VK_SUCCESS) {

            
                        LOGI("Swapchain created successfully");


                        uint32_t swapchainImageCount = 0;

            
                        vkGetSwapchainImagesKHR(mDevice, mSwapchain, &swapchainImageCount,

            
                                                nullptr);

            
                        std::vector<VkImage> swapchainImages(swapchainImageCount);

            
                        vkGetSwapchainImagesKHR(mDevice, mSwapchain, &swapchainImageCount,

            
                                                swapchainImages.data());


                        LOGI("Swapchain has %u images", swapchainImageCount);

            
                    } else {

            
                        LOGI("Swapchain creation failed");

            
                    }

            
                }


                // Image available callback (AImageReader)

            
                static void onImageAvailable(void*, AImageReader* reader) {

            
                    LOGI("onImageAvailable callback triggered");

            
                    AImage* image = nullptr;

            
                    media_status_t status = AImageReader_acquireLatestImage(reader, &image);

            
                    if (status != AMEDIA_OK || !image) {

            
                        LOGE("Failed to acquire latest image");

            
                        return;

            
                    }

            
                    AImage_delete(image);

            
                    LOGI("Released acquired image");

            
                }


                void cleanUpSwapchainForTest() {

            
                    if (mSwapchain != VK_NULL_HANDLE) {

            
                        vkDestroySwapchainKHR(mDevice, mSwapchain, nullptr);

            
                        mSwapchain = VK_NULL_HANDLE;

            
                    }

            
                    if (mDevice != VK_NULL_HANDLE) {

            
                        vkDestroyDevice(mDevice, nullptr);

            
                        mDevice = VK_NULL_HANDLE;

            
                    }

            
                    if (mSurface != VK_NULL_HANDLE) {

            
                        vkDestroySurfaceKHR(mVkInstance, mSurface, nullptr);

            
                        mSurface = VK_NULL_HANDLE;

            
                    }

            
                    if (mVkInstance != VK_NULL_HANDLE) {

            
                        vkDestroyInstance(mVkInstance, nullptr);

            
                        mVkInstance = VK_NULL_HANDLE;

            
                    }

            
                    if (mReader) {

            
                        // AImageReader_delete(mReader);

            
                        mReader = nullptr;

            
                    }

            
                    // Note: The ANativeWindow from AImageReader is implicitly

            
                    // managed by the reader, so we don't explicitly delete it.

            
                    mWindow = nullptr;

            
                }


                void buildSwapchianForTest(std::vector<const char*>& instanceLayers,

            
                                           std::vector<const char*>& deviceLayers) {

            
                    createVulkanInstance(instanceLayers);


                    // the "atest libvulkan_test" command will execute this test as a binary

            
                    // (not apk) on the device. Consequently we can't render to the screen

            
                    // and need to work around this by using AImageReader*

            
                    createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);

            
                    getANativeWindowFromReader();

            
                    createVulkanSurface();

            
                    pickPhysicalDeviceAndQueueFamily();


                    createDeviceAndGetQueue(deviceLayers);

            
                    createSwapchain();

            
                }

            
            };


            TEST_F(AImageReaderVulkanSwapchainTest, TestHelperMethods) {

            
                // Verify that the basic plumbing/helper functions of these tests is

            
                // working. This doesn't directly test any of the layer code. It only

            
                // verifies that we can successfully create a swapchain with an AImageReader


                std::vector<const char*> instanceLayers;

            
                std::vector<const char*> deviceLayers;

            
                buildSwapchianForTest(deviceLayers, instanceLayers);


                ASSERT_NE(mVkInstance, (VkInstance)VK_NULL_HANDLE);

            
                ASSERT_NE(mPhysicalDev, (VkPhysicalDevice)VK_NULL_HANDLE);

            
                ASSERT_NE(mDevice, (VkDevice)VK_NULL_HANDLE);

            
                ASSERT_NE(mSurface, (VkSurfaceKHR)VK_NULL_HANDLE);

            
                ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE);

            
                cleanUpSwapchainForTest();

            
            }


            // Passing state in these tests requires global state. Wrap each test in an

            
            // anonymous namespace to prevent conflicting names.

            
            namespace {


            VKAPI_ATTR VkResult VKAPI_CALL hookedGetPhysicalDeviceImageFormatProperties2KHR(

            
                VkPhysicalDevice,

            
                const VkPhysicalDeviceImageFormatInfo2*,

            
                VkImageFormatProperties2*) {

            
                return VK_ERROR_SURFACE_LOST_KHR;

            
            }


            static PFN_vkGetSwapchainGrallocUsage2ANDROID

            
                pfnNextGetSwapchainGrallocUsage2ANDROID = nullptr;


            static bool g_grallocCalled = false;


            VKAPI_ATTR VkResult VKAPI_CALL hookGetSwapchainGrallocUsage2ANDROID(

            
                VkDevice device,

            
                VkFormat format,

            
                VkImageUsageFlags imageUsage,

            
                VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,

            
                uint64_t* grallocConsumerUsage,

            
                uint64_t* grallocProducerUsage) {

            
                g_grallocCalled = true;

            
                if (pfnNextGetSwapchainGrallocUsage2ANDROID) {

            
                    return pfnNextGetSwapchainGrallocUsage2ANDROID(

            
                        device, format, imageUsage, swapchainImageUsage,

            
                        grallocConsumerUsage, grallocProducerUsage);

            
                }


                return VK_ERROR_INITIALIZATION_FAILED;

            
            }


            TEST_F(AImageReaderVulkanSwapchainTest, getProducerUsageFallbackTest1) {

            
                // BUG: 379230826

            
                // Verify that getProducerUsage falls back to

            
                // GetSwapchainGrallocUsage*ANDROID if GPDIFP2 fails

            
                std::vector<const char*> instanceLayers = {};

            
                std::vector<const char*> deviceLayers = {};

            
                createVulkanInstance(instanceLayers);


                createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);

            
                getANativeWindowFromReader();

            
                createVulkanSurface();

            
                pickPhysicalDeviceAndQueueFamily();


                createDeviceAndGetQueue(deviceLayers);

            
                auto& pdev = vulkan::driver::GetData(mDevice).driver_physical_device;

            
                auto& pdevDispatchTable = vulkan::driver::GetData(pdev).driver;

            
                auto& deviceDispatchTable = vulkan::driver::GetData(mDevice).driver;


                ASSERT_NE(deviceDispatchTable.GetSwapchainGrallocUsage2ANDROID, nullptr);


                pdevDispatchTable.GetPhysicalDeviceImageFormatProperties2 =

            
                    hookedGetPhysicalDeviceImageFormatProperties2KHR;

            
                deviceDispatchTable.GetSwapchainGrallocUsage2ANDROID =

            
                    hookGetSwapchainGrallocUsage2ANDROID;


                ASSERT_FALSE(g_grallocCalled);


                createSwapchain();


                ASSERT_TRUE(g_grallocCalled);


                ASSERT_NE(mVkInstance, (VkInstance)VK_NULL_HANDLE);

            
                ASSERT_NE(mPhysicalDev, (VkPhysicalDevice)VK_NULL_HANDLE);

            
                ASSERT_NE(mDevice, (VkDevice)VK_NULL_HANDLE);

            
                ASSERT_NE(mSurface, (VkSurfaceKHR)VK_NULL_HANDLE);

            
                cleanUpSwapchainForTest();

            
            }


            }  // namespace


            // Passing state in these tests requires global state. Wrap each test in an

            
            // anonymous namespace to prevent conflicting names.

            
            namespace {


            static bool g_returnNotSupportedOnce = true;


            VKAPI_ATTR VkResult VKAPI_CALL

            
            Hook_GetPhysicalDeviceImageFormatProperties2_NotSupportedOnce(

            
                VkPhysicalDevice /*physicalDevice*/,

            
                const VkPhysicalDeviceImageFormatInfo2* /*pImageFormatInfo*/,

            
                VkImageFormatProperties2* /*pImageFormatProperties*/) {

            
                if (g_returnNotSupportedOnce) {

            
                    g_returnNotSupportedOnce = false;

            
                    return VK_ERROR_FORMAT_NOT_SUPPORTED;

            
                }

            
                return VK_SUCCESS;

            
            }


            TEST_F(AImageReaderVulkanSwapchainTest, SurfaceFormats2KHR_IgnoreNotSupported) {

            
                // BUG: 357903074

            
                // Verify that vkGetPhysicalDeviceSurfaceFormats2KHR properly

            
                // ignores VK_ERROR_FORMAT_NOT_SUPPORTED and continues enumerating formats.

            
                std::vector<const char*> instanceLayers;

            
                createVulkanInstance(instanceLayers);

            
                createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);

            
                getANativeWindowFromReader();

            
                createVulkanSurface();

            
                pickPhysicalDeviceAndQueueFamily();


                auto& pdevDispatchTable = vulkan::driver::GetData(mPhysicalDev).driver;

            
                pdevDispatchTable.GetPhysicalDeviceImageFormatProperties2 =

            
                    Hook_GetPhysicalDeviceImageFormatProperties2_NotSupportedOnce;


                PFN_vkGetPhysicalDeviceSurfaceFormats2KHR

            
                    pfnGetPhysicalDeviceSurfaceFormats2KHR =

            
                        reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormats2KHR>(

            
                            vkGetInstanceProcAddr(mVkInstance,

            
                                                  "vkGetPhysicalDeviceSurfaceFormats2KHR"));

            
                ASSERT_NE(nullptr, pfnGetPhysicalDeviceSurfaceFormats2KHR)

            
                    << "Could not get pointer to vkGetPhysicalDeviceSurfaceFormats2KHR";


                VkPhysicalDeviceSurfaceInfo2KHR surfaceInfo2{};

            
                surfaceInfo2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;

            
                surfaceInfo2.pNext = nullptr;

            
                surfaceInfo2.surface = mSurface;


                uint32_t formatCount = 0;

            
                VkResult res = pfnGetPhysicalDeviceSurfaceFormats2KHR(

            
                    mPhysicalDev, &surfaceInfo2, &formatCount, nullptr);


                // If the loader never tries a second format, it might fail or 0-out the

            
                // formatCount. The patch ensures it continues to the next format rather

            
                // than bailing out on the first NOT_SUPPORTED.

            
                ASSERT_EQ(VK_SUCCESS, res)

            
                    << "vkGetPhysicalDeviceSurfaceFormats2KHR failed unexpectedly";

            
                ASSERT_GT(formatCount, 0U)

            
                    << "No surface formats found; the loader may have bailed early.";


                std::vector<VkSurfaceFormat2KHR> formats(formatCount);

            
                for (auto& f : formats) {

            
                    f.sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;

            
                    f.pNext = nullptr;

            
                }

            
                res = pfnGetPhysicalDeviceSurfaceFormats2KHR(mPhysicalDev, &surfaceInfo2,

            
                                                             &formatCount, formats.data());

            
                ASSERT_EQ(VK_SUCCESS, res) << "Failed to retrieve surface formats";


                LOGI(

            
                    "SurfaceFormats2KHR_IgnoreNotSupported test: found %u formats after "

            
                    "ignoring NOT_SUPPORTED",

            
                    formatCount);


                cleanUpSwapchainForTest();

            
            }


            }  // namespace


            namespace {


            TEST_F(AImageReaderVulkanSwapchainTest, MutableFormatSwapchainTest) {

            
                // Test swapchain with mutable format extension

            
                std::vector<const char*> instanceLayers;

            
                std::vector<const char*> deviceLayers;

            
                std::vector<const char*> deviceExtensions = {

            
                    VK_KHR_SWAPCHAIN_EXTENSION_NAME,

            
                    VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME,

            
                    VK_KHR_MAINTENANCE2_EXTENSION_NAME,

            
                    VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME};


                createVulkanInstance(instanceLayers);

            
                createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);

            
                getANativeWindowFromReader();

            
                createVulkanSurface();

            
                pickPhysicalDeviceAndQueueFamily();

            
                createDeviceAndGetQueue(deviceLayers, deviceExtensions);


                ASSERT_NE((VkDevice)VK_NULL_HANDLE, mDevice);

            
                ASSERT_NE((VkSurfaceKHR)VK_NULL_HANDLE, mSurface);


                VkSurfaceCapabilitiesKHR surfaceCaps{};

            
                VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface,

            
                                                                   &surfaceCaps));


                uint32_t formatCount = 0;

            
                vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface, &formatCount,

            
                                                     nullptr);

            
                ASSERT_GT(formatCount, 0U);

            
                std::vector<VkSurfaceFormatKHR> formats(formatCount);

            
                vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface, &formatCount,

            
                                                     formats.data());


                VkFormat viewFormats[2] = {formats[0].format, formats[0].format};

            
                if (formatCount > 1) {

            
                    viewFormats[1] = formats[1].format;

            
                }


                VkImageFormatListCreateInfoKHR formatList{};

            
                formatList.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR;

            
                formatList.viewFormatCount = 2;

            
                formatList.pViewFormats = viewFormats;


                VkSwapchainCreateInfoKHR swapchainInfo{};

            
                swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;

            
                swapchainInfo.pNext = &formatList;

            
                swapchainInfo.surface = mSurface;

            
                swapchainInfo.minImageCount = surfaceCaps.minImageCount + 1;

            
                swapchainInfo.imageFormat = formats[0].format;

            
                swapchainInfo.imageColorSpace = formats[0].colorSpace;

            
                swapchainInfo.imageExtent = surfaceCaps.currentExtent;

            
                swapchainInfo.imageArrayLayers = 1;

            
                swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;

            
                swapchainInfo.preTransform = surfaceCaps.currentTransform;

            
                swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;

            
                swapchainInfo.presentMode = VK_PRESENT_MODE_FIFO_KHR;

            
                swapchainInfo.clipped = VK_TRUE;


                swapchainInfo.flags = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR;


                uint32_t queueFamilyIndices[] = {mPresentQueueFamily};

            
                swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;

            
                swapchainInfo.queueFamilyIndexCount = 1;

            
                swapchainInfo.pQueueFamilyIndices = queueFamilyIndices;


                VkResult res =

            
                    vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain);

            
                if (res == VK_SUCCESS) {

            
                    LOGI("Mutable format swapchain created successfully");


                    uint32_t imageCount = 0;

            
                    vkGetSwapchainImagesKHR(mDevice, mSwapchain, &imageCount, nullptr);

            
                    ASSERT_GT(imageCount, 0U);

            
                } else {

            
                    LOGI(

            
                        "Mutable format swapchain creation failed (extension may not be "

            
                        "supported)");

            
                }


                cleanUpSwapchainForTest();

            
            }


            }  // namespace


            }  // namespace libvulkantest


            }  // namespace android
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <android/log.h>
	#include <driver.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <media/NdkImageReader.h>
	#include <vulkan/vulkan.h>

	#define LOGI(...) \
	__android_log_print(ANDROID_LOG_INFO, "libvulkan_test", __VA_ARGS__)
	#define LOGE(...) \
	__android_log_print(ANDROID_LOG_ERROR, "libvulkan_test", __VA_ARGS__)

	#define VK_CHECK(result) ASSERT_EQ(VK_SUCCESS, result)

	namespace android {

	namespace libvulkantest {

	class AImageReaderVulkanSwapchainTest : public ::testing::Test {
	public:
	AImageReaderVulkanSwapchainTest() {}

	AImageReader* mReader = nullptr;
	ANativeWindow* mWindow = nullptr;
	VkInstance mVkInstance = VK_NULL_HANDLE;
	VkPhysicalDevice mPhysicalDev = VK_NULL_HANDLE;
	VkDevice mDevice = VK_NULL_HANDLE;
	VkSurfaceKHR mSurface = VK_NULL_HANDLE;
	VkQueue mPresentQueue = VK_NULL_HANDLE;
	uint32_t mPresentQueueFamily = UINT32_MAX;
	VkSwapchainKHR mSwapchain = VK_NULL_HANDLE;

	void SetUp() override {}

	void TearDown() override {}

	// ------------------------------------------------------
	// Helper methods
	// ------------------------------------------------------

	void createVulkanInstance(std::vector<const char*>& layers) {
	const char* extensions[] = {
	VK_KHR_SURFACE_EXTENSION_NAME,
	VK_KHR_ANDROID_SURFACE_EXTENSION_NAME,
	VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME,
	VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
	};

	VkApplicationInfo appInfo{};
	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	appInfo.pApplicationName = "AImageReader Vulkan Swapchain Test";
	appInfo.applicationVersion = 1;
	appInfo.pEngineName = "TestEngine";
	appInfo.engineVersion = 1;
	appInfo.apiVersion = VK_API_VERSION_1_0;

	VkInstanceCreateInfo instInfo{};
	instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	instInfo.pApplicationInfo = &appInfo;
	instInfo.enabledExtensionCount =
	sizeof(extensions) / sizeof(extensions[0]);
	instInfo.ppEnabledExtensionNames = extensions;
	instInfo.enabledLayerCount = layers.size();
	instInfo.ppEnabledLayerNames = layers.data();
	VkResult res = vkCreateInstance(&instInfo, nullptr, &mVkInstance);
	VK_CHECK(res);
	LOGE("Vulkan instance created");
	}

	void createAImageReader(int width, int height, int format, int maxImages) {
	media_status_t status =
	AImageReader_new(width, height, format, maxImages, &mReader);
	ASSERT_EQ(AMEDIA_OK, status) << "Failed to create AImageReader";
	ASSERT_NE(nullptr, mReader) << "AImageReader is null";

	// Optionally set a listener
	AImageReader_ImageListener listener{};
	listener.context = this;
	listener.onImageAvailable =
	&AImageReaderVulkanSwapchainTest::onImageAvailable;
	AImageReader_setImageListener(mReader, &listener);

	LOGI("AImageReader created with %dx%d, format=%d", width, height,
	format);
	}

	void getANativeWindowFromReader() {
	ASSERT_NE(nullptr, mReader);

	media_status_t status = AImageReader_getWindow(mReader, &mWindow);
	ASSERT_EQ(AMEDIA_OK, status)
	<< "Failed to get ANativeWindow from AImageReader";
	ASSERT_NE(nullptr, mWindow) << "ANativeWindow is null";
	LOGI("ANativeWindow obtained from AImageReader");
	}

	void createVulkanSurface() {
	ASSERT_NE((VkInstance)VK_NULL_HANDLE, mVkInstance);
	ASSERT_NE((ANativeWindow*)nullptr, mWindow);

	VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{};
	surfaceCreateInfo.sType =
	VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
	surfaceCreateInfo.window = mWindow;

	VkResult res = vkCreateAndroidSurfaceKHR(
	mVkInstance, &surfaceCreateInfo, nullptr, &mSurface);
	VK_CHECK(res);
	LOGI("Vulkan surface created from ANativeWindow");
	}

	void pickPhysicalDeviceAndQueueFamily() {
	ASSERT_NE((VkInstance)VK_NULL_HANDLE, mVkInstance);

	uint32_t deviceCount = 0;
	vkEnumeratePhysicalDevices(mVkInstance, &deviceCount, nullptr);
	ASSERT_GT(deviceCount, 0U) << "No Vulkan physical devices found!";

	std::vector<VkPhysicalDevice> devices(deviceCount);
	vkEnumeratePhysicalDevices(mVkInstance, &deviceCount, devices.data());

	for (auto& dev : devices) {
	uint32_t queueFamilyCount = 0;
	vkGetPhysicalDeviceQueueFamilyProperties(dev, &queueFamilyCount,
	nullptr);
	std::vector<VkQueueFamilyProperties> queueProps(queueFamilyCount);
	vkGetPhysicalDeviceQueueFamilyProperties(dev, &queueFamilyCount,
	queueProps.data());

	for (uint32_t i = 0; i < queueFamilyCount; i++) {
	VkBool32 support = VK_FALSE;
	vkGetPhysicalDeviceSurfaceSupportKHR(dev, i, mSurface,
	&support);
	if (support == VK_TRUE) {
	// Found a queue family that can present
	mPhysicalDev = dev;
	mPresentQueueFamily = i;

	LOGI(
	"Physical device found with queue family %u supporting "
	"present",
	i);
	return;
	}
	}
	}

	FAIL()
	<< "No physical device found that supports present to the surface!";
	}

	void createDeviceAndGetQueue(std::vector<const char*>& layers,
	std::vector<const char*> inExtensions = {}) {
	ASSERT_NE((void*)VK_NULL_HANDLE, mPhysicalDev);
	ASSERT_NE(UINT32_MAX, mPresentQueueFamily);

	float queuePriority = 1.0f;
	VkDeviceQueueCreateInfo queueInfo{};
	queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	queueInfo.queueFamilyIndex = mPresentQueueFamily;
	queueInfo.queueCount = 1;
	queueInfo.pQueuePriorities = &queuePriority;

	VkDeviceCreateInfo deviceInfo{};
	deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
	deviceInfo.queueCreateInfoCount = 1;
	deviceInfo.pQueueCreateInfos = &queueInfo;
	deviceInfo.enabledLayerCount = layers.size();
	deviceInfo.ppEnabledLayerNames = layers.data();

	std::vector<const char*> extensions = {
	VK_KHR_SWAPCHAIN_EXTENSION_NAME,
	};
	for (auto extension : inExtensions) {
	extensions.push_back(extension);
	}
	deviceInfo.enabledExtensionCount = extensions.size();
	deviceInfo.ppEnabledExtensionNames = extensions.data();

	VkResult res =
	vkCreateDevice(mPhysicalDev, &deviceInfo, nullptr, &mDevice);
	VK_CHECK(res);
	LOGI("Logical device created");

	vkGetDeviceQueue(mDevice, mPresentQueueFamily, 0, &mPresentQueue);
	ASSERT_NE((VkQueue)VK_NULL_HANDLE, mPresentQueue);
	LOGI("Acquired present-capable queue");
	}

	void createSwapchain() {
	ASSERT_NE((VkDevice)VK_NULL_HANDLE, mDevice);
	ASSERT_NE((VkSurfaceKHR)VK_NULL_HANDLE, mSurface);

	VkSurfaceCapabilitiesKHR surfaceCaps{};
	VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
	mPhysicalDev, mSurface, &surfaceCaps));

	uint32_t formatCount = 0;
	vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface,
	&formatCount, nullptr);
	ASSERT_GT(formatCount, 0U);
	std::vector<VkSurfaceFormatKHR> formats(formatCount);
	vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface,
	&formatCount, formats.data());

	VkSurfaceFormatKHR chosenFormat = formats[0];
	LOGI("Chosen surface format: %d", chosenFormat.format);

	uint32_t presentModeCount = 0;
	vkGetPhysicalDeviceSurfacePresentModesKHR(mPhysicalDev, mSurface,
	&presentModeCount, nullptr);
	ASSERT_GT(presentModeCount, 0U);
	std::vector<VkPresentModeKHR> presentModes(presentModeCount);
	vkGetPhysicalDeviceSurfacePresentModesKHR(
	mPhysicalDev, mSurface, &presentModeCount, presentModes.data());

	VkPresentModeKHR chosenPresentMode = VK_PRESENT_MODE_FIFO_KHR;
	for (auto mode : presentModes) {
	if (mode == VK_PRESENT_MODE_FIFO_KHR) {
	chosenPresentMode = mode;
	break;
	}
	}
	LOGI("Chosen present mode: %d", chosenPresentMode);

	VkExtent2D swapchainExtent{};
	if (surfaceCaps.currentExtent.width == 0xFFFFFFFF) {
	swapchainExtent.width = 640; // fallback
	swapchainExtent.height = 480; // fallback
	} else {
	swapchainExtent = surfaceCaps.currentExtent;
	}
	LOGI("Swapchain extent: %d x %d", swapchainExtent.width,
	swapchainExtent.height);

	uint32_t desiredImageCount = surfaceCaps.minImageCount + 1;
	if (surfaceCaps.maxImageCount > 0 &&
	desiredImageCount > surfaceCaps.maxImageCount) {
	desiredImageCount = surfaceCaps.maxImageCount;
	}

	VkSwapchainCreateInfoKHR swapchainInfo{};
	swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	swapchainInfo.surface = mSurface;
	swapchainInfo.minImageCount = desiredImageCount;
	swapchainInfo.imageFormat = chosenFormat.format;
	swapchainInfo.imageColorSpace = chosenFormat.colorSpace;
	swapchainInfo.imageExtent = swapchainExtent;
	swapchainInfo.imageArrayLayers = 1;
	swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT \|
	VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
	swapchainInfo.preTransform = surfaceCaps.currentTransform;
	swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
	swapchainInfo.presentMode = chosenPresentMode;
	swapchainInfo.clipped = VK_TRUE;
	swapchainInfo.oldSwapchain = VK_NULL_HANDLE;

	uint32_t queueFamilyIndices[] = {mPresentQueueFamily};
	swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
	swapchainInfo.queueFamilyIndexCount = 1;
	swapchainInfo.pQueueFamilyIndices = queueFamilyIndices;

	VkResult res =
	vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain);
	if (res == VK_SUCCESS) {
	LOGI("Swapchain created successfully");

	uint32_t swapchainImageCount = 0;
	vkGetSwapchainImagesKHR(mDevice, mSwapchain, &swapchainImageCount,
	nullptr);
	std::vector<VkImage> swapchainImages(swapchainImageCount);
	vkGetSwapchainImagesKHR(mDevice, mSwapchain, &swapchainImageCount,
	swapchainImages.data());

	LOGI("Swapchain has %u images", swapchainImageCount);
	} else {
	LOGI("Swapchain creation failed");
	}
	}

	// Image available callback (AImageReader)
	static void onImageAvailable(void, AImageReader reader) {
	LOGI("onImageAvailable callback triggered");
	AImage* image = nullptr;
	media_status_t status = AImageReader_acquireLatestImage(reader, &image);
	if (status != AMEDIA_OK \|\| !image) {
	LOGE("Failed to acquire latest image");
	return;
	}
	AImage_delete(image);
	LOGI("Released acquired image");
	}

	void cleanUpSwapchainForTest() {
	if (mSwapchain != VK_NULL_HANDLE) {
	vkDestroySwapchainKHR(mDevice, mSwapchain, nullptr);
	mSwapchain = VK_NULL_HANDLE;
	}
	if (mDevice != VK_NULL_HANDLE) {
	vkDestroyDevice(mDevice, nullptr);
	mDevice = VK_NULL_HANDLE;
	}
	if (mSurface != VK_NULL_HANDLE) {
	vkDestroySurfaceKHR(mVkInstance, mSurface, nullptr);
	mSurface = VK_NULL_HANDLE;
	}
	if (mVkInstance != VK_NULL_HANDLE) {
	vkDestroyInstance(mVkInstance, nullptr);
	mVkInstance = VK_NULL_HANDLE;
	}
	if (mReader) {
	// AImageReader_delete(mReader);
	mReader = nullptr;
	}
	// Note: The ANativeWindow from AImageReader is implicitly
	// managed by the reader, so we don't explicitly delete it.
	mWindow = nullptr;
	}

	void buildSwapchianForTest(std::vector<const char*>& instanceLayers,
	std::vector<const char*>& deviceLayers) {
	createVulkanInstance(instanceLayers);

	// the "atest libvulkan_test" command will execute this test as a binary
	// (not apk) on the device. Consequently we can't render to the screen
	// and need to work around this by using AImageReader*
	createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);
	getANativeWindowFromReader();
	createVulkanSurface();
	pickPhysicalDeviceAndQueueFamily();

	createDeviceAndGetQueue(deviceLayers);
	createSwapchain();
	}
	};

	TEST_F(AImageReaderVulkanSwapchainTest, TestHelperMethods) {
	// Verify that the basic plumbing/helper functions of these tests is
	// working. This doesn't directly test any of the layer code. It only
	// verifies that we can successfully create a swapchain with an AImageReader

	std::vector<const char*> instanceLayers;
	std::vector<const char*> deviceLayers;
	buildSwapchianForTest(deviceLayers, instanceLayers);

	ASSERT_NE(mVkInstance, (VkInstance)VK_NULL_HANDLE);
	ASSERT_NE(mPhysicalDev, (VkPhysicalDevice)VK_NULL_HANDLE);
	ASSERT_NE(mDevice, (VkDevice)VK_NULL_HANDLE);
	ASSERT_NE(mSurface, (VkSurfaceKHR)VK_NULL_HANDLE);
	ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE);
	cleanUpSwapchainForTest();
	}

	// Passing state in these tests requires global state. Wrap each test in an
	// anonymous namespace to prevent conflicting names.
	namespace {

	VKAPI_ATTR VkResult VKAPI_CALL hookedGetPhysicalDeviceImageFormatProperties2KHR(
	VkPhysicalDevice,
	const VkPhysicalDeviceImageFormatInfo2*,
	VkImageFormatProperties2*) {
	return VK_ERROR_SURFACE_LOST_KHR;
	}

	static PFN_vkGetSwapchainGrallocUsage2ANDROID
	pfnNextGetSwapchainGrallocUsage2ANDROID = nullptr;

	static bool g_grallocCalled = false;

	VKAPI_ATTR VkResult VKAPI_CALL hookGetSwapchainGrallocUsage2ANDROID(
	VkDevice device,
	VkFormat format,
	VkImageUsageFlags imageUsage,
	VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
	uint64_t* grallocConsumerUsage,
	uint64_t* grallocProducerUsage) {
	g_grallocCalled = true;
	if (pfnNextGetSwapchainGrallocUsage2ANDROID) {
	return pfnNextGetSwapchainGrallocUsage2ANDROID(
	device, format, imageUsage, swapchainImageUsage,
	grallocConsumerUsage, grallocProducerUsage);
	}

	return VK_ERROR_INITIALIZATION_FAILED;
	}

	TEST_F(AImageReaderVulkanSwapchainTest, getProducerUsageFallbackTest1) {
	// BUG: 379230826
	// Verify that getProducerUsage falls back to
	// GetSwapchainGrallocUsage*ANDROID if GPDIFP2 fails
	std::vector<const char*> instanceLayers = {};
	std::vector<const char*> deviceLayers = {};
	createVulkanInstance(instanceLayers);

	createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);
	getANativeWindowFromReader();
	createVulkanSurface();
	pickPhysicalDeviceAndQueueFamily();

	createDeviceAndGetQueue(deviceLayers);
	auto& pdev = vulkan::driver::GetData(mDevice).driver_physical_device;
	auto& pdevDispatchTable = vulkan::driver::GetData(pdev).driver;
	auto& deviceDispatchTable = vulkan::driver::GetData(mDevice).driver;

	ASSERT_NE(deviceDispatchTable.GetSwapchainGrallocUsage2ANDROID, nullptr);

	pdevDispatchTable.GetPhysicalDeviceImageFormatProperties2 =
	hookedGetPhysicalDeviceImageFormatProperties2KHR;
	deviceDispatchTable.GetSwapchainGrallocUsage2ANDROID =
	hookGetSwapchainGrallocUsage2ANDROID;

	ASSERT_FALSE(g_grallocCalled);

	createSwapchain();

	ASSERT_TRUE(g_grallocCalled);

	ASSERT_NE(mVkInstance, (VkInstance)VK_NULL_HANDLE);
	ASSERT_NE(mPhysicalDev, (VkPhysicalDevice)VK_NULL_HANDLE);
	ASSERT_NE(mDevice, (VkDevice)VK_NULL_HANDLE);
	ASSERT_NE(mSurface, (VkSurfaceKHR)VK_NULL_HANDLE);
	cleanUpSwapchainForTest();
	}

	} // namespace

	// Passing state in these tests requires global state. Wrap each test in an
	// anonymous namespace to prevent conflicting names.
	namespace {

	static bool g_returnNotSupportedOnce = true;

	VKAPI_ATTR VkResult VKAPI_CALL
	Hook_GetPhysicalDeviceImageFormatProperties2_NotSupportedOnce(
	VkPhysicalDevice /physicalDevice/,
	const VkPhysicalDeviceImageFormatInfo2* /pImageFormatInfo/,
	VkImageFormatProperties2* /pImageFormatProperties/) {
	if (g_returnNotSupportedOnce) {
	g_returnNotSupportedOnce = false;
	return VK_ERROR_FORMAT_NOT_SUPPORTED;
	}
	return VK_SUCCESS;
	}

	TEST_F(AImageReaderVulkanSwapchainTest, SurfaceFormats2KHR_IgnoreNotSupported) {
	// BUG: 357903074
	// Verify that vkGetPhysicalDeviceSurfaceFormats2KHR properly
	// ignores VK_ERROR_FORMAT_NOT_SUPPORTED and continues enumerating formats.
	std::vector<const char*> instanceLayers;
	createVulkanInstance(instanceLayers);
	createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);
	getANativeWindowFromReader();
	createVulkanSurface();
	pickPhysicalDeviceAndQueueFamily();

	auto& pdevDispatchTable = vulkan::driver::GetData(mPhysicalDev).driver;
	pdevDispatchTable.GetPhysicalDeviceImageFormatProperties2 =
	Hook_GetPhysicalDeviceImageFormatProperties2_NotSupportedOnce;

	PFN_vkGetPhysicalDeviceSurfaceFormats2KHR
	pfnGetPhysicalDeviceSurfaceFormats2KHR =
	reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormats2KHR>(
	vkGetInstanceProcAddr(mVkInstance,
	"vkGetPhysicalDeviceSurfaceFormats2KHR"));
	ASSERT_NE(nullptr, pfnGetPhysicalDeviceSurfaceFormats2KHR)
	<< "Could not get pointer to vkGetPhysicalDeviceSurfaceFormats2KHR";

	VkPhysicalDeviceSurfaceInfo2KHR surfaceInfo2{};
	surfaceInfo2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
	surfaceInfo2.pNext = nullptr;
	surfaceInfo2.surface = mSurface;

	uint32_t formatCount = 0;
	VkResult res = pfnGetPhysicalDeviceSurfaceFormats2KHR(
	mPhysicalDev, &surfaceInfo2, &formatCount, nullptr);

	// If the loader never tries a second format, it might fail or 0-out the
	// formatCount. The patch ensures it continues to the next format rather
	// than bailing out on the first NOT_SUPPORTED.
	ASSERT_EQ(VK_SUCCESS, res)
	<< "vkGetPhysicalDeviceSurfaceFormats2KHR failed unexpectedly";
	ASSERT_GT(formatCount, 0U)
	<< "No surface formats found; the loader may have bailed early.";

	std::vector<VkSurfaceFormat2KHR> formats(formatCount);
	for (auto& f : formats) {
	f.sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
	f.pNext = nullptr;
	}
	res = pfnGetPhysicalDeviceSurfaceFormats2KHR(mPhysicalDev, &surfaceInfo2,
	&formatCount, formats.data());
	ASSERT_EQ(VK_SUCCESS, res) << "Failed to retrieve surface formats";

	LOGI(
	"SurfaceFormats2KHR_IgnoreNotSupported test: found %u formats after "
	"ignoring NOT_SUPPORTED",
	formatCount);

	cleanUpSwapchainForTest();
	}

	} // namespace

	namespace {

	TEST_F(AImageReaderVulkanSwapchainTest, MutableFormatSwapchainTest) {
	// Test swapchain with mutable format extension
	std::vector<const char*> instanceLayers;
	std::vector<const char*> deviceLayers;
	std::vector<const char*> deviceExtensions = {
	VK_KHR_SWAPCHAIN_EXTENSION_NAME,
	VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME,
	VK_KHR_MAINTENANCE2_EXTENSION_NAME,
	VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME};

	createVulkanInstance(instanceLayers);
	createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3);
	getANativeWindowFromReader();
	createVulkanSurface();
	pickPhysicalDeviceAndQueueFamily();
	createDeviceAndGetQueue(deviceLayers, deviceExtensions);

	ASSERT_NE((VkDevice)VK_NULL_HANDLE, mDevice);
	ASSERT_NE((VkSurfaceKHR)VK_NULL_HANDLE, mSurface);

	VkSurfaceCapabilitiesKHR surfaceCaps{};
	VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface,
	&surfaceCaps));

	uint32_t formatCount = 0;
	vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface, &formatCount,
	nullptr);
	ASSERT_GT(formatCount, 0U);
	std::vector<VkSurfaceFormatKHR> formats(formatCount);
	vkGetPhysicalDeviceSurfaceFormatsKHR(mPhysicalDev, mSurface, &formatCount,
	formats.data());

	VkFormat viewFormats[2] = {formats[0].format, formats[0].format};
	if (formatCount > 1) {
	viewFormats[1] = formats[1].format;
	}

	VkImageFormatListCreateInfoKHR formatList{};
	formatList.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR;
	formatList.viewFormatCount = 2;
	formatList.pViewFormats = viewFormats;

	VkSwapchainCreateInfoKHR swapchainInfo{};
	swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
	swapchainInfo.pNext = &formatList;
	swapchainInfo.surface = mSurface;
	swapchainInfo.minImageCount = surfaceCaps.minImageCount + 1;
	swapchainInfo.imageFormat = formats[0].format;
	swapchainInfo.imageColorSpace = formats[0].colorSpace;
	swapchainInfo.imageExtent = surfaceCaps.currentExtent;
	swapchainInfo.imageArrayLayers = 1;
	swapchainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
	swapchainInfo.preTransform = surfaceCaps.currentTransform;
	swapchainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
	swapchainInfo.presentMode = VK_PRESENT_MODE_FIFO_KHR;
	swapchainInfo.clipped = VK_TRUE;

	swapchainInfo.flags = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR;

	uint32_t queueFamilyIndices[] = {mPresentQueueFamily};
	swapchainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
	swapchainInfo.queueFamilyIndexCount = 1;
	swapchainInfo.pQueueFamilyIndices = queueFamilyIndices;

	VkResult res =
	vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain);
	if (res == VK_SUCCESS) {
	LOGI("Mutable format swapchain created successfully");

	uint32_t imageCount = 0;
	vkGetSwapchainImagesKHR(mDevice, mSwapchain, &imageCount, nullptr);
	ASSERT_GT(imageCount, 0U);
	} else {
	LOGI(
	"Mutable format swapchain creation failed (extension may not be "
	"supported)");
	}

	cleanUpSwapchainForTest();
	}

	} // namespace

	} // namespace libvulkantest

	} // namespace android