2 * Copyright 2015 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <grallocusage/GrallocUsageConversion.h>
21 #include <ui/BufferQueueDefs.h>
22 #include <sync/sync.h>
23 #include <utils/StrongPointer.h>
24 #include <utils/Vector.h>
25 #include <system/window.h>
29 // TODO(jessehall): Currently we don't have a good error code for when a native
30 // window operation fails. Just returning INITIALIZATION_FAILED for now. Later
31 // versions (post SDK 0.9) of the API/extension have a better error code.
32 // When updating to that version, audit all error returns.
38 const VkSurfaceTransformFlagsKHR kSupportedTransforms =
39 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR |
40 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR |
41 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR |
42 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR |
43 // TODO(jessehall): See TODO in TranslateNativeToVulkanTransform.
44 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR |
45 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR |
46 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR |
47 // VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR |
48 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
50 VkSurfaceTransformFlagBitsKHR TranslateNativeToVulkanTransform(int native) {
51 // Native and Vulkan transforms are isomorphic, but are represented
52 // differently. Vulkan transforms are built up of an optional horizontal
53 // mirror, followed by a clockwise 0/90/180/270-degree rotation. Native
54 // transforms are built up from a horizontal flip, vertical flip, and
55 // 90-degree rotation, all optional but always in that order.
57 // TODO(jessehall): For now, only support pure rotations, not
58 // flip or flip-and-rotate, until I have more time to test them and build
59 // sample code. As far as I know we never actually use anything besides
60 // pure rotations anyway.
64 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
65 // case NATIVE_WINDOW_TRANSFORM_FLIP_H: // 0x1
66 // return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR;
67 // case NATIVE_WINDOW_TRANSFORM_FLIP_V: // 0x2
68 // return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR;
69 case NATIVE_WINDOW_TRANSFORM_ROT_180: // FLIP_H | FLIP_V
70 return VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR;
71 case NATIVE_WINDOW_TRANSFORM_ROT_90: // 0x4
72 return VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR;
73 // case NATIVE_WINDOW_TRANSFORM_FLIP_H | NATIVE_WINDOW_TRANSFORM_ROT_90:
74 // return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR;
75 // case NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_ROT_90:
76 // return VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR;
77 case NATIVE_WINDOW_TRANSFORM_ROT_270: // FLIP_H | FLIP_V | ROT_90
78 return VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR;
79 case NATIVE_WINDOW_TRANSFORM_INVERSE_DISPLAY:
81 return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
85 int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
87 case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
88 return NATIVE_WINDOW_TRANSFORM_ROT_270;
89 case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
90 return NATIVE_WINDOW_TRANSFORM_ROT_180;
91 case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
92 return NATIVE_WINDOW_TRANSFORM_ROT_90;
93 // TODO(jessehall): See TODO in TranslateNativeToVulkanTransform.
94 // case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR:
95 // return NATIVE_WINDOW_TRANSFORM_FLIP_H;
96 // case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR:
97 // return NATIVE_WINDOW_TRANSFORM_FLIP_H |
98 // NATIVE_WINDOW_TRANSFORM_ROT_90;
99 // case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR:
100 // return NATIVE_WINDOW_TRANSFORM_FLIP_V;
101 // case VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR:
102 // return NATIVE_WINDOW_TRANSFORM_FLIP_V |
103 // NATIVE_WINDOW_TRANSFORM_ROT_90;
104 case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
105 case VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR:
113 TimingInfo() = default;
114 TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
115 : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
116 native_frame_id_(nativeFrameId) {}
118 return (timestamp_desired_present_time_ !=
119 NATIVE_WINDOW_TIMESTAMP_PENDING &&
120 timestamp_actual_present_time_ !=
121 NATIVE_WINDOW_TIMESTAMP_PENDING &&
122 timestamp_render_complete_time_ !=
123 NATIVE_WINDOW_TIMESTAMP_PENDING &&
124 timestamp_composition_latch_time_ !=
125 NATIVE_WINDOW_TIMESTAMP_PENDING);
127 void calculate(int64_t rdur) {
128 bool anyTimestampInvalid =
129 (timestamp_actual_present_time_ ==
130 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
131 (timestamp_render_complete_time_ ==
132 NATIVE_WINDOW_TIMESTAMP_INVALID) ||
133 (timestamp_composition_latch_time_ ==
134 NATIVE_WINDOW_TIMESTAMP_INVALID);
135 if (anyTimestampInvalid) {
136 ALOGE("Unexpectedly received invalid timestamp.");
137 vals_.actualPresentTime = 0;
138 vals_.earliestPresentTime = 0;
139 vals_.presentMargin = 0;
143 vals_.actualPresentTime =
144 static_cast<uint64_t>(timestamp_actual_present_time_);
145 int64_t margin = (timestamp_composition_latch_time_ -
146 timestamp_render_complete_time_);
147 // Calculate vals_.earliestPresentTime, and potentially adjust
148 // vals_.presentMargin. The initial value of vals_.earliestPresentTime
149 // is vals_.actualPresentTime. If we can subtract rdur (the duration
150 // of a refresh cycle) from vals_.earliestPresentTime (and also from
151 // vals_.presentMargin) and still leave a positive margin, then we can
152 // report to the application that it could have presented earlier than
153 // it did (per the extension specification). If for some reason, we
154 // can do this subtraction repeatedly, we do, since
155 // vals_.earliestPresentTime really is supposed to be the "earliest".
156 int64_t early_time = timestamp_actual_present_time_;
157 while ((margin > rdur) &&
158 ((early_time - rdur) > timestamp_composition_latch_time_)) {
162 vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
163 vals_.presentMargin = static_cast<uint64_t>(margin);
165 void get_values(VkPastPresentationTimingGOOGLE* values) const {
170 VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
172 uint64_t native_frame_id_ { 0 };
173 int64_t timestamp_desired_present_time_{ NATIVE_WINDOW_TIMESTAMP_PENDING };
174 int64_t timestamp_actual_present_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
175 int64_t timestamp_render_complete_time_ { NATIVE_WINDOW_TIMESTAMP_PENDING };
176 int64_t timestamp_composition_latch_time_
177 { NATIVE_WINDOW_TIMESTAMP_PENDING };
180 // ----------------------------------------------------------------------------
183 android::sp<ANativeWindow> window;
184 VkSwapchainKHR swapchain_handle;
187 VkSurfaceKHR HandleFromSurface(Surface* surface) {
188 return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
191 Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
192 return reinterpret_cast<Surface*>(handle);
195 // Maximum number of TimingInfo structs to keep per swapchain:
196 enum { MAX_TIMING_INFOS = 10 };
197 // Minimum number of frames to look for in the past (so we don't cause
198 // syncronous requests to Surface Flinger):
199 enum { MIN_NUM_FRAMES_AGO = 5 };
202 Swapchain(Surface& surface_,
203 uint32_t num_images_,
204 VkPresentModeKHR present_mode)
206 num_images(num_images_),
207 mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
208 frame_timestamps_enabled(false),
209 shared(present_mode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
210 present_mode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
211 ANativeWindow* window = surface.window.get();
212 native_window_get_refresh_cycle_duration(
220 bool frame_timestamps_enabled;
221 int64_t refresh_duration;
225 Image() : image(VK_NULL_HANDLE), dequeue_fence(-1), dequeued(false) {}
227 android::sp<ANativeWindowBuffer> buffer;
228 // The fence is only valid when the buffer is dequeued, and should be
229 // -1 any other time. When valid, we own the fd, and must ensure it is
230 // closed: either by closing it explicitly when queueing the buffer,
231 // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
234 } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
236 android::Vector<TimingInfo> timing;
239 VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
240 return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
243 Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
244 return reinterpret_cast<Swapchain*>(handle);
247 void ReleaseSwapchainImage(VkDevice device,
248 ANativeWindow* window,
250 Swapchain::Image& image) {
251 ALOG_ASSERT(release_fence == -1 || image.dequeued,
252 "ReleaseSwapchainImage: can't provide a release fence for "
253 "non-dequeued images");
255 if (image.dequeued) {
256 if (release_fence >= 0) {
257 // We get here from vkQueuePresentKHR. The application is
258 // responsible for creating an execution dependency chain from
259 // vkAcquireNextImage (dequeue_fence) to vkQueuePresentKHR
260 // (release_fence), so we can drop the dequeue_fence here.
261 if (image.dequeue_fence >= 0)
262 close(image.dequeue_fence);
264 // We get here during swapchain destruction, or various serious
265 // error cases e.g. when we can't create the release_fence during
266 // vkQueuePresentKHR. In non-error cases, the dequeue_fence should
267 // have already signalled, since the swapchain images are supposed
268 // to be idle before the swapchain is destroyed. In error cases,
269 // there may be rendering in flight to the image, but since we
270 // weren't able to create a release_fence, waiting for the
271 // dequeue_fence is about the best we can do.
272 release_fence = image.dequeue_fence;
274 image.dequeue_fence = -1;
277 window->cancelBuffer(window, image.buffer.get(), release_fence);
279 if (release_fence >= 0) {
280 sync_wait(release_fence, -1 /* forever */);
281 close(release_fence);
285 image.dequeued = false;
289 GetData(device).driver.DestroyImage(device, image.image, nullptr);
290 image.image = VK_NULL_HANDLE;
293 image.buffer.clear();
296 void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
297 if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
299 for (uint32_t i = 0; i < swapchain->num_images; i++) {
300 if (!swapchain->images[i].dequeued)
301 ReleaseSwapchainImage(device, nullptr, -1, swapchain->images[i]);
303 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
304 swapchain->timing.clear();
307 uint32_t get_num_ready_timings(Swapchain& swapchain) {
308 if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
312 uint32_t num_ready = 0;
313 const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
314 for (uint32_t i = 0; i < num_timings; i++) {
315 TimingInfo& ti = swapchain.timing.editItemAt(i);
317 // This TimingInfo is ready to be reported to the user. Add it
322 // This TimingInfo is not yet ready to be reported to the user,
323 // and so we should look for any available timestamps that
324 // might make it ready.
325 int64_t desired_present_time = 0;
326 int64_t render_complete_time = 0;
327 int64_t composition_latch_time = 0;
328 int64_t actual_present_time = 0;
329 // Obtain timestamps:
330 int ret = native_window_get_frame_timestamps(
331 swapchain.surface.window.get(), ti.native_frame_id_,
332 &desired_present_time, &render_complete_time,
333 &composition_latch_time,
334 NULL, //&first_composition_start_time,
335 NULL, //&last_composition_start_time,
336 NULL, //&composition_finish_time,
337 // TODO(ianelliott): Maybe ask if this one is
338 // supported, at startup time (since it may not be
340 &actual_present_time,
341 NULL, //&dequeue_ready_time,
342 NULL /*&reads_done_time*/);
344 if (ret != android::NO_ERROR) {
348 // Record the timestamp(s) we received, and then see if this TimingInfo
349 // is ready to be reported to the user:
350 ti.timestamp_desired_present_time_ = desired_present_time;
351 ti.timestamp_actual_present_time_ = actual_present_time;
352 ti.timestamp_render_complete_time_ = render_complete_time;
353 ti.timestamp_composition_latch_time_ = composition_latch_time;
356 // The TimingInfo has received enough timestamps, and should now
357 // use those timestamps to calculate the info that should be
358 // reported to the user:
359 ti.calculate(swapchain.refresh_duration);
366 // TODO(ianelliott): DEAL WITH RETURN VALUE (e.g. VK_INCOMPLETE)!!!
367 void copy_ready_timings(Swapchain& swapchain,
369 VkPastPresentationTimingGOOGLE* timings) {
370 if (swapchain.timing.empty()) {
375 size_t last_ready = swapchain.timing.size() - 1;
376 while (!swapchain.timing[last_ready].ready()) {
377 if (last_ready == 0) {
384 uint32_t num_copied = 0;
385 size_t num_to_remove = 0;
386 for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
387 const TimingInfo& ti = swapchain.timing[i];
389 ti.get_values(&timings[num_copied]);
395 // Discard old frames that aren't ready if newer frames are ready.
396 // We don't expect to get the timing info for those old frames.
397 swapchain.timing.removeItemsAt(0, num_to_remove);
402 android_pixel_format GetNativePixelFormat(VkFormat format) {
403 android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888;
405 case VK_FORMAT_R8G8B8A8_UNORM:
406 case VK_FORMAT_R8G8B8A8_SRGB:
407 native_format = HAL_PIXEL_FORMAT_RGBA_8888;
409 case VK_FORMAT_R5G6B5_UNORM_PACK16:
410 native_format = HAL_PIXEL_FORMAT_RGB_565;
412 case VK_FORMAT_R16G16B16A16_SFLOAT:
413 native_format = HAL_PIXEL_FORMAT_RGBA_FP16;
415 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
416 native_format = HAL_PIXEL_FORMAT_RGBA_1010102;
419 ALOGV("unsupported swapchain format %d", format);
422 return native_format;
425 android_dataspace GetNativeDataspace(VkColorSpaceKHR colorspace) {
426 switch (colorspace) {
427 case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:
428 return HAL_DATASPACE_V0_SRGB;
429 case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:
430 return HAL_DATASPACE_DISPLAY_P3;
431 case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:
432 return HAL_DATASPACE_V0_SCRGB_LINEAR;
433 case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:
434 return HAL_DATASPACE_DCI_P3_LINEAR;
435 case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:
436 return HAL_DATASPACE_DCI_P3;
437 case VK_COLOR_SPACE_BT709_LINEAR_EXT:
438 return HAL_DATASPACE_V0_SRGB_LINEAR;
439 case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:
440 return HAL_DATASPACE_V0_SRGB;
441 case VK_COLOR_SPACE_BT2020_LINEAR_EXT:
442 return HAL_DATASPACE_BT2020_LINEAR;
443 case VK_COLOR_SPACE_HDR10_ST2084_EXT:
444 return static_cast<android_dataspace>(
445 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
446 HAL_DATASPACE_RANGE_FULL);
447 case VK_COLOR_SPACE_DOLBYVISION_EXT:
448 return static_cast<android_dataspace>(
449 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_ST2084 |
450 HAL_DATASPACE_RANGE_FULL);
451 case VK_COLOR_SPACE_HDR10_HLG_EXT:
452 return static_cast<android_dataspace>(
453 HAL_DATASPACE_STANDARD_BT2020 | HAL_DATASPACE_TRANSFER_HLG |
454 HAL_DATASPACE_RANGE_FULL);
455 case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:
456 return static_cast<android_dataspace>(
457 HAL_DATASPACE_STANDARD_ADOBE_RGB |
458 HAL_DATASPACE_TRANSFER_LINEAR | HAL_DATASPACE_RANGE_FULL);
459 case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:
460 return HAL_DATASPACE_ADOBE_RGB;
462 // Pass through is intended to allow app to provide data that is passed
463 // to the display system without modification.
464 case VK_COLOR_SPACE_PASS_THROUGH_EXT:
465 return HAL_DATASPACE_ARBITRARY;
468 // This indicates that we don't know about the
469 // dataspace specified and we should indicate that
471 return HAL_DATASPACE_UNKNOWN;
475 } // anonymous namespace
478 VkResult CreateAndroidSurfaceKHR(
480 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
481 const VkAllocationCallbacks* allocator,
482 VkSurfaceKHR* out_surface) {
484 allocator = &GetData(instance).allocator;
485 void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
487 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
489 return VK_ERROR_OUT_OF_HOST_MEMORY;
490 Surface* surface = new (mem) Surface;
492 surface->window = pCreateInfo->window;
493 surface->swapchain_handle = VK_NULL_HANDLE;
495 // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
497 native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
499 // TODO(jessehall): Improve error reporting. Can we enumerate possible
500 // errors and translate them to valid Vulkan result codes?
501 ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
504 allocator->pfnFree(allocator->pUserData, surface);
505 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
508 *out_surface = HandleFromSurface(surface);
513 void DestroySurfaceKHR(VkInstance instance,
514 VkSurfaceKHR surface_handle,
515 const VkAllocationCallbacks* allocator) {
516 Surface* surface = SurfaceFromHandle(surface_handle);
519 native_window_api_disconnect(surface->window.get(), NATIVE_WINDOW_API_EGL);
520 ALOGV_IF(surface->swapchain_handle != VK_NULL_HANDLE,
521 "destroyed VkSurfaceKHR 0x%" PRIx64
522 " has active VkSwapchainKHR 0x%" PRIx64,
523 reinterpret_cast<uint64_t>(surface_handle),
524 reinterpret_cast<uint64_t>(surface->swapchain_handle));
527 allocator = &GetData(instance).allocator;
528 allocator->pfnFree(allocator->pUserData, surface);
532 VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
533 uint32_t /*queue_family*/,
534 VkSurfaceKHR /*surface*/,
535 VkBool32* supported) {
536 *supported = VK_TRUE;
541 VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
542 VkPhysicalDevice /*pdev*/,
543 VkSurfaceKHR surface,
544 VkSurfaceCapabilitiesKHR* capabilities) {
546 ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
549 err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
551 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
552 strerror(-err), err);
553 return VK_ERROR_SURFACE_LOST_KHR;
555 err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
557 ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
558 strerror(-err), err);
559 return VK_ERROR_SURFACE_LOST_KHR;
563 err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
565 ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
566 strerror(-err), err);
567 return VK_ERROR_SURFACE_LOST_KHR;
570 // TODO(jessehall): Figure out what the min/max values should be.
571 capabilities->minImageCount = 2;
572 capabilities->maxImageCount = 3;
574 capabilities->currentExtent =
575 VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
577 // TODO(jessehall): Figure out what the max extent should be. Maximum
578 // texture dimension maybe?
579 capabilities->minImageExtent = VkExtent2D{1, 1};
580 capabilities->maxImageExtent = VkExtent2D{4096, 4096};
582 capabilities->maxImageArrayLayers = 1;
584 capabilities->supportedTransforms = kSupportedTransforms;
585 capabilities->currentTransform =
586 TranslateNativeToVulkanTransform(transform_hint);
588 // On Android, window composition is a WindowManager property, not something
589 // associated with the bufferqueue. It can't be changed from here.
590 capabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
592 // TODO(jessehall): I think these are right, but haven't thought hard about
593 // it. Do we need to query the driver for support of any of these?
594 // Currently not included:
595 // - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
596 // - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
597 capabilities->supportedUsageFlags =
598 VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
599 VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
600 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
601 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
607 VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
608 VkSurfaceKHR surface_handle,
610 VkSurfaceFormatKHR* formats) {
611 const InstanceData& instance_data = GetData(pdev);
613 // TODO(jessehall): Fill out the set of supported formats. Longer term, add
614 // a new gralloc method to query whether a (format, usage) pair is
615 // supported, and check that for each gralloc format that corresponds to a
616 // Vulkan format. Shorter term, just add a few more formats to the ones
619 const VkSurfaceFormatKHR kFormats[] = {
620 {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
621 {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
622 {VK_FORMAT_R5G6B5_UNORM_PACK16, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR},
624 const uint32_t kNumFormats = sizeof(kFormats) / sizeof(kFormats[0]);
625 uint32_t total_num_formats = kNumFormats;
627 bool wide_color_support = false;
628 Surface& surface = *SurfaceFromHandle(surface_handle);
629 int err = native_window_get_wide_color_support(surface.window.get(),
630 &wide_color_support);
632 // Not allowed to return a more sensible error code, so do this
633 return VK_ERROR_OUT_OF_HOST_MEMORY;
635 ALOGV("wide_color_support is: %d", wide_color_support);
637 wide_color_support &&
638 instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
640 const VkSurfaceFormatKHR kWideColorFormats[] = {
641 {VK_FORMAT_R16G16B16A16_SFLOAT,
642 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT},
643 {VK_FORMAT_A2R10G10B10_UNORM_PACK32,
644 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT},
646 const uint32_t kNumWideColorFormats =
647 sizeof(kWideColorFormats) / sizeof(kWideColorFormats[0]);
648 if (wide_color_support) {
649 total_num_formats += kNumWideColorFormats;
652 VkResult result = VK_SUCCESS;
654 uint32_t out_count = 0;
655 uint32_t transfer_count = 0;
656 if (*count < total_num_formats)
657 result = VK_INCOMPLETE;
658 transfer_count = std::min(*count, kNumFormats);
659 std::copy(kFormats, kFormats + transfer_count, formats);
660 out_count += transfer_count;
661 if (wide_color_support) {
662 transfer_count = std::min(*count - out_count, kNumWideColorFormats);
663 std::copy(kWideColorFormats, kWideColorFormats + transfer_count,
664 formats + out_count);
665 out_count += transfer_count;
669 *count = total_num_formats;
675 VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
676 VkPhysicalDevice physicalDevice,
677 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
678 VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
679 VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
680 physicalDevice, pSurfaceInfo->surface,
681 &pSurfaceCapabilities->surfaceCapabilities);
683 VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
684 while (caps->pNext) {
685 caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
687 switch (caps->sType) {
688 case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
689 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
690 reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
692 // Claim same set of usage flags are supported for
693 // shared present modes as for other modes.
694 shared_caps->sharedPresentSupportedUsageFlags =
695 pSurfaceCapabilities->surfaceCapabilities
696 .supportedUsageFlags;
700 // Ignore all other extension structs
709 VkResult GetPhysicalDeviceSurfaceFormats2KHR(
710 VkPhysicalDevice physicalDevice,
711 const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
712 uint32_t* pSurfaceFormatCount,
713 VkSurfaceFormat2KHR* pSurfaceFormats) {
714 if (!pSurfaceFormats) {
715 return GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice,
716 pSurfaceInfo->surface,
717 pSurfaceFormatCount, nullptr);
719 // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
721 android::Vector<VkSurfaceFormatKHR> surface_formats;
722 surface_formats.resize(*pSurfaceFormatCount);
723 VkResult result = GetPhysicalDeviceSurfaceFormatsKHR(
724 physicalDevice, pSurfaceInfo->surface, pSurfaceFormatCount,
725 &surface_formats.editItemAt(0));
727 if (result == VK_SUCCESS || result == VK_INCOMPLETE) {
728 // marshal results individually due to stride difference.
729 // completely ignore any chained extension structs.
730 uint32_t formats_to_marshal = *pSurfaceFormatCount;
731 for (uint32_t i = 0u; i < formats_to_marshal; i++) {
732 pSurfaceFormats[i].surfaceFormat = surface_formats[i];
741 VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
742 VkSurfaceKHR /*surface*/,
744 VkPresentModeKHR* modes) {
745 android::Vector<VkPresentModeKHR> present_modes;
746 present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR);
747 present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR);
749 VkPhysicalDevicePresentationPropertiesANDROID present_properties;
750 if (QueryPresentationProperties(pdev, &present_properties)) {
751 if (present_properties.sharedImage) {
752 present_modes.push_back(VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR);
753 present_modes.push_back(VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR);
757 uint32_t num_modes = uint32_t(present_modes.size());
759 VkResult result = VK_SUCCESS;
761 if (*count < num_modes)
762 result = VK_INCOMPLETE;
763 *count = std::min(*count, num_modes);
764 std::copy(present_modes.begin(), present_modes.begin() + int(*count), modes);
772 VkResult CreateSwapchainKHR(VkDevice device,
773 const VkSwapchainCreateInfoKHR* create_info,
774 const VkAllocationCallbacks* allocator,
775 VkSwapchainKHR* swapchain_handle) {
777 VkResult result = VK_SUCCESS;
779 ALOGV("vkCreateSwapchainKHR: surface=0x%" PRIx64
780 " minImageCount=%u imageFormat=%u imageColorSpace=%u"
781 " imageExtent=%ux%u imageUsage=%#x preTransform=%u presentMode=%u"
782 " oldSwapchain=0x%" PRIx64,
783 reinterpret_cast<uint64_t>(create_info->surface),
784 create_info->minImageCount, create_info->imageFormat,
785 create_info->imageColorSpace, create_info->imageExtent.width,
786 create_info->imageExtent.height, create_info->imageUsage,
787 create_info->preTransform, create_info->presentMode,
788 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
791 allocator = &GetData(device).allocator;
793 android_pixel_format native_pixel_format =
794 GetNativePixelFormat(create_info->imageFormat);
795 android_dataspace native_dataspace =
796 GetNativeDataspace(create_info->imageColorSpace);
797 if (native_dataspace == HAL_DATASPACE_UNKNOWN) {
799 "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
800 "failed: Unsupported color space",
801 create_info->imageColorSpace);
802 return VK_ERROR_INITIALIZATION_FAILED;
805 ALOGV_IF(create_info->imageArrayLayers != 1,
806 "swapchain imageArrayLayers=%u not supported",
807 create_info->imageArrayLayers);
808 ALOGV_IF((create_info->preTransform & ~kSupportedTransforms) != 0,
809 "swapchain preTransform=%#x not supported",
810 create_info->preTransform);
811 ALOGV_IF(!(create_info->presentMode == VK_PRESENT_MODE_FIFO_KHR ||
812 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ||
813 create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
814 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR),
815 "swapchain presentMode=%u not supported",
816 create_info->presentMode);
818 Surface& surface = *SurfaceFromHandle(create_info->surface);
820 if (surface.swapchain_handle != create_info->oldSwapchain) {
821 ALOGV("Can't create a swapchain for VkSurfaceKHR 0x%" PRIx64
822 " because it already has active swapchain 0x%" PRIx64
823 " but VkSwapchainCreateInfo::oldSwapchain=0x%" PRIx64,
824 reinterpret_cast<uint64_t>(create_info->surface),
825 reinterpret_cast<uint64_t>(surface.swapchain_handle),
826 reinterpret_cast<uint64_t>(create_info->oldSwapchain));
827 return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
829 if (create_info->oldSwapchain != VK_NULL_HANDLE)
830 OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
832 // -- Reset the native window --
833 // The native window might have been used previously, and had its properties
834 // changed from defaults. That will affect the answer we get for queries
835 // like MIN_UNDEQUED_BUFFERS. Reset to a known/default state before we
836 // attempt such queries.
838 // The native window only allows dequeueing all buffers before any have
839 // been queued, since after that point at least one is assumed to be in
840 // non-FREE state at any given time. Disconnecting and re-connecting
841 // orphans the previous buffers, getting us back to the state where we can
842 // dequeue all buffers.
843 err = native_window_api_disconnect(surface.window.get(),
844 NATIVE_WINDOW_API_EGL);
845 ALOGW_IF(err != 0, "native_window_api_disconnect failed: %s (%d)",
846 strerror(-err), err);
848 native_window_api_connect(surface.window.get(), NATIVE_WINDOW_API_EGL);
849 ALOGW_IF(err != 0, "native_window_api_connect failed: %s (%d)",
850 strerror(-err), err);
852 err = native_window_set_buffer_count(surface.window.get(), 0);
854 ALOGE("native_window_set_buffer_count(0) failed: %s (%d)",
855 strerror(-err), err);
856 return VK_ERROR_SURFACE_LOST_KHR;
860 create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
861 err = surface.window->setSwapInterval(surface.window.get(), swap_interval);
863 // TODO(jessehall): Improve error reporting. Can we enumerate possible
864 // errors and translate them to valid Vulkan result codes?
865 ALOGE("native_window->setSwapInterval(1) failed: %s (%d)",
866 strerror(-err), err);
867 return VK_ERROR_SURFACE_LOST_KHR;
870 err = native_window_set_shared_buffer_mode(surface.window.get(), false);
872 ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
873 strerror(-err), err);
874 return VK_ERROR_SURFACE_LOST_KHR;
877 err = native_window_set_auto_refresh(surface.window.get(), false);
879 ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
880 strerror(-err), err);
881 return VK_ERROR_SURFACE_LOST_KHR;
884 // -- Configure the native window --
886 const auto& dispatch = GetData(device).driver;
888 err = native_window_set_buffers_format(surface.window.get(),
889 native_pixel_format);
891 // TODO(jessehall): Improve error reporting. Can we enumerate possible
892 // errors and translate them to valid Vulkan result codes?
893 ALOGE("native_window_set_buffers_format(%d) failed: %s (%d)",
894 native_pixel_format, strerror(-err), err);
895 return VK_ERROR_SURFACE_LOST_KHR;
897 err = native_window_set_buffers_data_space(surface.window.get(),
900 // TODO(jessehall): Improve error reporting. Can we enumerate possible
901 // errors and translate them to valid Vulkan result codes?
902 ALOGE("native_window_set_buffers_data_space(%d) failed: %s (%d)",
903 native_dataspace, strerror(-err), err);
904 return VK_ERROR_SURFACE_LOST_KHR;
907 err = native_window_set_buffers_dimensions(
908 surface.window.get(), static_cast<int>(create_info->imageExtent.width),
909 static_cast<int>(create_info->imageExtent.height));
911 // TODO(jessehall): Improve error reporting. Can we enumerate possible
912 // errors and translate them to valid Vulkan result codes?
913 ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
914 create_info->imageExtent.width, create_info->imageExtent.height,
915 strerror(-err), err);
916 return VK_ERROR_SURFACE_LOST_KHR;
919 // VkSwapchainCreateInfo::preTransform indicates the transformation the app
920 // applied during rendering. native_window_set_transform() expects the
921 // inverse: the transform the app is requesting that the compositor perform
922 // during composition. With native windows, pre-transform works by rendering
923 // with the same transform the compositor is applying (as in Vulkan), but
924 // then requesting the inverse transform, so that when the compositor does
925 // it's job the two transforms cancel each other out and the compositor ends
926 // up applying an identity transform to the app's buffer.
927 err = native_window_set_buffers_transform(
928 surface.window.get(),
929 InvertTransformToNative(create_info->preTransform));
931 // TODO(jessehall): Improve error reporting. Can we enumerate possible
932 // errors and translate them to valid Vulkan result codes?
933 ALOGE("native_window_set_buffers_transform(%d) failed: %s (%d)",
934 InvertTransformToNative(create_info->preTransform),
935 strerror(-err), err);
936 return VK_ERROR_SURFACE_LOST_KHR;
939 err = native_window_set_scaling_mode(
940 surface.window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
942 // TODO(jessehall): Improve error reporting. Can we enumerate possible
943 // errors and translate them to valid Vulkan result codes?
944 ALOGE("native_window_set_scaling_mode(SCALE_TO_WINDOW) failed: %s (%d)",
945 strerror(-err), err);
946 return VK_ERROR_SURFACE_LOST_KHR;
949 VkSwapchainImageUsageFlagsANDROID swapchain_image_usage = 0;
950 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR ||
951 create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
952 swapchain_image_usage |= VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID;
953 err = native_window_set_shared_buffer_mode(surface.window.get(), true);
955 ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
956 return VK_ERROR_SURFACE_LOST_KHR;
960 if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
961 err = native_window_set_auto_refresh(surface.window.get(), true);
963 ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
964 return VK_ERROR_SURFACE_LOST_KHR;
969 err = surface.window->query(surface.window.get(),
970 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
972 if (err != 0 || query_value < 0) {
973 // TODO(jessehall): Improve error reporting. Can we enumerate possible
974 // errors and translate them to valid Vulkan result codes?
975 ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err,
977 return VK_ERROR_SURFACE_LOST_KHR;
979 uint32_t min_undequeued_buffers = static_cast<uint32_t>(query_value);
980 uint32_t num_images =
981 (create_info->minImageCount - 1) + min_undequeued_buffers;
983 // Lower layer insists that we have at least two buffers. This is wasteful
984 // and we'd like to relax it in the shared case, but not all the pieces are
985 // in place for that to work yet. Note we only lie to the lower layer-- we
986 // don't want to give the app back a swapchain with extra images (which they
987 // can't actually use!).
988 err = native_window_set_buffer_count(surface.window.get(), std::max(2u, num_images));
990 // TODO(jessehall): Improve error reporting. Can we enumerate possible
991 // errors and translate them to valid Vulkan result codes?
992 ALOGE("native_window_set_buffer_count(%d) failed: %s (%d)", num_images,
993 strerror(-err), err);
994 return VK_ERROR_SURFACE_LOST_KHR;
997 int gralloc_usage = 0;
998 if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
999 uint64_t consumer_usage, producer_usage;
1000 result = dispatch.GetSwapchainGrallocUsage2ANDROID(
1001 device, create_info->imageFormat, create_info->imageUsage,
1002 swapchain_image_usage, &consumer_usage, &producer_usage);
1003 if (result != VK_SUCCESS) {
1004 ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
1005 return VK_ERROR_SURFACE_LOST_KHR;
1008 android_convertGralloc1To0Usage(producer_usage, consumer_usage);
1009 } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
1010 result = dispatch.GetSwapchainGrallocUsageANDROID(
1011 device, create_info->imageFormat, create_info->imageUsage,
1013 if (result != VK_SUCCESS) {
1014 ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
1015 return VK_ERROR_SURFACE_LOST_KHR;
1018 err = native_window_set_usage(surface.window.get(), gralloc_usage);
1020 // TODO(jessehall): Improve error reporting. Can we enumerate possible
1021 // errors and translate them to valid Vulkan result codes?
1022 ALOGE("native_window_set_usage failed: %s (%d)", strerror(-err), err);
1023 return VK_ERROR_SURFACE_LOST_KHR;
1026 // -- Allocate our Swapchain object --
1027 // After this point, we must deallocate the swapchain on error.
1029 void* mem = allocator->pfnAllocation(allocator->pUserData,
1030 sizeof(Swapchain), alignof(Swapchain),
1031 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
1033 return VK_ERROR_OUT_OF_HOST_MEMORY;
1034 Swapchain* swapchain =
1035 new (mem) Swapchain(surface, num_images, create_info->presentMode);
1037 // -- Dequeue all buffers and create a VkImage for each --
1038 // Any failures during or after this must cancel the dequeued buffers.
1040 VkSwapchainImageCreateInfoANDROID swapchain_image_create = {
1041 #pragma clang diagnostic push
1042 #pragma clang diagnostic ignored "-Wold-style-cast"
1043 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
1044 #pragma clang diagnostic pop
1046 .usage = swapchain_image_usage,
1048 VkNativeBufferANDROID image_native_buffer = {
1049 #pragma clang diagnostic push
1050 #pragma clang diagnostic ignored "-Wold-style-cast"
1051 .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
1052 #pragma clang diagnostic pop
1053 .pNext = &swapchain_image_create,
1055 VkImageCreateInfo image_create = {
1056 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1057 .pNext = &image_native_buffer,
1058 .imageType = VK_IMAGE_TYPE_2D,
1059 .format = create_info->imageFormat,
1060 .extent = {0, 0, 1},
1063 .samples = VK_SAMPLE_COUNT_1_BIT,
1064 .tiling = VK_IMAGE_TILING_OPTIMAL,
1065 .usage = create_info->imageUsage,
1067 .sharingMode = create_info->imageSharingMode,
1068 .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
1069 .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1072 for (uint32_t i = 0; i < num_images; i++) {
1073 Swapchain::Image& img = swapchain->images[i];
1075 ANativeWindowBuffer* buffer;
1076 err = surface.window->dequeueBuffer(surface.window.get(), &buffer,
1077 &img.dequeue_fence);
1079 // TODO(jessehall): Improve error reporting. Can we enumerate
1080 // possible errors and translate them to valid Vulkan result codes?
1081 ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
1082 result = VK_ERROR_SURFACE_LOST_KHR;
1085 img.buffer = buffer;
1086 img.dequeued = true;
1088 image_create.extent =
1089 VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1090 static_cast<uint32_t>(img.buffer->height),
1092 image_native_buffer.handle = img.buffer->handle;
1093 image_native_buffer.stride = img.buffer->stride;
1094 image_native_buffer.format = img.buffer->format;
1095 image_native_buffer.usage = img.buffer->usage;
1096 // TODO: Adjust once ANativeWindowBuffer supports gralloc1-style usage.
1097 // For now, this is the same translation Gralloc1On0Adapter does.
1098 image_native_buffer.usage2.consumer =
1099 static_cast<uint64_t>(img.buffer->usage);
1100 image_native_buffer.usage2.producer =
1101 static_cast<uint64_t>(img.buffer->usage);
1104 dispatch.CreateImage(device, &image_create, nullptr, &img.image);
1105 if (result != VK_SUCCESS) {
1106 ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1111 // -- Cancel all buffers, returning them to the queue --
1112 // If an error occurred before, also destroy the VkImage and release the
1113 // buffer reference. Otherwise, we retain a strong reference to the buffer.
1115 // TODO(jessehall): The error path here is the same as DestroySwapchain,
1116 // but not the non-error path. Should refactor/unify.
1117 if (!swapchain->shared) {
1118 for (uint32_t i = 0; i < num_images; i++) {
1119 Swapchain::Image& img = swapchain->images[i];
1121 surface.window->cancelBuffer(surface.window.get(), img.buffer.get(),
1123 img.dequeue_fence = -1;
1124 img.dequeued = false;
1126 if (result != VK_SUCCESS) {
1128 dispatch.DestroyImage(device, img.image, nullptr);
1133 if (result != VK_SUCCESS) {
1134 swapchain->~Swapchain();
1135 allocator->pfnFree(allocator->pUserData, swapchain);
1139 surface.swapchain_handle = HandleFromSwapchain(swapchain);
1140 *swapchain_handle = surface.swapchain_handle;
1145 void DestroySwapchainKHR(VkDevice device,
1146 VkSwapchainKHR swapchain_handle,
1147 const VkAllocationCallbacks* allocator) {
1148 const auto& dispatch = GetData(device).driver;
1149 Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
1152 bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1153 ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
1155 if (swapchain->frame_timestamps_enabled) {
1156 native_window_enable_frame_timestamps(window, false);
1158 for (uint32_t i = 0; i < swapchain->num_images; i++)
1159 ReleaseSwapchainImage(device, window, -1, swapchain->images[i]);
1161 swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
1163 allocator = &GetData(device).allocator;
1164 swapchain->~Swapchain();
1165 allocator->pfnFree(allocator->pUserData, swapchain);
1169 VkResult GetSwapchainImagesKHR(VkDevice,
1170 VkSwapchainKHR swapchain_handle,
1173 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1174 ALOGW_IF(swapchain.surface.swapchain_handle != swapchain_handle,
1175 "getting images for non-active swapchain 0x%" PRIx64
1176 "; only dequeued image handles are valid",
1177 reinterpret_cast<uint64_t>(swapchain_handle));
1178 VkResult result = VK_SUCCESS;
1180 uint32_t n = swapchain.num_images;
1181 if (*count < swapchain.num_images) {
1183 result = VK_INCOMPLETE;
1185 for (uint32_t i = 0; i < n; i++)
1186 images[i] = swapchain.images[i].image;
1189 *count = swapchain.num_images;
1195 VkResult AcquireNextImageKHR(VkDevice device,
1196 VkSwapchainKHR swapchain_handle,
1198 VkSemaphore semaphore,
1200 uint32_t* image_index) {
1201 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1202 ANativeWindow* window = swapchain.surface.window.get();
1206 if (swapchain.surface.swapchain_handle != swapchain_handle)
1207 return VK_ERROR_OUT_OF_DATE_KHR;
1210 timeout != UINT64_MAX,
1211 "vkAcquireNextImageKHR: non-infinite timeouts not yet implemented");
1213 if (swapchain.shared) {
1214 // In shared mode, we keep the buffer dequeued all the time, so we don't
1215 // want to dequeue a buffer here. Instead, just ask the driver to ensure
1216 // the semaphore and fence passed to us will be signalled.
1218 result = GetData(device).driver.AcquireImageANDROID(
1219 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1223 ANativeWindowBuffer* buffer;
1225 err = window->dequeueBuffer(window, &buffer, &fence_fd);
1227 // TODO(jessehall): Improve error reporting. Can we enumerate possible
1228 // errors and translate them to valid Vulkan result codes?
1229 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1230 return VK_ERROR_SURFACE_LOST_KHR;
1234 for (idx = 0; idx < swapchain.num_images; idx++) {
1235 if (swapchain.images[idx].buffer.get() == buffer) {
1236 swapchain.images[idx].dequeued = true;
1237 swapchain.images[idx].dequeue_fence = fence_fd;
1241 if (idx == swapchain.num_images) {
1242 ALOGE("dequeueBuffer returned unrecognized buffer");
1243 window->cancelBuffer(window, buffer, fence_fd);
1244 return VK_ERROR_OUT_OF_DATE_KHR;
1247 int fence_clone = -1;
1248 if (fence_fd != -1) {
1249 fence_clone = dup(fence_fd);
1250 if (fence_clone == -1) {
1251 ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
1252 strerror(errno), errno);
1253 sync_wait(fence_fd, -1 /* forever */);
1257 result = GetData(device).driver.AcquireImageANDROID(
1258 device, swapchain.images[idx].image, fence_clone, semaphore, vk_fence);
1259 if (result != VK_SUCCESS) {
1260 // NOTE: we're relying on AcquireImageANDROID to close fence_clone,
1261 // even if the call fails. We could close it ourselves on failure, but
1262 // that would create a race condition if the driver closes it on a
1263 // failure path: some other thread might create an fd with the same
1264 // number between the time the driver closes it and the time we close
1265 // it. We must assume one of: the driver *always* closes it even on
1266 // failure, or *never* closes it on failure.
1267 window->cancelBuffer(window, buffer, fence_fd);
1268 swapchain.images[idx].dequeued = false;
1269 swapchain.images[idx].dequeue_fence = -1;
1277 static VkResult WorstPresentResult(VkResult a, VkResult b) {
1278 // See the error ranking for vkQueuePresentKHR at the end of section 29.6
1279 // (in spec version 1.0.14).
1280 static const VkResult kWorstToBest[] = {
1281 VK_ERROR_DEVICE_LOST,
1282 VK_ERROR_SURFACE_LOST_KHR,
1283 VK_ERROR_OUT_OF_DATE_KHR,
1284 VK_ERROR_OUT_OF_DEVICE_MEMORY,
1285 VK_ERROR_OUT_OF_HOST_MEMORY,
1288 for (auto result : kWorstToBest) {
1289 if (a == result || b == result)
1292 ALOG_ASSERT(a == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", a);
1293 ALOG_ASSERT(b == VK_SUCCESS, "invalid vkQueuePresentKHR result %d", b);
1294 return a != VK_SUCCESS ? a : b;
1298 VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* present_info) {
1299 ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1300 "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
1301 present_info->sType);
1303 VkDevice device = GetData(queue).driver_device;
1304 const auto& dispatch = GetData(queue).driver;
1305 VkResult final_result = VK_SUCCESS;
1307 // Look at the pNext chain for supported extension structs:
1308 const VkPresentRegionsKHR* present_regions = nullptr;
1309 const VkPresentTimesInfoGOOGLE* present_times = nullptr;
1310 const VkPresentRegionsKHR* next =
1311 reinterpret_cast<const VkPresentRegionsKHR*>(present_info->pNext);
1313 switch (next->sType) {
1314 case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1315 present_regions = next;
1317 case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
1319 reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1322 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1326 next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1330 present_regions->swapchainCount != present_info->swapchainCount,
1331 "VkPresentRegions::swapchainCount != VkPresentInfo::swapchainCount");
1332 ALOGV_IF(present_times &&
1333 present_times->swapchainCount != present_info->swapchainCount,
1334 "VkPresentTimesInfoGOOGLE::swapchainCount != "
1335 "VkPresentInfo::swapchainCount");
1336 const VkPresentRegionKHR* regions =
1337 (present_regions) ? present_regions->pRegions : nullptr;
1338 const VkPresentTimeGOOGLE* times =
1339 (present_times) ? present_times->pTimes : nullptr;
1340 const VkAllocationCallbacks* allocator = &GetData(device).allocator;
1341 android_native_rect_t* rects = nullptr;
1342 uint32_t nrects = 0;
1344 for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
1345 Swapchain& swapchain =
1346 *SwapchainFromHandle(present_info->pSwapchains[sc]);
1347 uint32_t image_idx = present_info->pImageIndices[sc];
1348 Swapchain::Image& img = swapchain.images[image_idx];
1349 const VkPresentRegionKHR* region =
1350 (regions && !swapchain.mailbox_mode) ? ®ions[sc] : nullptr;
1351 const VkPresentTimeGOOGLE* time = (times) ? ×[sc] : nullptr;
1352 VkResult swapchain_result = VK_SUCCESS;
1357 result = dispatch.QueueSignalReleaseImageANDROID(
1358 queue, present_info->waitSemaphoreCount,
1359 present_info->pWaitSemaphores, img.image, &fence);
1360 if (result != VK_SUCCESS) {
1361 ALOGE("QueueSignalReleaseImageANDROID failed: %d", result);
1362 swapchain_result = result;
1365 if (swapchain.surface.swapchain_handle ==
1366 present_info->pSwapchains[sc]) {
1367 ANativeWindow* window = swapchain.surface.window.get();
1368 if (swapchain_result == VK_SUCCESS) {
1370 // Process the incremental-present hint for this swapchain:
1371 uint32_t rcount = region->rectangleCount;
1372 if (rcount > nrects) {
1373 android_native_rect_t* new_rects =
1374 static_cast<android_native_rect_t*>(
1375 allocator->pfnReallocation(
1376 allocator->pUserData, rects,
1377 sizeof(android_native_rect_t) * rcount,
1378 alignof(android_native_rect_t),
1379 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
1384 rcount = 0; // Ignore the hint for this swapchain
1387 for (uint32_t r = 0; r < rcount; ++r) {
1388 if (region->pRectangles[r].layer > 0) {
1390 "vkQueuePresentKHR ignoring invalid layer "
1391 "(%u); using layer 0 instead",
1392 region->pRectangles[r].layer);
1394 int x = region->pRectangles[r].offset.x;
1395 int y = region->pRectangles[r].offset.y;
1396 int width = static_cast<int>(
1397 region->pRectangles[r].extent.width);
1398 int height = static_cast<int>(
1399 region->pRectangles[r].extent.height);
1400 android_native_rect_t* cur_rect = &rects[r];
1402 cur_rect->top = y + height;
1403 cur_rect->right = x + width;
1404 cur_rect->bottom = y;
1406 native_window_set_surface_damage(window, rects, rcount);
1409 if (!swapchain.frame_timestamps_enabled) {
1412 "native_window_enable_frame_timestamps(true)");
1413 native_window_enable_frame_timestamps(window, true);
1414 swapchain.frame_timestamps_enabled = true;
1417 // Record the nativeFrameId so it can be later correlated to
1419 uint64_t nativeFrameId = 0;
1420 err = native_window_get_next_frame_id(
1421 window, &nativeFrameId);
1422 if (err != android::NO_ERROR) {
1423 ALOGE("Failed to get next native frame ID.");
1426 // Add a new timing record with the user's presentID and
1427 // the nativeFrameId.
1428 swapchain.timing.push_back(TimingInfo(time, nativeFrameId));
1429 while (swapchain.timing.size() > MAX_TIMING_INFOS) {
1430 swapchain.timing.removeAt(0);
1432 if (time->desiredPresentTime) {
1433 // Set the desiredPresentTime:
1436 "native_window_set_buffers_timestamp(%" PRId64 ")",
1437 time->desiredPresentTime);
1438 native_window_set_buffers_timestamp(
1440 static_cast<int64_t>(time->desiredPresentTime));
1444 err = window->queueBuffer(window, img.buffer.get(), fence);
1445 // queueBuffer always closes fence, even on error
1447 // TODO(jessehall): What now? We should probably cancel the
1449 ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1450 swapchain_result = WorstPresentResult(
1451 swapchain_result, VK_ERROR_OUT_OF_DATE_KHR);
1453 if (img.dequeue_fence >= 0) {
1454 close(img.dequeue_fence);
1455 img.dequeue_fence = -1;
1457 img.dequeued = false;
1459 // If the swapchain is in shared mode, immediately dequeue the
1460 // buffer so it can be presented again without an intervening
1461 // call to AcquireNextImageKHR. We expect to get the same buffer
1462 // back from every call to dequeueBuffer in this mode.
1463 if (swapchain.shared && swapchain_result == VK_SUCCESS) {
1464 ANativeWindowBuffer* buffer;
1466 err = window->dequeueBuffer(window, &buffer, &fence_fd);
1468 ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1469 swapchain_result = WorstPresentResult(swapchain_result,
1470 VK_ERROR_SURFACE_LOST_KHR);
1472 else if (img.buffer != buffer) {
1473 ALOGE("got wrong image back for shared swapchain");
1474 swapchain_result = WorstPresentResult(swapchain_result,
1475 VK_ERROR_SURFACE_LOST_KHR);
1478 img.dequeue_fence = fence_fd;
1479 img.dequeued = true;
1483 if (swapchain_result != VK_SUCCESS) {
1484 ReleaseSwapchainImage(device, window, fence, img);
1485 OrphanSwapchain(device, &swapchain);
1488 ReleaseSwapchainImage(device, nullptr, fence, img);
1489 swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
1492 if (present_info->pResults)
1493 present_info->pResults[sc] = swapchain_result;
1495 if (swapchain_result != final_result)
1496 final_result = WorstPresentResult(final_result, swapchain_result);
1499 allocator->pfnFree(allocator->pUserData, rects);
1502 return final_result;
1506 VkResult GetRefreshCycleDurationGOOGLE(
1508 VkSwapchainKHR swapchain_handle,
1509 VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
1510 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1511 VkResult result = VK_SUCCESS;
1513 pDisplayTimingProperties->refreshDuration =
1514 static_cast<uint64_t>(swapchain.refresh_duration);
1520 VkResult GetPastPresentationTimingGOOGLE(
1522 VkSwapchainKHR swapchain_handle,
1524 VkPastPresentationTimingGOOGLE* timings) {
1525 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1526 ANativeWindow* window = swapchain.surface.window.get();
1527 VkResult result = VK_SUCCESS;
1529 if (!swapchain.frame_timestamps_enabled) {
1530 ALOGV("Calling native_window_enable_frame_timestamps(true)");
1531 native_window_enable_frame_timestamps(window, true);
1532 swapchain.frame_timestamps_enabled = true;
1536 // TODO(ianelliott): plumb return value (e.g. VK_INCOMPLETE)
1537 copy_ready_timings(swapchain, count, timings);
1539 *count = get_num_ready_timings(swapchain);
1546 VkResult GetSwapchainStatusKHR(
1548 VkSwapchainKHR swapchain_handle) {
1549 Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1550 VkResult result = VK_SUCCESS;
1552 if (swapchain.surface.swapchain_handle != swapchain_handle) {
1553 return VK_ERROR_OUT_OF_DATE_KHR;
1556 // TODO(chrisforbes): Implement this function properly
1561 VKAPI_ATTR void SetHdrMetadataEXT(
1563 uint32_t swapchainCount,
1564 const VkSwapchainKHR* pSwapchains,
1565 const VkHdrMetadataEXT* pHdrMetadataEXTs) {
1566 // TODO: courtneygo: implement actual function
1568 (void)swapchainCount;
1570 (void)pHdrMetadataEXTs;
1574 } // namespace driver
1575 } // namespace vulkan