| /* |
| * 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 <graphicsenv/GraphicsEnv.h> |
| #include <gtest/gtest.h> |
| #include <media/NdkImageReader.h> |
| #include <system/window.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 { |
| // We need this to run before any other vulkan tests. Otherwise the |
| // layers are already marked as loaded |
| auto app_namespace = |
| android::GraphicsEnv::getInstance().getAppNamespace(); |
| android::GraphicsEnv::getInstance().setLayerPaths( |
| app_namespace, |
| "/data/local/tmp/libvulkan_test/x86_64/:/data/local/tmp/" |
| "libvulkan_test/arm64/"); |
| } |
| |
| 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, |
| bool set_listener = true) { |
| 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"; |
| |
| if (set_listener) { |
| // 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 = {}, |
| void* pNext = nullptr) { |
| 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.pNext = pNext; |
| 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 |
| |
| int Hook_ANativeWindow_Perform_FakeTimestamps(ANativeWindow* window, |
| ANativeWindow_performFn perform, |
| void*, |
| int operation, |
| va_list args) { |
| if (operation == NATIVE_WINDOW_GET_FRAME_TIMESTAMPS) { |
| ALOGI("Intercepted NATIVE_WINDOW_GET_FRAME_TIMESTAMPS"); |
| uint64_t frameId = va_arg(args, uint64_t); |
| int64_t* outRequestedPresentTime = va_arg(args, int64_t*); |
| int64_t* outAcquireTime = va_arg(args, int64_t*); |
| int64_t* outLatchTime = va_arg(args, int64_t*); |
| int64_t* outFirstRefreshStartTime = va_arg(args, int64_t*); |
| int64_t* outLastRefreshStartTime = va_arg(args, int64_t*); |
| int64_t* outGpuCompositionDoneTime = va_arg(args, int64_t*); |
| int64_t* outDisplayPresentTime = va_arg(args, int64_t*); |
| int64_t* outDequeueReadyTime = va_arg(args, int64_t*); |
| int64_t* outReleaseTime = va_arg(args, int64_t*); |
| |
| if (outRequestedPresentTime) |
| *outRequestedPresentTime = frameId; |
| if (outAcquireTime) |
| *outAcquireTime = frameId; |
| if (outLatchTime) |
| *outLatchTime = frameId; |
| if (outFirstRefreshStartTime) |
| *outFirstRefreshStartTime = frameId; |
| if (outLastRefreshStartTime) |
| *outLastRefreshStartTime = frameId; |
| if (outGpuCompositionDoneTime) |
| *outGpuCompositionDoneTime = frameId; |
| if (outDisplayPresentTime) |
| *outDisplayPresentTime = frameId; |
| if (outDequeueReadyTime) |
| *outDequeueReadyTime = frameId; |
| if (outReleaseTime) |
| *outReleaseTime = frameId; |
| |
| return 0; |
| } |
| |
| return perform(window, operation, args); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, FrameTimestampInterceptorTest) { |
| // verify native_window_get_frame_timestamp can be intercepted |
| std::vector<const char*> instanceLayers; |
| std::vector<const char*> deviceLayers; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3); |
| getANativeWindowFromReader(); |
| ASSERT_NE(mWindow, nullptr); |
| |
| int result = mWindow->perform( |
| mWindow, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, |
| Hook_ANativeWindow_Perform_FakeTimestamps, nullptr /* data */); |
| ASSERT_EQ(result, 0); |
| |
| int64_t latchTime = 0; |
| native_window_get_frame_timestamps(mWindow, 123, nullptr, nullptr, |
| &latchTime, nullptr, nullptr, nullptr, |
| nullptr, nullptr, nullptr); |
| |
| ASSERT_EQ(latchTime, 123); |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, StandardPresentTimingCountTest) { |
| // verify we only wait 1 frame for timing results b/440824659 |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3); |
| getANativeWindowFromReader(); |
| |
| int result = mWindow->perform( |
| mWindow, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, |
| Hook_ANativeWindow_Perform_FakeTimestamps, nullptr /* data */); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| // Check if the required display timing extension is supported by the |
| // device. |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool timingExtSupported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME) == 0) { |
| timingExtSupported = true; |
| break; |
| } |
| } |
| |
| if (!timingExtSupported) { |
| GTEST_SKIP() << "Vulkan extension " |
| << VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME |
| << " not supported."; |
| } |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount > 0 && |
| imageCount > surfaceCaps.maxImageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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; |
| |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain); |
| VK_CHECK(res); |
| ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE); |
| |
| uint32_t imageIndex; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| |
| VkPresentTimeGOOGLE presentTime = {1, 1000}; |
| VkPresentTimesInfoGOOGLE presentTimesInfo = {}; |
| presentTimesInfo.sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; |
| presentTimesInfo.swapchainCount = 1; |
| presentTimesInfo.pTimes = &presentTime; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentTimesInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &mSwapchain; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| auto pfnGetPastPresentationTimingGOOGLE = |
| (PFN_vkGetPastPresentationTimingGOOGLE)vkGetDeviceProcAddr( |
| mDevice, "vkGetPastPresentationTimingGOOGLE"); |
| ASSERT_NE(pfnGetPastPresentationTimingGOOGLE, |
| (PFN_vkGetPastPresentationTimingGOOGLE) nullptr); |
| |
| uint32_t timingCount = 0; |
| res = pfnGetPastPresentationTimingGOOGLE(mDevice, mSwapchain, &timingCount, |
| nullptr); |
| VK_CHECK(res); |
| |
| ASSERT_TRUE(timingCount == 1) |
| << "Expected one timing record to be available."; |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, SharedPresentTimingZeroedTest) { |
| // Verifies that for shared present modes, vkGetPastPresentationTimingGOOGLE |
| // returns a record with zeroed-out timing values, as per the change in |
| // get_num_ready_timings. |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3); |
| getANativeWindowFromReader(); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool timingExtSupported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME) == 0) { |
| timingExtSupported = true; |
| break; |
| } |
| } |
| |
| if (!timingExtSupported) { |
| GTEST_SKIP() << "Vulkan extension " |
| << VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME |
| << " not supported."; |
| } |
| |
| uint32_t presentModeCount = 0; |
| vkGetPhysicalDeviceSurfacePresentModesKHR(mPhysicalDev, mSurface, |
| &presentModeCount, nullptr); |
| ASSERT_GT(presentModeCount, 0U); |
| std::vector<VkPresentModeKHR> presentModes(presentModeCount); |
| vkGetPhysicalDeviceSurfacePresentModesKHR( |
| mPhysicalDev, mSurface, &presentModeCount, presentModes.data()); |
| |
| bool sharedPresentSupported = false; |
| for (const auto& mode : presentModes) { |
| if (mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR) { |
| sharedPresentSupported = true; |
| break; |
| } |
| } |
| |
| if (!sharedPresentSupported) { |
| GTEST_SKIP() |
| << "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR not supported."; |
| } |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = 1; |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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_SHARED_DEMAND_REFRESH_KHR; |
| swapchainInfo.clipped = VK_TRUE; |
| |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain); |
| VK_CHECK(res); |
| ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE); |
| |
| uint32_t imageIndex; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| ASSERT_EQ(imageIndex, 0U); |
| |
| VkPresentTimeGOOGLE presentTime = {123, 456}; |
| VkPresentTimesInfoGOOGLE presentTimesInfo = {}; |
| presentTimesInfo.sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE; |
| presentTimesInfo.swapchainCount = 1; |
| presentTimesInfo.pTimes = &presentTime; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentTimesInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &mSwapchain; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| |
| auto pfnGetPastPresentationTimingGOOGLE = |
| (PFN_vkGetPastPresentationTimingGOOGLE)vkGetDeviceProcAddr( |
| mDevice, "vkGetPastPresentationTimingGOOGLE"); |
| ASSERT_NE(pfnGetPastPresentationTimingGOOGLE, |
| (PFN_vkGetPastPresentationTimingGOOGLE) nullptr); |
| |
| uint32_t timingCount = 0; |
| res = pfnGetPastPresentationTimingGOOGLE(mDevice, mSwapchain, &timingCount, |
| nullptr); |
| VK_CHECK(res); |
| ASSERT_EQ(timingCount, 1U); |
| |
| VkPastPresentationTimingGOOGLE timing; |
| timingCount = 1; |
| res = pfnGetPastPresentationTimingGOOGLE(mDevice, mSwapchain, &timingCount, |
| &timing); |
| VK_CHECK(res); |
| ASSERT_EQ(timingCount, 1U); |
| |
| // Verify the new behavior: present ID is preserved, but times are zero. |
| EXPECT_EQ(timing.presentID, presentTime.presentID); |
| EXPECT_EQ(timing.actualPresentTime, 0U); |
| EXPECT_EQ(timing.earliestPresentTime, 0U); |
| EXPECT_EQ(timing.presentMargin, 0U); |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, LoadInstanceLayerAndDeviceLayer) { |
| // Verify our layer works as both a device and instance layer |
| // building the swapchain will fail if the layer is not loaded |
| |
| std::vector<const char*> instanceLayers = { |
| "VK_LAYER_libVulkanTestLayer", |
| }; |
| std::vector<const char*> deviceLayers = { |
| "VK_LAYER_libVulkanTestLayer", |
| }; |
| 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(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, |
| FailToLoadInstanceLayerAndDeviceLayerWithBadName) { |
| // Verify .so files without "libVkLayer_" prefix are not loaded |
| // building the swapchain will fail if the layer is not loaded |
| |
| std::vector<const char*> instanceLayers = { |
| "VK_LAYER_libVulkanTestLayer_without_libVkLayer_prefix", |
| }; |
| |
| const char* extensions[] = { |
| VK_KHR_SURFACE_EXTENSION_NAME, |
| VK_KHR_ANDROID_SURFACE_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 = instanceLayers.size(); |
| instInfo.ppEnabledLayerNames = instanceLayers.data(); |
| VkResult res = vkCreateInstance(&instInfo, nullptr, &mVkInstance); |
| |
| EXPECT_EQ(res, VK_ERROR_LAYER_NOT_PRESENT); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, PresentWait2Test) { |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_KHR_SWAPCHAIN_EXTENSION_NAME, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME, |
| VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 1, false); |
| getANativeWindowFromReader(); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool presentId2Supported = false; |
| bool presentWait2Supported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME) == 0) { |
| presentId2Supported = true; |
| } |
| if (strcmp(extension.extensionName, |
| VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME) == 0) { |
| presentWait2Supported = true; |
| } |
| } |
| |
| if (!presentId2Supported || !presentWait2Supported) { |
| GTEST_SKIP() |
| << "VK_KHR_present_id2 or VK_KHR_present_wait2 not supported"; |
| } |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount > 0 && |
| imageCount > surfaceCaps.maxImageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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_PRESENT_WAIT_2_BIT_KHR; |
| |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain); |
| VK_CHECK(res); |
| ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE); |
| |
| auto pfnWaitForPresent2KHR = (PFN_vkWaitForPresent2KHR)vkGetDeviceProcAddr( |
| mDevice, "vkWaitForPresent2KHR"); |
| ASSERT_NE(pfnWaitForPresent2KHR, (PFN_vkWaitForPresent2KHR) nullptr); |
| |
| uint64_t presentId = 1; |
| |
| VkPresentWait2InfoKHR presentWaitInfo{}; |
| presentWaitInfo.sType = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; |
| presentWaitInfo.presentId = 1; |
| presentWaitInfo.timeout = 10000; |
| |
| // Wait for a present that hasn't been queued. Counterintuitively this |
| // should pass as we assume any unseen frames are past prevented frames |
| res = pfnWaitForPresent2KHR(mDevice, mSwapchain, &presentWaitInfo); |
| ASSERT_EQ(res, VK_SUCCESS); |
| |
| uint32_t imageIndex; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| |
| VkPresentId2KHR presentIdInfo = {}; |
| presentIdInfo.sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; |
| presentIdInfo.swapchainCount = 1; |
| presentIdInfo.pPresentIds = &presentId; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentIdInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &mSwapchain; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| |
| // Make sure we get a timeout for a frame which remains in flight |
| res = pfnWaitForPresent2KHR(mDevice, mSwapchain, &presentWaitInfo); |
| ASSERT_EQ(res, VK_TIMEOUT); |
| |
| // Call this to trigger the frame acquired callback in |
| // BufferQueueConsumer::acquireBufer |
| AImage* image = nullptr; |
| media_status_t status = AImageReader_acquireLatestImage(mReader, &image); |
| |
| // Wait for the presentId we just submitted. Should succeed. |
| res = pfnWaitForPresent2KHR(mDevice, mSwapchain, &presentWaitInfo); |
| ASSERT_EQ(res, VK_SUCCESS); |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, PresentWait2ManyFrames) { |
| // Test vk_khr_present_wait2 with many frames. This also tests the |
| // native_window_get_last_replaced_frame_id logic inside swapchain.cpp |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_KHR_SWAPCHAIN_EXTENSION_NAME, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME, |
| VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 1, false); |
| getANativeWindowFromReader(); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool presentId2Supported = false; |
| bool presentWait2Supported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME) == 0) { |
| presentId2Supported = true; |
| } |
| if (strcmp(extension.extensionName, |
| VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME) == 0) { |
| presentWait2Supported = true; |
| } |
| } |
| |
| if (!presentId2Supported || !presentWait2Supported) { |
| GTEST_SKIP() |
| << "VK_KHR_present_id2 or VK_KHR_present_wait2 not supported"; |
| } |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions); |
| |
| uint32_t presentModeCount = 0; |
| vkGetPhysicalDeviceSurfacePresentModesKHR(mPhysicalDev, mSurface, |
| &presentModeCount, nullptr); |
| ASSERT_GT(presentModeCount, 0U); |
| std::vector<VkPresentModeKHR> presentModes(presentModeCount); |
| vkGetPhysicalDeviceSurfacePresentModesKHR( |
| mPhysicalDev, mSurface, &presentModeCount, presentModes.data()); |
| |
| bool mailboxSupported = false; |
| for (const auto& mode : presentModes) { |
| if (mode == VK_PRESENT_MODE_MAILBOX_KHR) { |
| mailboxSupported = true; |
| break; |
| } |
| } |
| |
| if (!mailboxSupported) { |
| GTEST_SKIP() << "VK_PRESENT_MODE_MAILBOX_KHR not supported."; |
| } |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| if (surfaceCaps.maxImageCount != 0 && surfaceCaps.maxImageCount < 2) { |
| GTEST_SKIP() << "Swapchain doesn't support at least 2 images."; |
| } |
| uint32_t imageCount = std::max(2u, surfaceCaps.minImageCount); |
| if (surfaceCaps.maxImageCount != 0) { |
| imageCount = std::min(imageCount, surfaceCaps.maxImageCount); |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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_MAILBOX_KHR; |
| swapchainInfo.clipped = VK_TRUE; |
| swapchainInfo.flags = VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR; |
| |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain); |
| VK_CHECK(res); |
| ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE); |
| |
| auto pfnWaitForPresent2KHR = (PFN_vkWaitForPresent2KHR)vkGetDeviceProcAddr( |
| mDevice, "vkWaitForPresent2KHR"); |
| ASSERT_NE(pfnWaitForPresent2KHR, (PFN_vkWaitForPresent2KHR) nullptr); |
| |
| uint32_t imageIndex1; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex1); |
| VK_CHECK(res); |
| |
| uint64_t presentId1 = 1; |
| VkPresentId2KHR presentIdInfo1 = {}; |
| presentIdInfo1.sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; |
| presentIdInfo1.swapchainCount = 1; |
| presentIdInfo1.pPresentIds = &presentId1; |
| |
| VkPresentInfoKHR presentInfo1 = {}; |
| presentInfo1.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo1.pNext = &presentIdInfo1; |
| presentInfo1.swapchainCount = 1; |
| presentInfo1.pSwapchains = &mSwapchain; |
| presentInfo1.pImageIndices = &imageIndex1; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo1); |
| VK_CHECK(res); |
| |
| // Present with ID 2, this should replace/drop frame 1 |
| uint32_t imageIndex2; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex2); |
| VK_CHECK(res); |
| |
| uint64_t presentId2 = 2; |
| VkPresentId2KHR presentIdInfo2 = {}; |
| presentIdInfo2.sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; |
| presentIdInfo2.swapchainCount = 1; |
| presentIdInfo2.pPresentIds = &presentId2; |
| |
| VkPresentInfoKHR presentInfo2 = {}; |
| presentInfo2.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo2.pNext = &presentIdInfo2; |
| presentInfo2.swapchainCount = 1; |
| presentInfo2.pSwapchains = &mSwapchain; |
| presentInfo2.pImageIndices = &imageIndex2; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo2); |
| VK_CHECK(res); |
| |
| // Present with ID 3, this should replace/drop frame 2 |
| uint32_t imageIndex3; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex3); |
| VK_CHECK(res); |
| |
| uint64_t presentId3 = 3; |
| VkPresentId2KHR presentIdInfo3 = {}; |
| presentIdInfo3.sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; |
| presentIdInfo3.swapchainCount = 1; |
| presentIdInfo3.pPresentIds = &presentId3; |
| |
| VkPresentInfoKHR presentInfo3 = {}; |
| presentInfo3.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo3.pNext = &presentIdInfo3; |
| presentInfo3.swapchainCount = 1; |
| presentInfo3.pSwapchains = &mSwapchain; |
| presentInfo3.pImageIndices = &imageIndex3; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo3); |
| VK_CHECK(res); |
| |
| // Wait for present ID 2, which was dropped by present 3. |
| VkPresentWait2InfoKHR presentWaitInfo2{}; |
| presentWaitInfo2.sType = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; |
| presentWaitInfo2.presentId = 2; |
| presentWaitInfo2.timeout = 100000; |
| |
| res = pfnWaitForPresent2KHR(mDevice, mSwapchain, &presentWaitInfo2); |
| ASSERT_EQ(res, VK_SUCCESS); |
| |
| // Wait for present ID 1, which was dropped by present 2 |
| VkPresentWait2InfoKHR presentWaitInfo1{}; |
| presentWaitInfo1.sType = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR; |
| presentWaitInfo1.presentId = 1; |
| presentWaitInfo1.timeout = 0; |
| |
| res = pfnWaitForPresent2KHR(mDevice, mSwapchain, &presentWaitInfo1); |
| ASSERT_EQ(res, VK_SUCCESS); |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, TestFifoLatestReadySupport) { |
| // Test if VK_PRESENT_MODE_FIFO_LATEST_READY_EXT is supported |
| std::vector<const char*> instanceLayers; |
| std::vector<const char*> deviceLayers; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3); |
| getANativeWindowFromReader(); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| // Check if the physical device supports the extension |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> extensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| extensions.data()); |
| |
| bool extensionSupported = false; |
| for (const auto& extension : extensions) { |
| if (strcmp(extension.extensionName, |
| "VK_EXT_present_mode_fifo_latest_ready") == 0) { |
| extensionSupported = true; |
| break; |
| } |
| } |
| |
| LOGI("VK_EXT_present_mode_fifo_latest_ready extension supported: %s", |
| extensionSupported ? "YES" : "NO"); |
| |
| createDeviceAndGetQueue(deviceLayers); |
| |
| // Check if the present mode is supported |
| uint32_t presentModeCount = 0; |
| vkGetPhysicalDeviceSurfacePresentModesKHR(mPhysicalDev, mSurface, |
| &presentModeCount, nullptr); |
| std::vector<VkPresentModeKHR> presentModes(presentModeCount); |
| vkGetPhysicalDeviceSurfacePresentModesKHR( |
| mPhysicalDev, mSurface, &presentModeCount, presentModes.data()); |
| |
| bool modeSupported = false; |
| for (auto mode : presentModes) { |
| if (mode == VK_PRESENT_MODE_FIFO_LATEST_READY_EXT) { |
| modeSupported = true; |
| break; |
| } |
| } |
| |
| LOGI( |
| "VK_PRESENT_MODE_FIFO_LATEST_READY_EXT present mode supported " |
| "natively: %s", |
| modeSupported ? "YES" : "NO"); |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| static bool HasExtension(std::vector<VkExtensionProperties> const & extensions, |
| char const *extensionName) |
| { |
| for (auto const &ext : extensions) |
| if (!strcmp(ext.extensionName, extensionName)) |
| return true; |
| return false; |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, TestKhrFeaturesCorrectlyExposed) { |
| std::vector<char const *> instanceExtensions10 = { |
| VK_KHR_SURFACE_EXTENSION_NAME, |
| VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, |
| VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME, |
| VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, |
| }; |
| |
| VkInstance instance10; |
| |
| VkApplicationInfo appInfo10 = { |
| VK_STRUCTURE_TYPE_APPLICATION_INFO, |
| nullptr, |
| nullptr, |
| 0, |
| nullptr, |
| 0, |
| VK_API_VERSION_1_0, |
| }; |
| |
| VkInstanceCreateInfo ici10 = { |
| VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, |
| nullptr, |
| 0, |
| &appInfo10, |
| 0, |
| nullptr, |
| static_cast<uint32_t>(instanceExtensions10.size()), |
| instanceExtensions10.data() |
| }; |
| vkCreateInstance(&ici10, nullptr, &instance10); |
| |
| ASSERT_NE(instance10, nullptr); |
| |
| uint32_t deviceCount = 0; |
| vkEnumeratePhysicalDevices(instance10, &deviceCount, nullptr); |
| if (!deviceCount) |
| GTEST_SKIP() << "No vulkan devices"; |
| |
| VkPhysicalDevice physicalDevice; |
| deviceCount = 1; // only fetch first physical device. |
| vkEnumeratePhysicalDevices(instance10, &deviceCount, &physicalDevice); |
| |
| ASSERT_NE(physicalDevice, nullptr); |
| |
| uint32_t deviceExtensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &deviceExtensionCount, nullptr); |
| std::vector<VkExtensionProperties> deviceExtensions(deviceExtensionCount); |
| vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &deviceExtensionCount, deviceExtensions.data()); |
| |
| if (!HasExtension(deviceExtensions, VK_KHR_PRESENT_ID_EXTENSION_NAME)) |
| GTEST_SKIP() << "Device does not offer KHR_present_id"; |
| |
| // Now deliberately use the _KHR_ version of the GPDF2 function to fetch the |
| // features associated with this extension. |
| VkPhysicalDevicePresentIdFeaturesKHR presentIdFeatures = { |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, |
| nullptr, |
| VK_FALSE, /* present id */ |
| }; |
| VkPhysicalDeviceFeatures2KHR features2 = { |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, |
| &presentIdFeatures, |
| |
| }; |
| |
| auto gpdf2 = (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr( |
| instance10, "vkGetPhysicalDeviceFeatures2KHR"); |
| gpdf2(physicalDevice, &features2); |
| |
| // Our feature should have been populated! |
| ASSERT_EQ(presentIdFeatures.presentId, VK_TRUE); |
| } |
| |
| namespace { |
| |
| struct OnAcquiredCallbackData { |
| ANativeWindow_OnAcquiredCallback callback = nullptr; |
| void* data = nullptr; |
| }; |
| |
| int Hook_ANativeWindow_Perform_SetCallback(ANativeWindow* window, |
| ANativeWindow_performFn perform, |
| void* data, |
| int operation, |
| va_list args) { |
| if (operation == NATIVE_WINDOW_API_SET_ON_ACQUIRED_CALLBACK) { |
| ALOGI("Intercepted NATIVE_WINDOW_API_SET_ON_ACQUIRED_CALLBACK"); |
| if (data) { |
| va_list args_copy; |
| va_copy(args_copy, args); |
| auto* captured = static_cast<OnAcquiredCallbackData*>(data); |
| captured->callback = va_arg(args_copy, ANativeWindow_OnAcquiredCallback); |
| captured->data = va_arg(args_copy, void*); |
| va_end(args_copy); |
| } |
| } |
| |
| return perform(window, operation, args); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, SurfaceDestroyedBeforeOnAcquiredCallback) { |
| // Verify that the callback from the consumer (AImageReader) doesn't cause a |
| // crash if the surface has already been destroyed. |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_KHR_SWAPCHAIN_EXTENSION_NAME, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME, |
| VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME, |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME, |
| }; |
| OnAcquiredCallbackData callbackData; |
| |
| createVulkanInstance(instanceLayers); |
| // Don't set listener, we will acquire manually |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 1, false); |
| getANativeWindowFromReader(); |
| |
| |
| int result = mWindow->perform( |
| mWindow, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, |
| Hook_ANativeWindow_Perform_SetCallback, &callbackData); |
| ASSERT_EQ(result, 0); |
| |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool presentId2Supported = false; |
| bool presentWait2Supported = false; |
| bool presentTimingSupported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME) == 0) { |
| presentId2Supported = true; |
| } |
| if (strcmp(extension.extensionName, |
| VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME) == 0) { |
| presentWait2Supported = true; |
| } |
| if (strcmp(extension.extensionName, |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME) == 0) { |
| presentTimingSupported = true; |
| } |
| } |
| |
| if (!presentId2Supported || !presentWait2Supported || |
| !presentTimingSupported) { |
| GTEST_SKIP() << "VK_KHR_present_id2, VK_KHR_present_wait2, or " |
| "VK_EXT_present_timing not supported"; |
| } |
| |
| VkPhysicalDevicePresentWait2FeaturesKHR presentWait2Features = {}; |
| presentWait2Features.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; |
| presentWait2Features.presentWait2 = VK_TRUE; |
| |
| VkPhysicalDevicePresentId2FeaturesKHR presentId2Features = {}; |
| presentId2Features.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; |
| presentId2Features.presentId2 = VK_TRUE; |
| presentId2Features.pNext = &presentWait2Features; |
| |
| VkPhysicalDevicePresentTimingFeaturesEXT presentTimingFeatures = {}; |
| presentTimingFeatures.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; |
| presentTimingFeatures.presentTiming = VK_TRUE; |
| presentTimingFeatures.presentAtAbsoluteTime = VK_TRUE; |
| presentTimingFeatures.pNext = &presentId2Features; |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions, |
| &presentTimingFeatures); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount > 0 && |
| imageCount > surfaceCaps.maxImageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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_PRESENT_WAIT_2_BIT_KHR; |
| |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain); |
| VK_CHECK(res); |
| ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE); |
| |
| uint32_t imageIndex; |
| res = vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| |
| uint64_t presentId = 1; |
| VkPresentId2KHR presentIdInfo = {}; |
| presentIdInfo.sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; |
| presentIdInfo.swapchainCount = 1; |
| presentIdInfo.pPresentIds = &presentId; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentIdInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &mSwapchain; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| |
| // Destroy the swapchain and surface immediately after present |
| vkDestroySwapchainKHR(mDevice, mSwapchain, nullptr); |
| mSwapchain = VK_NULL_HANDLE; |
| vkDestroySurfaceKHR(mVkInstance, mSurface, nullptr); |
| mSurface = VK_NULL_HANDLE; |
| |
| // Trigger the callback manually (AImageReader acquire). |
| // This used to crash if the surface was already destroyed. |
| callbackData.callback(0 /*bufferId*/, 0 /*frameId*/, callbackData.data); |
| cleanUpSwapchainForTest(); |
| } |
| |
| } // namespace |
| |
| namespace { |
| |
| int Hook_ANativeWindow_Perform_ErrorTimestamps(ANativeWindow* window, |
| ANativeWindow_performFn perform, |
| void*, |
| int operation, |
| va_list args) { |
| if (operation == NATIVE_WINDOW_GET_FRAME_TIMESTAMPS) { |
| return -EINVAL; |
| } |
| return perform(window, operation, args); |
| } |
| |
| int Hook_ANativeWindow_Perform_SuccessTimestamps_NonZero( |
| ANativeWindow* window, |
| ANativeWindow_performFn perform, |
| void*, |
| int operation, |
| va_list args) { |
| if (operation == NATIVE_WINDOW_GET_FRAME_TIMESTAMPS) { |
| uint64_t frameId = va_arg(args, uint64_t); |
| int64_t* outRequestedPresentTime = va_arg(args, int64_t*); |
| int64_t* outAcquireTime = va_arg(args, int64_t*); |
| int64_t* outLatchTime = va_arg(args, int64_t*); |
| int64_t* outFirstRefreshStartTime = va_arg(args, int64_t*); |
| int64_t* outLastRefreshStartTime = va_arg(args, int64_t*); |
| int64_t* outGpuCompositionDoneTime = va_arg(args, int64_t*); |
| int64_t* outDisplayPresentTime = va_arg(args, int64_t*); |
| int64_t* outDequeueReadyTime = va_arg(args, int64_t*); |
| int64_t* outReleaseTime = va_arg(args, int64_t*); |
| |
| if (outRequestedPresentTime) |
| *outRequestedPresentTime = 12345; |
| if (outAcquireTime) |
| *outAcquireTime = 12345; |
| if (outLatchTime) |
| *outLatchTime = 12345; |
| if (outFirstRefreshStartTime) |
| *outFirstRefreshStartTime = 12345; |
| if (outLastRefreshStartTime) |
| *outLastRefreshStartTime = 12345; |
| if (outGpuCompositionDoneTime) |
| *outGpuCompositionDoneTime = 12345; |
| if (outDisplayPresentTime) |
| *outDisplayPresentTime = 12345; |
| if (outDequeueReadyTime) |
| *outDequeueReadyTime = 12345; |
| if (outReleaseTime) |
| *outReleaseTime = 12345; |
| |
| return 0; |
| } |
| |
| return perform(window, operation, args); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, ExtPresentTimingErrorTimestamps) { |
| // verify we return 0 timestamps when NATIVE_WINDOW_GET_FRAME_TIMESTAMPS |
| // returns an error. |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3); |
| getANativeWindowFromReader(); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| // Check if the required display timing extension is supported by the device |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool timingExtSupported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME) == 0) { |
| timingExtSupported = true; |
| break; |
| } |
| } |
| |
| if (!timingExtSupported) { |
| GTEST_SKIP() << "Vulkan extension " |
| << VK_EXT_PRESENT_TIMING_EXTENSION_NAME |
| << " not supported."; |
| } |
| |
| VkPhysicalDevicePresentTimingFeaturesEXT presentTimingFeatures = {}; |
| presentTimingFeatures.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; |
| presentTimingFeatures.presentTiming = VK_TRUE; |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions, |
| &presentTimingFeatures); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount > 0 && |
| imageCount > surfaceCaps.maxImageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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; |
| |
| // Set error interceptor |
| int result = mWindow->perform( |
| mWindow, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, |
| Hook_ANativeWindow_Perform_ErrorTimestamps, nullptr /* data */); |
| ASSERT_EQ(result, 0); |
| |
| // Create Swapchain 1 |
| VkSwapchainKHR swapchain1 = VK_NULL_HANDLE; |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &swapchain1); |
| VK_CHECK(res); |
| |
| uint32_t imageIndex; |
| res = vkAcquireNextImageKHR(mDevice, swapchain1, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| |
| VkPresentTimingInfoEXT presentTimingInfo = {}; |
| presentTimingInfo.presentStageQueries = |
| VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT; |
| presentTimingInfo.targetTime = 0; |
| |
| VkPresentTimingsInfoEXT presentTimingsInfo = {}; |
| presentTimingsInfo.sType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; |
| presentTimingsInfo.swapchainCount = 1; |
| presentTimingsInfo.pTimingInfos = &presentTimingInfo; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentTimingsInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &swapchain1; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| |
| auto pfnGetPastPresentationTimingEXT = |
| (PFN_vkGetPastPresentationTimingEXT)vkGetDeviceProcAddr( |
| mDevice, "vkGetPastPresentationTimingEXT"); |
| ASSERT_NE(pfnGetPastPresentationTimingEXT, |
| (PFN_vkGetPastPresentationTimingEXT) nullptr); |
| |
| // Query timing on Swapchain 1 |
| VkPastPresentationTimingInfoEXT pastTimingInfo1 = {}; |
| pastTimingInfo1.sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; |
| pastTimingInfo1.swapchain = swapchain1; |
| |
| VkPastPresentationTimingPropertiesEXT pastTimingProps1 = {}; |
| pastTimingProps1.sType = |
| VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; |
| |
| // First call to get count |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastTimingInfo1, |
| &pastTimingProps1); |
| VK_CHECK(res); |
| ASSERT_EQ(pastTimingProps1.presentationTimingCount, 1U); |
| |
| std::vector<VkPastPresentationTimingEXT> pastTimings1(1); |
| std::vector<VkPresentStageTimeEXT> stages1(1); |
| pastTimings1[0].sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; |
| pastTimings1[0].pPresentStages = stages1.data(); |
| pastTimingProps1.pPresentationTimings = pastTimings1.data(); |
| |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastTimingInfo1, |
| &pastTimingProps1); |
| VK_CHECK(res); |
| |
| // Verify timestamps are 0 since interceptor returned error |
| EXPECT_EQ(pastTimings1[0].presentStageCount, 1U); |
| EXPECT_EQ(stages1[0].time, 0U); |
| |
| mSwapchain = swapchain1; |
| cleanUpSwapchainForTest(); |
| } |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, |
| ExtPresentTimingSuccessTimestampsRetiredSwapchain) { |
| // verify we return 0 timestamps when it returns success (with non-zero |
| // values) but the swapchain is retired. |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 3); |
| getANativeWindowFromReader(); |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| // Check if the required display timing extension is supported by the device |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| bool timingExtSupported = false; |
| for (const auto& extension : availableExtensions) { |
| if (strcmp(extension.extensionName, |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME) == 0) { |
| timingExtSupported = true; |
| break; |
| } |
| } |
| |
| if (!timingExtSupported) { |
| GTEST_SKIP() << "Vulkan extension " |
| << VK_EXT_PRESENT_TIMING_EXTENSION_NAME |
| << " not supported."; |
| } |
| |
| VkPhysicalDevicePresentTimingFeaturesEXT presentTimingFeatures = {}; |
| presentTimingFeatures.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; |
| presentTimingFeatures.presentTiming = VK_TRUE; |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions, |
| &presentTimingFeatures); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount > 0 && |
| imageCount > surfaceCaps.maxImageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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; |
| |
| // Set success interceptor |
| int result = |
| mWindow->perform(mWindow, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, |
| Hook_ANativeWindow_Perform_SuccessTimestamps_NonZero, |
| nullptr /* data */); |
| ASSERT_EQ(result, 0); |
| |
| // Create Swapchain 1 |
| VkSwapchainKHR swapchain1 = VK_NULL_HANDLE; |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &swapchain1); |
| VK_CHECK(res); |
| |
| uint32_t imageIndex; |
| res = vkAcquireNextImageKHR(mDevice, swapchain1, UINT64_MAX, VK_NULL_HANDLE, |
| VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| |
| VkPresentTimingInfoEXT presentTimingInfo = {}; |
| presentTimingInfo.presentStageQueries = |
| VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT; |
| presentTimingInfo.targetTime = 0; |
| |
| VkPresentTimingsInfoEXT presentTimingsInfo = {}; |
| presentTimingsInfo.sType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; |
| presentTimingsInfo.swapchainCount = 1; |
| presentTimingsInfo.pTimingInfos = &presentTimingInfo; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentTimingsInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &swapchain1; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| |
| // Retire Swapchain 1 with Swapchain 2 |
| VkSwapchainKHR swapchain2 = VK_NULL_HANDLE; |
| swapchainInfo.oldSwapchain = swapchain1; |
| res = vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &swapchain2); |
| VK_CHECK(res); |
| |
| auto pfnGetPastPresentationTimingEXT = |
| (PFN_vkGetPastPresentationTimingEXT)vkGetDeviceProcAddr( |
| mDevice, "vkGetPastPresentationTimingEXT"); |
| ASSERT_NE(pfnGetPastPresentationTimingEXT, |
| (PFN_vkGetPastPresentationTimingEXT) nullptr); |
| |
| // Query timing on Swapchain 1 (it is retired, interceptor returns 12345, so |
| // should be forced to 0) |
| VkPastPresentationTimingInfoEXT pastTimingInfo1 = {}; |
| pastTimingInfo1.sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; |
| pastTimingInfo1.swapchain = swapchain1; |
| |
| VkPastPresentationTimingPropertiesEXT pastTimingProps1 = {}; |
| pastTimingProps1.sType = |
| VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; |
| |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastTimingInfo1, |
| &pastTimingProps1); |
| VK_CHECK(res); |
| ASSERT_EQ(pastTimingProps1.presentationTimingCount, 1U); |
| |
| std::vector<VkPastPresentationTimingEXT> pastTimings1(1); |
| std::vector<VkPresentStageTimeEXT> stages1(1); |
| pastTimings1[0].sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; |
| pastTimings1[0].pPresentStages = stages1.data(); |
| pastTimingProps1.pPresentationTimings = pastTimings1.data(); |
| |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastTimingInfo1, |
| &pastTimingProps1); |
| VK_CHECK(res); |
| |
| EXPECT_EQ(pastTimings1[0].presentStageCount, 1U); |
| EXPECT_EQ(stages1[0].time, 0U); |
| |
| // Clean up |
| vkDestroySwapchainKHR(mDevice, swapchain1, nullptr); |
| mSwapchain = swapchain2; |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| } // namespace |
| |
| TEST_F(AImageReaderVulkanSwapchainTest, |
| GetPastPresentationTimingEXT_IncompleteQueryTest) { |
| // verify that returning VK_INCOMPLETE does not erase all ready timings |
| std::vector<const char*> instanceLayers = {}; |
| std::vector<const char*> deviceLayers = {}; |
| std::vector<const char*> deviceExtensions = { |
| VK_KHR_SWAPCHAIN_EXTENSION_NAME, |
| VK_EXT_PRESENT_TIMING_EXTENSION_NAME, |
| VK_KHR_PRESENT_ID_2_EXTENSION_NAME, |
| }; |
| |
| createVulkanInstance(instanceLayers); |
| createAImageReader(640, 480, AIMAGE_FORMAT_PRIVATE, 4); |
| getANativeWindowFromReader(); |
| |
| int result = mWindow->perform( |
| mWindow, NATIVE_WINDOW_SET_PERFORM_INTERCEPTOR, |
| Hook_ANativeWindow_Perform_FakeTimestamps, nullptr /* data */); |
| ASSERT_EQ(result, 0); |
| |
| createVulkanSurface(); |
| pickPhysicalDeviceAndQueueFamily(); |
| |
| uint32_t extensionCount = 0; |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| nullptr); |
| std::vector<VkExtensionProperties> availableExtensions(extensionCount); |
| vkEnumerateDeviceExtensionProperties(mPhysicalDev, nullptr, &extensionCount, |
| availableExtensions.data()); |
| |
| VkPhysicalDevicePresentId2FeaturesKHR presentId2Features = {}; |
| presentId2Features.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; |
| presentId2Features.presentId2 = VK_TRUE; |
| presentId2Features.pNext = nullptr; |
| |
| VkPhysicalDevicePresentTimingFeaturesEXT presentTimingFeatures = {}; |
| presentTimingFeatures.sType = |
| VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT; |
| presentTimingFeatures.presentTiming = VK_TRUE; |
| presentTimingFeatures.presentAtAbsoluteTime = VK_TRUE; |
| presentTimingFeatures.pNext = &presentId2Features; |
| |
| createDeviceAndGetQueue(deviceLayers, deviceExtensions, |
| &presentTimingFeatures); |
| |
| VkSurfaceCapabilitiesKHR surfaceCaps{}; |
| VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(mPhysicalDev, mSurface, |
| &surfaceCaps)); |
| |
| uint32_t imageCount = surfaceCaps.minImageCount + 1; |
| if (surfaceCaps.maxImageCount > 0 && |
| imageCount > surfaceCaps.maxImageCount) { |
| imageCount = surfaceCaps.maxImageCount; |
| } |
| |
| VkSwapchainCreateInfoKHR swapchainInfo{}; |
| swapchainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; |
| swapchainInfo.surface = mSurface; |
| swapchainInfo.minImageCount = imageCount; |
| swapchainInfo.imageFormat = VK_FORMAT_R8G8B8A8_UNORM; |
| swapchainInfo.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; |
| 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; |
| |
| VkResult res = |
| vkCreateSwapchainKHR(mDevice, &swapchainInfo, nullptr, &mSwapchain); |
| VK_CHECK(res); |
| ASSERT_NE(mSwapchain, (VkSwapchainKHR)VK_NULL_HANDLE); |
| |
| typedef VkResult(VKAPI_PTR * PFN_vkGetPastPresentationTimingEXT_Local)( |
| VkDevice, const VkPastPresentationTimingInfoEXT*, |
| VkPastPresentationTimingPropertiesEXT*); |
| auto pfnGetPastPresentationTimingEXT = |
| reinterpret_cast<PFN_vkGetPastPresentationTimingEXT_Local>( |
| vkGetDeviceProcAddr(mDevice, "vkGetPastPresentationTimingEXT")); |
| ASSERT_NE(pfnGetPastPresentationTimingEXT, nullptr); |
| |
| // Queue 2 presents |
| for (uint64_t i = 1; i <= 2; ++i) { |
| uint32_t imageIndex; |
| res = |
| vkAcquireNextImageKHR(mDevice, mSwapchain, UINT64_MAX, |
| VK_NULL_HANDLE, VK_NULL_HANDLE, &imageIndex); |
| VK_CHECK(res); |
| |
| VkPresentTimingInfoEXT presentTimingInfo = {}; |
| presentTimingInfo.presentStageQueries = |
| VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT | |
| VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT; |
| presentTimingInfo.targetTime = 1000 * i; |
| |
| VkPresentTimingsInfoEXT presentTimingsInfo = {}; |
| presentTimingsInfo.sType = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT; |
| presentTimingsInfo.swapchainCount = 1; |
| presentTimingsInfo.pTimingInfos = &presentTimingInfo; |
| |
| VkPresentId2KHR presentIdInfo = {}; |
| presentIdInfo.sType = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR; |
| presentIdInfo.swapchainCount = 1; |
| presentIdInfo.pPresentIds = &i; |
| presentIdInfo.pNext = &presentTimingsInfo; |
| |
| VkPresentInfoKHR presentInfo = {}; |
| presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; |
| presentInfo.pNext = &presentIdInfo; |
| presentInfo.swapchainCount = 1; |
| presentInfo.pSwapchains = &mSwapchain; |
| presentInfo.pImageIndices = &imageIndex; |
| |
| res = vkQueuePresentKHR(mPresentQueue, &presentInfo); |
| VK_CHECK(res); |
| } |
| |
| // Now query with count = 1 |
| VkPastPresentationTimingInfoEXT pastInfo = {}; |
| pastInfo.sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT; |
| pastInfo.swapchain = mSwapchain; |
| |
| VkPastPresentationTimingPropertiesEXT pastProps = {}; |
| pastProps.sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT; |
| |
| // First query just the count |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastInfo, &pastProps); |
| VK_CHECK(res); |
| ASSERT_EQ(pastProps.presentationTimingCount, 2); |
| |
| // Now query with 1 element array |
| VkPastPresentationTimingEXT timing1[1] = {}; |
| timing1[0].sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; |
| |
| VkPresentStageTimeEXT stages1[2] = {}; |
| timing1[0].pPresentStages = stages1; |
| |
| pastProps.presentationTimingCount = 1; |
| pastProps.pPresentationTimings = timing1; |
| |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastInfo, &pastProps); |
| ASSERT_EQ(res, VK_INCOMPLETE); |
| ASSERT_EQ(pastProps.presentationTimingCount, 1); |
| EXPECT_EQ(timing1[0].presentId, 1); |
| |
| // Query remaining elements |
| pastProps.pPresentationTimings = nullptr; |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastInfo, &pastProps); |
| VK_CHECK(res); |
| ASSERT_EQ(pastProps.presentationTimingCount, 1); |
| |
| VkPastPresentationTimingEXT timing2[1] = {}; |
| timing2[0].sType = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT; |
| |
| VkPresentStageTimeEXT stages2[2] = {}; |
| timing2[0].pPresentStages = stages2; |
| |
| pastProps.presentationTimingCount = 1; |
| pastProps.pPresentationTimings = timing2; |
| |
| res = pfnGetPastPresentationTimingEXT(mDevice, &pastInfo, &pastProps); |
| VK_CHECK(res); |
| ASSERT_EQ(pastProps.presentationTimingCount, 1); |
| EXPECT_EQ(timing2[0].presentId, 2); |
| |
| cleanUpSwapchainForTest(); |
| } |
| |
| } // namespace libvulkantest |
| |
| } // namespace android |
