Revert "libvulkan: Implement EXT_swapchain_maintenance1"
This reverts commit 08c7bb1fdb33d6ad34ba1b2de3ac0579750456fe.
Reason for revert: Possibly the cause of b/263412882 (will revert and see if that clears up the problem)
Change-Id: If217e36c67fcea8b5270dbf20b0c13c42d1da09a
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 0dac6ad..1bf7abb 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -291,9 +291,6 @@
release_fence(-1),
dequeued(false) {}
VkImage image;
- // If the image is bound to memory, an sp to the underlying gralloc buffer.
- // Otherwise, nullptr; the image will be bound to memory as part of
- // AcquireNextImage.
android::sp<ANativeWindowBuffer> buffer;
// The fence is only valid when the buffer is dequeued, and should be
// -1 any other time. When valid, we own the fd, and must ensure it is
@@ -655,40 +652,100 @@
VkSurfaceCapabilitiesKHR* capabilities) {
ATRACE_CALL();
- // Implement in terms of GetPhysicalDeviceSurfaceCapabilities2KHR
-
- VkPhysicalDeviceSurfaceInfo2KHR info2 = {
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
- nullptr,
- surface
- };
-
- VkSurfaceCapabilities2KHR caps2 = {
- VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
- nullptr,
- {},
- };
-
- VkResult result = GetPhysicalDeviceSurfaceCapabilities2KHR(pdev, &info2, &caps2);
- *capabilities = caps2.surfaceCapabilities;
- return result;
-}
-
-// Does the call-twice and VK_INCOMPLETE handling for querying lists
-// of things, where we already have the full set built in a vector.
-template <typename T>
-VkResult CopyWithIncomplete(std::vector<T> const& things,
- T* callerPtr, uint32_t* callerCount) {
- VkResult result = VK_SUCCESS;
- if (callerPtr) {
- if (things.size() > *callerCount)
- result = VK_INCOMPLETE;
- *callerCount = std::min(uint32_t(things.size()), *callerCount);
- std::copy(things.begin(), things.begin() + *callerCount, callerPtr);
+ int err;
+ int width, height;
+ int transform_hint;
+ int max_buffer_count;
+ if (surface == VK_NULL_HANDLE) {
+ const InstanceData& instance_data = GetData(pdev);
+ ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
+ bool surfaceless_enabled =
+ instance_data.hook_extensions.test(surfaceless);
+ if (!surfaceless_enabled) {
+ // It is an error to pass a surface==VK_NULL_HANDLE unless the
+ // VK_GOOGLE_surfaceless_query extension is enabled
+ return VK_ERROR_SURFACE_LOST_KHR;
+ }
+ // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
+ // extension for this function is for
+ // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following
+ // four values cannot be known without a surface. Default values will
+ // be supplied anyway, but cannot be relied upon.
+ width = 0xFFFFFFFF;
+ height = 0xFFFFFFFF;
+ transform_hint = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
+ capabilities->minImageCount = 0xFFFFFFFF;
+ capabilities->maxImageCount = 0xFFFFFFFF;
} else {
- *callerCount = things.size();
+ ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
+
+ err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
+ if (err != android::OK) {
+ ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
+ strerror(-err), err);
+ return VK_ERROR_SURFACE_LOST_KHR;
+ }
+ err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
+ if (err != android::OK) {
+ ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
+ strerror(-err), err);
+ return VK_ERROR_SURFACE_LOST_KHR;
+ }
+
+ err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
+ &transform_hint);
+ if (err != android::OK) {
+ ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
+ strerror(-err), err);
+ return VK_ERROR_SURFACE_LOST_KHR;
+ }
+
+ err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT,
+ &max_buffer_count);
+ if (err != android::OK) {
+ ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
+ strerror(-err), err);
+ return VK_ERROR_SURFACE_LOST_KHR;
+ }
+ capabilities->minImageCount = std::min(max_buffer_count, 3);
+ capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
}
- return result;
+
+ capabilities->currentExtent =
+ VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
+
+ // TODO(http://b/134182502): Figure out what the max extent should be.
+ capabilities->minImageExtent = VkExtent2D{1, 1};
+ capabilities->maxImageExtent = VkExtent2D{4096, 4096};
+
+ if (capabilities->maxImageExtent.height <
+ capabilities->currentExtent.height) {
+ capabilities->maxImageExtent.height =
+ capabilities->currentExtent.height;
+ }
+
+ if (capabilities->maxImageExtent.width <
+ capabilities->currentExtent.width) {
+ capabilities->maxImageExtent.width = capabilities->currentExtent.width;
+ }
+
+ capabilities->maxImageArrayLayers = 1;
+
+ capabilities->supportedTransforms = kSupportedTransforms;
+ capabilities->currentTransform =
+ TranslateNativeToVulkanTransform(transform_hint);
+
+ // On Android, window composition is a WindowManager property, not something
+ // associated with the bufferqueue. It can't be changed from here.
+ capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+
+ capabilities->supportedUsageFlags =
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+ VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+
+ return VK_SUCCESS;
}
VKAPI_ATTR
@@ -805,7 +862,21 @@
// Android users. This includes the ANGLE team (a layered implementation of
// OpenGL-ES).
- return CopyWithIncomplete(all_formats, formats, count);
+ VkResult result = VK_SUCCESS;
+ if (formats) {
+ uint32_t transfer_count = all_formats.size();
+ if (transfer_count > *count) {
+ transfer_count = *count;
+ result = VK_INCOMPLETE;
+ }
+ std::copy(all_formats.begin(), all_formats.begin() + transfer_count,
+ formats);
+ *count = transfer_count;
+ } else {
+ *count = all_formats.size();
+ }
+
+ return result;
}
VKAPI_ATTR
@@ -815,134 +886,19 @@
VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
ATRACE_CALL();
- auto surface = pSurfaceInfo->surface;
- auto capabilities = &pSurfaceCapabilities->surfaceCapabilities;
+ VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
+ physicalDevice, pSurfaceInfo->surface,
+ &pSurfaceCapabilities->surfaceCapabilities);
- VkSurfacePresentModeEXT const *pPresentMode = nullptr;
- for (auto pNext = reinterpret_cast<VkBaseInStructure const *>(pSurfaceInfo->pNext);
- pNext; pNext = reinterpret_cast<VkBaseInStructure const *>(pNext->pNext)) {
- switch (pNext->sType) {
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT:
- pPresentMode = reinterpret_cast<VkSurfacePresentModeEXT const *>(pNext);
- break;
+ VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
+ while (caps->pNext) {
+ caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
- default:
- break;
- }
- }
-
- int err;
- int width, height;
- int transform_hint;
- int max_buffer_count;
- if (surface == VK_NULL_HANDLE) {
- const InstanceData& instance_data = GetData(physicalDevice);
- ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query;
- bool surfaceless_enabled =
- instance_data.hook_extensions.test(surfaceless);
- if (!surfaceless_enabled) {
- // It is an error to pass a surface==VK_NULL_HANDLE unless the
- // VK_GOOGLE_surfaceless_query extension is enabled
- return VK_ERROR_SURFACE_LOST_KHR;
- }
- // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this
- // extension for this function is for
- // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following
- // four values cannot be known without a surface. Default values will
- // be supplied anyway, but cannot be relied upon.
- width = 0xFFFFFFFF;
- height = 0xFFFFFFFF;
- transform_hint = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
- capabilities->minImageCount = 0xFFFFFFFF;
- capabilities->maxImageCount = 0xFFFFFFFF;
- } else {
- ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
-
- err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
- if (err != android::OK) {
- ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
- strerror(-err), err);
- return VK_ERROR_SURFACE_LOST_KHR;
- }
- err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
- if (err != android::OK) {
- ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
- strerror(-err), err);
- return VK_ERROR_SURFACE_LOST_KHR;
- }
-
- err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT,
- &transform_hint);
- if (err != android::OK) {
- ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
- strerror(-err), err);
- return VK_ERROR_SURFACE_LOST_KHR;
- }
-
- err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT,
- &max_buffer_count);
- if (err != android::OK) {
- ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)",
- strerror(-err), err);
- return VK_ERROR_SURFACE_LOST_KHR;
- }
-
- if (pPresentMode && IsSharedPresentMode(pPresentMode->presentMode)) {
- capabilities->minImageCount = 1;
- capabilities->maxImageCount = 1;
- } else if (pPresentMode && pPresentMode->presentMode == VK_PRESENT_MODE_MAILBOX_KHR) {
- // TODO: use undequeued buffer requirement for more precise bound
- capabilities->minImageCount = std::min(max_buffer_count, 4);
- capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
- } else {
- // TODO: if we're able to, provide better bounds on the number of buffers
- // for other modes as well.
- capabilities->minImageCount = std::min(max_buffer_count, 3);
- capabilities->maxImageCount = static_cast<uint32_t>(max_buffer_count);
- }
- }
-
- capabilities->currentExtent =
- VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
-
- // TODO(http://b/134182502): Figure out what the max extent should be.
- capabilities->minImageExtent = VkExtent2D{1, 1};
- capabilities->maxImageExtent = VkExtent2D{4096, 4096};
-
- if (capabilities->maxImageExtent.height <
- capabilities->currentExtent.height) {
- capabilities->maxImageExtent.height =
- capabilities->currentExtent.height;
- }
-
- if (capabilities->maxImageExtent.width <
- capabilities->currentExtent.width) {
- capabilities->maxImageExtent.width = capabilities->currentExtent.width;
- }
-
- capabilities->maxImageArrayLayers = 1;
-
- capabilities->supportedTransforms = kSupportedTransforms;
- capabilities->currentTransform =
- TranslateNativeToVulkanTransform(transform_hint);
-
- // On Android, window composition is a WindowManager property, not something
- // associated with the bufferqueue. It can't be changed from here.
- capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
-
- capabilities->supportedUsageFlags =
- VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
- VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
- VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
- VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
-
- for (auto pNext = reinterpret_cast<VkBaseOutStructure*>(pSurfaceCapabilities->pNext);
- pNext; pNext = reinterpret_cast<VkBaseOutStructure*>(pNext->pNext)) {
-
- switch (pNext->sType) {
+ switch (caps->sType) {
case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
- reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(pNext);
+ reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
+ caps);
// Claim same set of usage flags are supported for
// shared present modes as for other modes.
shared_caps->sharedPresentSupportedUsageFlags =
@@ -952,64 +908,17 @@
case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
VkSurfaceProtectedCapabilitiesKHR* protected_caps =
- reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(pNext);
+ reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR*>(caps);
protected_caps->supportsProtected = VK_TRUE;
} break;
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
- VkSurfacePresentScalingCapabilitiesEXT* scaling_caps =
- reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(pNext);
- // By default, Android stretches the buffer to fit the window,
- // without preserving aspect ratio. Other modes are technically possible
- // but consult with CoGS team before exposing them here!
- scaling_caps->supportedPresentScaling = VK_PRESENT_SCALING_STRETCH_BIT_EXT;
-
- // Since we always scale, we don't support any gravity.
- scaling_caps->supportedPresentGravityX = 0;
- scaling_caps->supportedPresentGravityY = 0;
-
- // Scaled image limits are just the basic image limits
- scaling_caps->minScaledImageExtent = capabilities->minImageExtent;
- scaling_caps->maxScaledImageExtent = capabilities->maxImageExtent;
- } break;
-
- case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
- VkSurfacePresentModeCompatibilityEXT* mode_caps =
- reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(pNext);
-
- ALOG_ASSERT(pPresentMode,
- "querying VkSurfacePresentModeCompatibilityEXT "
- "requires VkSurfacePresentModeEXT to be provided");
- std::vector<VkPresentModeKHR> compatibleModes;
- compatibleModes.push_back(pPresentMode->presentMode);
-
- switch (pPresentMode->presentMode) {
- // Shared modes are both compatible with each other.
- case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:
- compatibleModes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
- break;
- case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:
- compatibleModes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
- break;
- default:
- // Other modes are only compatible with themselves.
- // TODO: consider whether switching between FIFO and MAILBOX is reasonable
- break;
- }
-
- // Note: this does not generate VK_INCOMPLETE since we're nested inside
- // a larger query and there would be no way to determine exactly where it came from.
- CopyWithIncomplete(compatibleModes, mode_caps->pPresentModes,
- &mode_caps->presentModeCount);
- } break;
-
default:
// Ignore all other extension structs
break;
}
}
- return VK_SUCCESS;
+ return result;
}
VKAPI_ATTR
@@ -1168,7 +1077,18 @@
present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
}
- return CopyWithIncomplete(present_modes, modes, count);
+ uint32_t num_modes = uint32_t(present_modes.size());
+
+ VkResult result = VK_SUCCESS;
+ if (modes) {
+ if (*count < num_modes)
+ result = VK_INCOMPLETE;
+ *count = std::min(*count, num_modes);
+ std::copy_n(present_modes.data(), *count, modes);
+ } else {
+ *count = num_modes;
+ }
+ return result;
}
VKAPI_ATTR
@@ -1454,7 +1374,8 @@
}
VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
- if (IsSharedPresentMode(create_info->presentMode)) {
+ if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
+ create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
err = native_window_set_shared_buffer_mode(window, true);
if (err != android::OK) {
@@ -1604,6 +1525,8 @@
Swapchain* swapchain = new (mem)
Swapchain(surface, num_images, create_info->presentMode,
TranslateVulkanToNativeTransform(create_info->preTransform));
+ // -- Dequeue all buffers and create a VkImage for each --
+ // Any failures during or after this must cancel the dequeued buffers.
VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
#pragma clang diagnostic push
@@ -1620,18 +1543,13 @@
#pragma clang diagnostic pop
.pNext = &swapchain_image_create,
};
-
VkImageCreateInfo image_create = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
- .pNext = nullptr,
+ .pNext = &image_native_buffer,
.flags = createProtectedSwapchain ? VK_IMAGE_CREATE_PROTECTED_BIT : 0u,
.imageType = VK_IMAGE_TYPE_2D,
.format = create_info->imageFormat,
- .extent = {
- create_info->imageExtent.width,
- create_info->imageExtent.height,
- 1
- },
+ .extent = {0, 0, 1},
.mipLevels = 1,
.arrayLayers = 1,
.samples = VK_SAMPLE_COUNT_1_BIT,
@@ -1642,87 +1560,60 @@
.pQueueFamilyIndices = create_info->pQueueFamilyIndices,
};
- // Note: don't do deferred allocation for shared present modes. There's only one buffer
- // involved so very little benefit.
- if ((create_info->flags & VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT) &&
- !IsSharedPresentMode(create_info->presentMode)) {
- // Don't want to touch the underlying gralloc buffers yet;
- // instead just create unbound VkImages which will later be bound to memory inside
- // AcquireNextImage.
- VkImageSwapchainCreateInfoKHR image_swapchain_create = {
- .sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
- .pNext = nullptr,
- .swapchain = HandleFromSwapchain(swapchain),
- };
- image_create.pNext = &image_swapchain_create;
+ for (uint32_t i = 0; i < num_images; i++) {
+ Swapchain::Image& img = swapchain->images[i];
- for (uint32_t i = 0; i < num_images; i++) {
- Swapchain::Image& img = swapchain->images[i];
- img.buffer = nullptr;
- img.dequeued = false;
-
- result = dispatch.CreateImage(device, &image_create, nullptr, &img.image);
- if (result != VK_SUCCESS) {
- ALOGD("vkCreateImage w/ for deferred swapchain image failed: %u", result);
- break;
+ ANativeWindowBuffer* buffer;
+ err = window->dequeueBuffer(window, &buffer, &img.dequeue_fence);
+ if (err != android::OK) {
+ ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
+ switch (-err) {
+ case ENOMEM:
+ result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
+ break;
+ default:
+ result = VK_ERROR_SURFACE_LOST_KHR;
+ break;
}
+ break;
}
- } else {
- // -- Dequeue all buffers and create a VkImage for each --
- // Any failures during or after this must cancel the dequeued buffers.
+ img.buffer = buffer;
+ img.dequeued = true;
- for (uint32_t i = 0; i < num_images; i++) {
- Swapchain::Image& img = swapchain->images[i];
+ image_create.extent =
+ VkExtent3D{static_cast<uint32_t>(img.buffer->width),
+ static_cast<uint32_t>(img.buffer->height),
+ 1};
+ image_native_buffer.handle = img.buffer->handle;
+ image_native_buffer.stride = img.buffer->stride;
+ image_native_buffer.format = img.buffer->format;
+ image_native_buffer.usage = int(img.buffer->usage);
+ android_convertGralloc0To1Usage(int(img.buffer->usage),
+ &image_native_buffer.usage2.producer,
+ &image_native_buffer.usage2.consumer);
+ image_native_buffer.usage3 = img.buffer->usage;
- ANativeWindowBuffer* buffer;
- err = window->dequeueBuffer(window, &buffer, &img.dequeue_fence);
- if (err != android::OK) {
- ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
- switch (-err) {
- case ENOMEM:
- result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
- break;
- default:
- result = VK_ERROR_SURFACE_LOST_KHR;
- break;
- }
- break;
- }
- img.buffer = buffer;
- img.dequeued = true;
-
- image_native_buffer.handle = img.buffer->handle;
- image_native_buffer.stride = img.buffer->stride;
- image_native_buffer.format = img.buffer->format;
- image_native_buffer.usage = int(img.buffer->usage);
- android_convertGralloc0To1Usage(int(img.buffer->usage),
- &image_native_buffer.usage2.producer,
- &image_native_buffer.usage2.consumer);
- image_native_buffer.usage3 = img.buffer->usage;
- image_create.pNext = &image_native_buffer;
-
- ATRACE_BEGIN("CreateImage");
- result =
- dispatch.CreateImage(device, &image_create, nullptr, &img.image);
- ATRACE_END();
- if (result != VK_SUCCESS) {
- ALOGD("vkCreateImage w/ native buffer failed: %u", result);
- break;
- }
+ ATRACE_BEGIN("CreateImage");
+ result =
+ dispatch.CreateImage(device, &image_create, nullptr, &img.image);
+ ATRACE_END();
+ if (result != VK_SUCCESS) {
+ ALOGD("vkCreateImage w/ native buffer failed: %u", result);
+ break;
}
+ }
- // -- Cancel all buffers, returning them to the queue --
- // If an error occurred before, also destroy the VkImage and release the
- // buffer reference. Otherwise, we retain a strong reference to the buffer.
- for (uint32_t i = 0; i < num_images; i++) {
- Swapchain::Image& img = swapchain->images[i];
- if (img.dequeued) {
- if (!swapchain->shared) {
- window->cancelBuffer(window, img.buffer.get(),
- img.dequeue_fence);
- img.dequeue_fence = -1;
- img.dequeued = false;
- }
+ // -- Cancel all buffers, returning them to the queue --
+ // If an error occurred before, also destroy the VkImage and release the
+ // buffer reference. Otherwise, we retain a strong reference to the buffer.
+ for (uint32_t i = 0; i < num_images; i++) {
+ Swapchain::Image& img = swapchain->images[i];
+ if (img.dequeued) {
+ if (!swapchain->shared) {
+ window->cancelBuffer(window, img.buffer.get(),
+ img.dequeue_fence);
+ img.dequeue_fence = -1;
+ img.dequeued = false;
}
}
}
@@ -1845,64 +1736,6 @@
break;
}
}
-
- // If this is a deferred alloc swapchain, this may be the first time we've
- // seen a particular buffer. If so, there should be an empty slot. Find it,
- // and bind the gralloc buffer to the VkImage for that slot. If there is no
- // empty slot, then we dequeued an unexpected buffer. Non-deferred swapchains
- // will also take this path, but will never have an empty slot since we
- // populated them all upfront.
- if (idx == swapchain.num_images) {
- for (idx = 0; idx < swapchain.num_images; idx++) {
- if (!swapchain.images[idx].buffer) {
- // Note: this structure is technically required for
- // Vulkan correctness, even though the driver is probably going
- // to use everything from the VkNativeBufferANDROID below.
- // This is kindof silly, but it's how we did the ANB
- // side of VK_KHR_swapchain v69, so we're stuck with it unless
- // we want to go tinkering with the ANB spec some more.
- VkBindImageMemorySwapchainInfoKHR bimsi = {
- .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
- .pNext = nullptr,
- .swapchain = swapchain_handle,
- .imageIndex = idx,
- };
- VkNativeBufferANDROID nb = {
- .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
- .pNext = &bimsi,
- .handle = buffer->handle,
- .stride = buffer->stride,
- .format = buffer->format,
- .usage = int(buffer->usage),
- };
- VkBindImageMemoryInfo bimi = {
- .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
- .pNext = &nb,
- .image = swapchain.images[idx].image,
- .memory = VK_NULL_HANDLE,
- .memoryOffset = 0,
- };
- result = GetData(device).driver.BindImageMemory2(device, 1, &bimi);
- if (result != VK_SUCCESS) {
- // This shouldn't really happen. If it does, something is probably
- // unrecoverably wrong with the swapchain and its images. Cancel
- // the buffer and declare the swapchain broken.
- ALOGE("failed to do deferred gralloc buffer bind");
- window->cancelBuffer(window, buffer, fence_fd);
- return VK_ERROR_OUT_OF_DATE_KHR;
- }
-
- swapchain.images[idx].dequeued = true;
- swapchain.images[idx].dequeue_fence = fence_fd;
- swapchain.images[idx].buffer = buffer;
- break;
- }
- }
- }
-
- // The buffer doesn't match any slot. This shouldn't normally happen, but is
- // possible if the bufferqueue is reconfigured behind libvulkan's back. If this
- // happens, just declare the swapchain to be broken and the app will recreate it.
if (idx == swapchain.num_images) {
ALOGE("dequeueBuffer returned unrecognized buffer");
window->cancelBuffer(window, buffer, fence_fd);
@@ -2028,32 +1861,12 @@
}
}
-// EXT_swapchain_maintenance1 present mode change
-static bool SetSwapchainPresentMode(ANativeWindow *window, VkPresentModeKHR mode) {
- // There is no dynamic switching between non-shared present modes.
- // All we support is switching between demand and continuous refresh.
- if (!IsSharedPresentMode(mode))
- return true;
-
- int err = native_window_set_auto_refresh(window,
- mode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
- if (err != android::OK) {
- ALOGE("native_window_set_auto_refresh() failed: %s (%d)",
- strerror(-err), err);
- return false;
- }
-
- return true;
-}
-
static VkResult PresentOneSwapchain(
VkQueue queue,
Swapchain& swapchain,
uint32_t imageIndex,
const VkPresentRegionKHR *pRegion,
const VkPresentTimeGOOGLE *pTime,
- VkFence presentFence,
- const VkPresentModeKHR *pPresentMode,
uint32_t waitSemaphoreCount,
const VkSemaphore *pWaitSemaphores) {
@@ -2084,33 +1897,12 @@
ANativeWindow* window = swapchain.surface.window.get();
if (swapchain_result == VK_SUCCESS) {
- if (presentFence != VK_NULL_HANDLE) {
- int fence_copy = fence < 0 ? -1 : dup(fence);
- VkImportFenceFdInfoKHR iffi = {
- VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
- nullptr,
- presentFence,
- VK_FENCE_IMPORT_TEMPORARY_BIT,
- VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,
- fence_copy,
- };
- if (VK_SUCCESS != dispatch.ImportFenceFdKHR(device, &iffi) && fence_copy >= 0) {
- // ImportFenceFdKHR takes ownership only if it succeeds
- close(fence_copy);
- }
- }
-
if (pRegion) {
SetSwapchainSurfaceDamage(window, pRegion);
}
if (pTime) {
SetSwapchainFrameTimestamp(swapchain, pTime);
}
- if (pPresentMode) {
- if (!SetSwapchainPresentMode(window, *pPresentMode))
- swapchain_result = WorstPresentResult(swapchain_result,
- VK_ERROR_SURFACE_LOST_KHR);
- }
err = window->queueBuffer(window, img.buffer.get(), fence);
// queueBuffer always closes fence, even on error
@@ -2191,9 +1983,6 @@
// Look at the pNext chain for supported extension structs:
const VkPresentRegionsKHR* present_regions = nullptr;
const VkPresentTimesInfoGOOGLE* present_times = nullptr;
- const VkSwapchainPresentFenceInfoEXT* present_fences = nullptr;
- const VkSwapchainPresentModeInfoEXT* present_modes = nullptr;
-
const VkPresentRegionsKHR* next =
reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
while (next) {
@@ -2205,14 +1994,6 @@
present_times =
reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT:
- present_fences =
- reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(next);
- break;
- case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT:
- present_modes =
- reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(next);
- break;
default:
ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
next->sType);
@@ -2228,15 +2009,6 @@
present_times->swapchainCount != present_info->swapchainCount,
"VkPresentTimesInfoGOOGLE::swapchainCount != "
"VkPresentInfo::swapchainCount");
- ALOGV_IF(present_fences &&
- present_fences->swapchainCount != present_info->swapchainCount,
- "VkSwapchainPresentFenceInfoEXT::swapchainCount != "
- "VkPresentInfo::swapchainCount");
- ALOGV_IF(present_modes &&
- present_modes->swapchainCount != present_info->swapchainCount,
- "VkSwapchainPresentModeInfoEXT::swapchainCount != "
- "VkPresentInfo::swapchainCount");
-
const VkPresentRegionKHR* regions =
(present_regions) ? present_regions->pRegions : nullptr;
const VkPresentTimeGOOGLE* times =
@@ -2252,8 +2024,6 @@
present_info->pImageIndices[sc],
(regions && !swapchain.mailbox_mode) ? ®ions[sc] : nullptr,
times ? ×[sc] : nullptr,
- present_fences ? present_fences->pFences[sc] : VK_NULL_HANDLE,
- present_modes ? &present_modes->pPresentModes[sc] : nullptr,
present_info->waitSemaphoreCount,
present_info->pWaitSemaphores);
@@ -2478,35 +2248,5 @@
out_bind_infos.empty() ? pBindInfos : out_bind_infos.data());
}
-VKAPI_ATTR
-VkResult ReleaseSwapchainImagesEXT(VkDevice /*device*/,
- const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {
- ATRACE_CALL();
-
- Swapchain& swapchain = *SwapchainFromHandle(pReleaseInfo->swapchain);
- ANativeWindow* window = swapchain.surface.window.get();
-
- // If in shared present mode, don't actually release the image back to the BQ.
- // Both sides share it forever.
- if (swapchain.shared)
- return VK_SUCCESS;
-
- for (uint32_t i = 0; i < pReleaseInfo->imageIndexCount; i++) {
- Swapchain::Image& img = swapchain.images[pReleaseInfo->pImageIndices[i]];
- window->cancelBuffer(window, img.buffer.get(), img.dequeue_fence);
-
- // cancelBuffer has taken ownership of the dequeue fence
- img.dequeue_fence = -1;
- // if we're still holding a release fence, get rid of it now
- if (img.release_fence >= 0) {
- close(img.release_fence);
- img.release_fence = -1;
- }
- img.dequeued = false;
- }
-
- return VK_SUCCESS;
-}
-
} // namespace driver
} // namespace vulkan