vulkan/libvulkan/swapchain.cpp

   1 /*
   2  * Copyright 2015 The Android Open Source Project
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <algorithm>
  18
  19 #include <grallocusage/GrallocUsageConversion.h>
  20 #include <log/log.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>
  26
  27 #include "driver.h"
  28
  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.
  33 namespace vulkan {
  34 namespace driver {
  35
  36 namespace {
  37
  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;
  49
  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.
  56
  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.
  61
  62     switch (native) {
  63         case 0:  // 0x0
  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:
  80         default:
  81             return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
  82     }
  83 }
  84
  85 int InvertTransformToNative(VkSurfaceTransformFlagBitsKHR transform) {
  86     switch (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:
 106         default:
 107             return 0;
 108     }
 109 }
 110
 111 class TimingInfo {
 112    public:
 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) {}
 117     bool ready() const {
 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);
 126     }
 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;
 140             return;
 141         }
 142
 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_)) {
 159             early_time -= rdur;
 160             margin -= rdur;
 161         }
 162         vals_.earliestPresentTime = static_cast<uint64_t>(early_time);
 163         vals_.presentMargin = static_cast<uint64_t>(margin);
 164     }
 165     void get_values(VkPastPresentationTimingGOOGLE* values) const {
 166         *values = vals_;
 167     }
 168
 169    public:
 170     VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
 171
 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 };
 178 };
 179
 180 // ----------------------------------------------------------------------------
 181
 182 struct Surface {
 183     android::sp<ANativeWindow> window;
 184     VkSwapchainKHR swapchain_handle;
 185 };
 186
 187 VkSurfaceKHR HandleFromSurface(Surface* surface) {
 188     return VkSurfaceKHR(reinterpret_cast<uint64_t>(surface));
 189 }
 190
 191 Surface* SurfaceFromHandle(VkSurfaceKHR handle) {
 192     return reinterpret_cast<Surface*>(handle);
 193 }
 194
 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 };
 200
 201 struct Swapchain {
 202     Swapchain(Surface& surface_,
 203               uint32_t num_images_,
 204               VkPresentModeKHR present_mode)
 205         : surface(surface_),
 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(
 213             window,
 214             &refresh_duration);
 215     }
 216
 217     Surface& surface;
 218     uint32_t num_images;
 219     bool mailbox_mode;
 220     bool frame_timestamps_enabled;
 221     int64_t refresh_duration;
 222     bool shared;
 223
 224     struct Image {
 225         Image() : image(VK_NULL_HANDLE), dequeue_fence(-1), dequeued(false) {}
 226         VkImage image;
 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().
 232         int dequeue_fence;
 233         bool dequeued;
 234     } images[android::BufferQueueDefs::NUM_BUFFER_SLOTS];
 235
 236     android::Vector<TimingInfo> timing;
 237 };
 238
 239 VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
 240     return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
 241 }
 242
 243 Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
 244     return reinterpret_cast<Swapchain*>(handle);
 245 }
 246
 247 void ReleaseSwapchainImage(VkDevice device,
 248                            ANativeWindow* window,
 249                            int release_fence,
 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");
 254
 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);
 263         } else {
 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;
 273         }
 274         image.dequeue_fence = -1;
 275
 276         if (window) {
 277             window->cancelBuffer(window, image.buffer.get(), release_fence);
 278         } else {
 279             if (release_fence >= 0) {
 280                 sync_wait(release_fence, -1 /* forever */);
 281                 close(release_fence);
 282             }
 283         }
 284
 285         image.dequeued = false;
 286     }
 287
 288     if (image.image) {
 289         GetData(device).driver.DestroyImage(device, image.image, nullptr);
 290         image.image = VK_NULL_HANDLE;
 291     }
 292
 293     image.buffer.clear();
 294 }
 295
 296 void OrphanSwapchain(VkDevice device, Swapchain* swapchain) {
 297     if (swapchain->surface.swapchain_handle != HandleFromSwapchain(swapchain))
 298         return;
 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]);
 302     }
 303     swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
 304     swapchain->timing.clear();
 305 }
 306
 307 uint32_t get_num_ready_timings(Swapchain& swapchain) {
 308     if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
 309         return 0;
 310     }
 311
 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);
 316         if (ti.ready()) {
 317             // This TimingInfo is ready to be reported to the user.  Add it
 318             // to the num_ready.
 319             num_ready++;
 320             continue;
 321         }
 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
 339             // supported):
 340             &actual_present_time,
 341             NULL,  //&dequeue_ready_time,
 342             NULL /*&reads_done_time*/);
 343
 344         if (ret != android::NO_ERROR) {
 345             continue;
 346         }
 347
 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;
 354
 355         if (ti.ready()) {
 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);
 360             num_ready++;
 361         }
 362     }
 363     return num_ready;
 364 }
 365
 366 // TODO(ianelliott): DEAL WITH RETURN VALUE (e.g. VK_INCOMPLETE)!!!
 367 void copy_ready_timings(Swapchain& swapchain,
 368                         uint32_t* count,
 369                         VkPastPresentationTimingGOOGLE* timings) {
 370     if (swapchain.timing.empty()) {
 371         *count = 0;
 372         return;
 373     }
 374
 375     size_t last_ready = swapchain.timing.size() - 1;
 376     while (!swapchain.timing[last_ready].ready()) {
 377         if (last_ready == 0) {
 378             *count = 0;
 379             return;
 380         }
 381         last_ready--;
 382     }
 383
 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];
 388         if (ti.ready()) {
 389             ti.get_values(&timings[num_copied]);
 390             num_copied++;
 391         }
 392         num_to_remove++;
 393     }
 394
 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);
 398
 399     *count = num_copied;
 400 }
 401
 402 android_pixel_format GetNativePixelFormat(VkFormat format) {
 403     android_pixel_format native_format = HAL_PIXEL_FORMAT_RGBA_8888;
 404     switch (format) {
 405         case VK_FORMAT_R8G8B8A8_UNORM:
 406         case VK_FORMAT_R8G8B8A8_SRGB:
 407             native_format = HAL_PIXEL_FORMAT_RGBA_8888;
 408             break;
 409         case VK_FORMAT_R5G6B5_UNORM_PACK16:
 410             native_format = HAL_PIXEL_FORMAT_RGB_565;
 411             break;
 412         case VK_FORMAT_R16G16B16A16_SFLOAT:
 413             native_format = HAL_PIXEL_FORMAT_RGBA_FP16;
 414             break;
 415         case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
 416             native_format = HAL_PIXEL_FORMAT_RGBA_1010102;
 417             break;
 418         default:
 419             ALOGV("unsupported swapchain format %d", format);
 420             break;
 421     }
 422     return native_format;
 423 }
 424
 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;
 461
 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;
 466
 467         default:
 468             // This indicates that we don't know about the
 469             // dataspace specified and we should indicate that
 470             // it's unsupported
 471             return HAL_DATASPACE_UNKNOWN;
 472     }
 473 }
 474
 475 }  // anonymous namespace
 476
 477 VKAPI_ATTR
 478 VkResult CreateAndroidSurfaceKHR(
 479     VkInstance instance,
 480     const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
 481     const VkAllocationCallbacks* allocator,
 482     VkSurfaceKHR* out_surface) {
 483     if (!allocator)
 484         allocator = &GetData(instance).allocator;
 485     void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Surface),
 486                                          alignof(Surface),
 487                                          VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 488     if (!mem)
 489         return VK_ERROR_OUT_OF_HOST_MEMORY;
 490     Surface* surface = new (mem) Surface;
 491
 492     surface->window = pCreateInfo->window;
 493     surface->swapchain_handle = VK_NULL_HANDLE;
 494
 495     // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
 496     int err =
 497         native_window_api_connect(surface->window.get(), NATIVE_WINDOW_API_EGL);
 498     if (err != 0) {
 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),
 502               err);
 503         surface->~Surface();
 504         allocator->pfnFree(allocator->pUserData, surface);
 505         return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
 506     }
 507
 508     *out_surface = HandleFromSurface(surface);
 509     return VK_SUCCESS;
 510 }
 511
 512 VKAPI_ATTR
 513 void DestroySurfaceKHR(VkInstance instance,
 514                        VkSurfaceKHR surface_handle,
 515                        const VkAllocationCallbacks* allocator) {
 516     Surface* surface = SurfaceFromHandle(surface_handle);
 517     if (!surface)
 518         return;
 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));
 525     surface->~Surface();
 526     if (!allocator)
 527         allocator = &GetData(instance).allocator;
 528     allocator->pfnFree(allocator->pUserData, surface);
 529 }
 530
 531 VKAPI_ATTR
 532 VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/,
 533                                             uint32_t /*queue_family*/,
 534                                             VkSurfaceKHR /*surface*/,
 535                                             VkBool32* supported) {
 536     *supported = VK_TRUE;
 537     return VK_SUCCESS;
 538 }
 539
 540 VKAPI_ATTR
 541 VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(
 542     VkPhysicalDevice /*pdev*/,
 543     VkSurfaceKHR surface,
 544     VkSurfaceCapabilitiesKHR* capabilities) {
 545     int err;
 546     ANativeWindow* window = SurfaceFromHandle(surface)->window.get();
 547
 548     int width, height;
 549     err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
 550     if (err != 0) {
 551         ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
 552               strerror(-err), err);
 553         return VK_ERROR_SURFACE_LOST_KHR;
 554     }
 555     err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
 556     if (err != 0) {
 557         ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
 558               strerror(-err), err);
 559         return VK_ERROR_SURFACE_LOST_KHR;
 560     }
 561
 562     int transform_hint;
 563     err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint);
 564     if (err != 0) {
 565         ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)",
 566               strerror(-err), err);
 567         return VK_ERROR_SURFACE_LOST_KHR;
 568     }
 569
 570     // TODO(jessehall): Figure out what the min/max values should be.
 571     capabilities->minImageCount = 2;
 572     capabilities->maxImageCount = 3;
 573
 574     capabilities->currentExtent =
 575         VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
 576
 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};
 581
 582     capabilities->maxImageArrayLayers = 1;
 583
 584     capabilities->supportedTransforms = kSupportedTransforms;
 585     capabilities->currentTransform =
 586         TranslateNativeToVulkanTransform(transform_hint);
 587
 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;
 591
 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;
 602
 603     return VK_SUCCESS;
 604 }
 605
 606 VKAPI_ATTR
 607 VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev,
 608                                             VkSurfaceKHR surface_handle,
 609                                             uint32_t* count,
 610                                             VkSurfaceFormatKHR* formats) {
 611     const InstanceData& instance_data = GetData(pdev);
 612
 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
 617     // hardcoded below.
 618
 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},
 623     };
 624     const uint32_t kNumFormats = sizeof(kFormats) / sizeof(kFormats[0]);
 625     uint32_t total_num_formats = kNumFormats;
 626
 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);
 631     if (err) {
 632         // Not allowed to return a more sensible error code, so do this
 633         return VK_ERROR_OUT_OF_HOST_MEMORY;
 634     }
 635     ALOGV("wide_color_support is: %d", wide_color_support);
 636     wide_color_support =
 637         wide_color_support &&
 638         instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace);
 639
 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},
 645     };
 646     const uint32_t kNumWideColorFormats =
 647         sizeof(kWideColorFormats) / sizeof(kWideColorFormats[0]);
 648     if (wide_color_support) {
 649         total_num_formats += kNumWideColorFormats;
 650     }
 651
 652     VkResult result = VK_SUCCESS;
 653     if (formats) {
 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;
 666         }
 667         *count = out_count;
 668     } else {
 669         *count = total_num_formats;
 670     }
 671     return result;
 672 }
 673
 674 VKAPI_ATTR
 675 VkResult GetPhysicalDeviceSurfaceCapabilities2KHR(
 676     VkPhysicalDevice physicalDevice,
 677     const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
 678     VkSurfaceCapabilities2KHR* pSurfaceCapabilities) {
 679     VkResult result = GetPhysicalDeviceSurfaceCapabilitiesKHR(
 680         physicalDevice, pSurfaceInfo->surface,
 681         &pSurfaceCapabilities->surfaceCapabilities);
 682
 683     VkSurfaceCapabilities2KHR* caps = pSurfaceCapabilities;
 684     while (caps->pNext) {
 685         caps = reinterpret_cast<VkSurfaceCapabilities2KHR*>(caps->pNext);
 686
 687         switch (caps->sType) {
 688             case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
 689                 VkSharedPresentSurfaceCapabilitiesKHR* shared_caps =
 690                     reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR*>(
 691                         caps);
 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;
 697             } break;
 698
 699             default:
 700                 // Ignore all other extension structs
 701                 break;
 702         }
 703     }
 704
 705     return result;
 706 }
 707
 708 VKAPI_ATTR
 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);
 718     } else {
 719         // temp vector for forwarding; we'll marshal it into the pSurfaceFormats
 720         // after the call.
 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));
 726
 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];
 733             }
 734         }
 735
 736         return result;
 737     }
 738 }
 739
 740 VKAPI_ATTR
 741 VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev,
 742                                                  VkSurfaceKHR /*surface*/,
 743                                                  uint32_t* count,
 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);
 748
 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);
 754         }
 755     }
 756
 757     uint32_t num_modes = uint32_t(present_modes.size());
 758
 759     VkResult result = VK_SUCCESS;
 760     if (modes) {
 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);
 765     } else {
 766         *count = num_modes;
 767     }
 768     return result;
 769 }
 770
 771 VKAPI_ATTR
 772 VkResult CreateSwapchainKHR(VkDevice device,
 773                             const VkSwapchainCreateInfoKHR* create_info,
 774                             const VkAllocationCallbacks* allocator,
 775                             VkSwapchainKHR* swapchain_handle) {
 776     int err;
 777     VkResult result = VK_SUCCESS;
 778
 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));
 789
 790     if (!allocator)
 791         allocator = &GetData(device).allocator;
 792
 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) {
 798         ALOGE(
 799             "CreateSwapchainKHR(VkSwapchainCreateInfoKHR.imageColorSpace = %d) "
 800             "failed: Unsupported color space",
 801             create_info->imageColorSpace);
 802         return VK_ERROR_INITIALIZATION_FAILED;
 803     }
 804
 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);
 817
 818     Surface& surface = *SurfaceFromHandle(create_info->surface);
 819
 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;
 828     }
 829     if (create_info->oldSwapchain != VK_NULL_HANDLE)
 830         OrphanSwapchain(device, SwapchainFromHandle(create_info->oldSwapchain));
 831
 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.
 837
 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);
 847     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);
 851
 852     err = native_window_set_buffer_count(surface.window.get(), 0);
 853     if (err != 0) {
 854         ALOGE("native_window_set_buffer_count(0) failed: %s (%d)",
 855               strerror(-err), err);
 856         return VK_ERROR_SURFACE_LOST_KHR;
 857     }
 858
 859     int swap_interval =
 860         create_info->presentMode == VK_PRESENT_MODE_MAILBOX_KHR ? 0 : 1;
 861     err = surface.window->setSwapInterval(surface.window.get(), swap_interval);
 862     if (err != 0) {
 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;
 868     }
 869
 870     err = native_window_set_shared_buffer_mode(surface.window.get(), false);
 871     if (err != 0) {
 872         ALOGE("native_window_set_shared_buffer_mode(false) failed: %s (%d)",
 873               strerror(-err), err);
 874         return VK_ERROR_SURFACE_LOST_KHR;
 875     }
 876
 877     err = native_window_set_auto_refresh(surface.window.get(), false);
 878     if (err != 0) {
 879         ALOGE("native_window_set_auto_refresh(false) failed: %s (%d)",
 880               strerror(-err), err);
 881         return VK_ERROR_SURFACE_LOST_KHR;
 882     }
 883
 884     // -- Configure the native window --
 885
 886     const auto& dispatch = GetData(device).driver;
 887
 888     err = native_window_set_buffers_format(surface.window.get(),
 889                                            native_pixel_format);
 890     if (err != 0) {
 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;
 896     }
 897     err = native_window_set_buffers_data_space(surface.window.get(),
 898                                                native_dataspace);
 899     if (err != 0) {
 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;
 905     }
 906
 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));
 910     if (err != 0) {
 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;
 917     }
 918
 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));
 930     if (err != 0) {
 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;
 937     }
 938
 939     err = native_window_set_scaling_mode(
 940         surface.window.get(), NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
 941     if (err != 0) {
 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;
 947     }
 948
 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);
 954         if (err != 0) {
 955             ALOGE("native_window_set_shared_buffer_mode failed: %s (%d)", strerror(-err), err);
 956             return VK_ERROR_SURFACE_LOST_KHR;
 957         }
 958     }
 959
 960     if (create_info->presentMode == VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR) {
 961         err = native_window_set_auto_refresh(surface.window.get(), true);
 962         if (err != 0) {
 963             ALOGE("native_window_set_auto_refresh failed: %s (%d)", strerror(-err), err);
 964             return VK_ERROR_SURFACE_LOST_KHR;
 965         }
 966     }
 967
 968     int query_value;
 969     err = surface.window->query(surface.window.get(),
 970                                 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
 971                                 &query_value);
 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,
 976               query_value);
 977         return VK_ERROR_SURFACE_LOST_KHR;
 978     }
 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;
 982
 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));
 989     if (err != 0) {
 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;
 995     }
 996
 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;
1006         }
1007         gralloc_usage =
1008             android_convertGralloc1To0Usage(producer_usage, consumer_usage);
1009     } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
1010         result = dispatch.GetSwapchainGrallocUsageANDROID(
1011             device, create_info->imageFormat, create_info->imageUsage,
1012             &gralloc_usage);
1013         if (result != VK_SUCCESS) {
1014             ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
1015             return VK_ERROR_SURFACE_LOST_KHR;
1016         }
1017     }
1018     err = native_window_set_usage(surface.window.get(), gralloc_usage);
1019     if (err != 0) {
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;
1024     }
1025
1026     // -- Allocate our Swapchain object --
1027     // After this point, we must deallocate the swapchain on error.
1028
1029     void* mem = allocator->pfnAllocation(allocator->pUserData,
1030                                          sizeof(Swapchain), alignof(Swapchain),
1031                                          VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
1032     if (!mem)
1033         return VK_ERROR_OUT_OF_HOST_MEMORY;
1034     Swapchain* swapchain =
1035         new (mem) Swapchain(surface, num_images, create_info->presentMode);
1036
1037     // -- Dequeue all buffers and create a VkImage for each --
1038     // Any failures during or after this must cancel the dequeued buffers.
1039
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
1045         .pNext = nullptr,
1046         .usage = swapchain_image_usage,
1047     };
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,
1054     };
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},
1061         .mipLevels = 1,
1062         .arrayLayers = 1,
1063         .samples = VK_SAMPLE_COUNT_1_BIT,
1064         .tiling = VK_IMAGE_TILING_OPTIMAL,
1065         .usage = create_info->imageUsage,
1066         .flags = 0,
1067         .sharingMode = create_info->imageSharingMode,
1068         .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
1069         .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
1070     };
1071
1072     for (uint32_t i = 0; i < num_images; i++) {
1073         Swapchain::Image& img = swapchain->images[i];
1074
1075         ANativeWindowBuffer* buffer;
1076         err = surface.window->dequeueBuffer(surface.window.get(), &buffer,
1077                                             &img.dequeue_fence);
1078         if (err != 0) {
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;
1083             break;
1084         }
1085         img.buffer = buffer;
1086         img.dequeued = true;
1087
1088         image_create.extent =
1089             VkExtent3D{static_cast<uint32_t>(img.buffer->width),
1090                        static_cast<uint32_t>(img.buffer->height),
1091                        1};
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);
1102
1103         result =
1104             dispatch.CreateImage(device, &image_create, nullptr, &img.image);
1105         if (result != VK_SUCCESS) {
1106             ALOGD("vkCreateImage w/ native buffer failed: %u", result);
1107             break;
1108         }
1109     }
1110
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.
1114     //
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];
1120             if (img.dequeued) {
1121                 surface.window->cancelBuffer(surface.window.get(), img.buffer.get(),
1122                                              img.dequeue_fence);
1123                 img.dequeue_fence = -1;
1124                 img.dequeued = false;
1125             }
1126             if (result != VK_SUCCESS) {
1127                 if (img.image)
1128                     dispatch.DestroyImage(device, img.image, nullptr);
1129             }
1130         }
1131     }
1132
1133     if (result != VK_SUCCESS) {
1134         swapchain->~Swapchain();
1135         allocator->pfnFree(allocator->pUserData, swapchain);
1136         return result;
1137     }
1138
1139     surface.swapchain_handle = HandleFromSwapchain(swapchain);
1140     *swapchain_handle = surface.swapchain_handle;
1141     return VK_SUCCESS;
1142 }
1143
1144 VKAPI_ATTR
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);
1150     if (!swapchain)
1151         return;
1152     bool active = swapchain->surface.swapchain_handle == swapchain_handle;
1153     ANativeWindow* window = active ? swapchain->surface.window.get() : nullptr;
1154
1155     if (swapchain->frame_timestamps_enabled) {
1156         native_window_enable_frame_timestamps(window, false);
1157     }
1158     for (uint32_t i = 0; i < swapchain->num_images; i++)
1159         ReleaseSwapchainImage(device, window, -1, swapchain->images[i]);
1160     if (active)
1161         swapchain->surface.swapchain_handle = VK_NULL_HANDLE;
1162     if (!allocator)
1163         allocator = &GetData(device).allocator;
1164     swapchain->~Swapchain();
1165     allocator->pfnFree(allocator->pUserData, swapchain);
1166 }
1167
1168 VKAPI_ATTR
1169 VkResult GetSwapchainImagesKHR(VkDevice,
1170                                VkSwapchainKHR swapchain_handle,
1171                                uint32_t* count,
1172                                VkImage* images) {
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;
1179     if (images) {
1180         uint32_t n = swapchain.num_images;
1181         if (*count < swapchain.num_images) {
1182             n = *count;
1183             result = VK_INCOMPLETE;
1184         }
1185         for (uint32_t i = 0; i < n; i++)
1186             images[i] = swapchain.images[i].image;
1187         *count = n;
1188     } else {
1189         *count = swapchain.num_images;
1190     }
1191     return result;
1192 }
1193
1194 VKAPI_ATTR
1195 VkResult AcquireNextImageKHR(VkDevice device,
1196                              VkSwapchainKHR swapchain_handle,
1197                              uint64_t timeout,
1198                              VkSemaphore semaphore,
1199                              VkFence vk_fence,
1200                              uint32_t* image_index) {
1201     Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1202     ANativeWindow* window = swapchain.surface.window.get();
1203     VkResult result;
1204     int err;
1205
1206     if (swapchain.surface.swapchain_handle != swapchain_handle)
1207         return VK_ERROR_OUT_OF_DATE_KHR;
1208
1209     ALOGW_IF(
1210         timeout != UINT64_MAX,
1211         "vkAcquireNextImageKHR: non-infinite timeouts not yet implemented");
1212
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.
1217         *image_index = 0;
1218         result = GetData(device).driver.AcquireImageANDROID(
1219                 device, swapchain.images[*image_index].image, -1, semaphore, vk_fence);
1220         return result;
1221     }
1222
1223     ANativeWindowBuffer* buffer;
1224     int fence_fd;
1225     err = window->dequeueBuffer(window, &buffer, &fence_fd);
1226     if (err != 0) {
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;
1231     }
1232
1233     uint32_t idx;
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;
1238             break;
1239         }
1240     }
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;
1245     }
1246
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 */);
1254         }
1255     }
1256
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;
1270         return result;
1271     }
1272
1273     *image_index = idx;
1274     return VK_SUCCESS;
1275 }
1276
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,
1286         VK_SUBOPTIMAL_KHR,
1287     };
1288     for (auto result : kWorstToBest) {
1289         if (a == result || b == result)
1290             return result;
1291     }
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;
1295 }
1296
1297 VKAPI_ATTR
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);
1302
1303     VkDevice device = GetData(queue).driver_device;
1304     const auto& dispatch = GetData(queue).driver;
1305     VkResult final_result = VK_SUCCESS;
1306
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);
1312     while (next) {
1313         switch (next->sType) {
1314             case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
1315                 present_regions = next;
1316                 break;
1317             case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
1318                 present_times =
1319                     reinterpret_cast<const VkPresentTimesInfoGOOGLE*>(next);
1320                 break;
1321             default:
1322                 ALOGV("QueuePresentKHR ignoring unrecognized pNext->sType = %x",
1323                       next->sType);
1324                 break;
1325         }
1326         next = reinterpret_cast<const VkPresentRegionsKHR*>(next->pNext);
1327     }
1328     ALOGV_IF(
1329         present_regions &&
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;
1343
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) ? &regions[sc] : nullptr;
1351         const VkPresentTimeGOOGLE* time = (times) ? &times[sc] : nullptr;
1352         VkResult swapchain_result = VK_SUCCESS;
1353         VkResult result;
1354         int err;
1355
1356         int fence = -1;
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;
1363         }
1364
1365         if (swapchain.surface.swapchain_handle ==
1366             present_info->pSwapchains[sc]) {
1367             ANativeWindow* window = swapchain.surface.window.get();
1368             if (swapchain_result == VK_SUCCESS) {
1369                 if (region) {
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));
1380                         if (new_rects) {
1381                             rects = new_rects;
1382                             nrects = rcount;
1383                         } else {
1384                             rcount = 0;  // Ignore the hint for this swapchain
1385                         }
1386                     }
1387                     for (uint32_t r = 0; r < rcount; ++r) {
1388                         if (region->pRectangles[r].layer > 0) {
1389                             ALOGV(
1390                                 "vkQueuePresentKHR ignoring invalid layer "
1391                                 "(%u); using layer 0 instead",
1392                                 region->pRectangles[r].layer);
1393                         }
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];
1401                         cur_rect->left = x;
1402                         cur_rect->top = y + height;
1403                         cur_rect->right = x + width;
1404                         cur_rect->bottom = y;
1405                     }
1406                     native_window_set_surface_damage(window, rects, rcount);
1407                 }
1408                 if (time) {
1409                     if (!swapchain.frame_timestamps_enabled) {
1410                         ALOGV(
1411                             "Calling "
1412                             "native_window_enable_frame_timestamps(true)");
1413                         native_window_enable_frame_timestamps(window, true);
1414                         swapchain.frame_timestamps_enabled = true;
1415                     }
1416
1417                     // Record the nativeFrameId so it can be later correlated to
1418                     // this present.
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.");
1424                     }
1425
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);
1431                     }
1432                     if (time->desiredPresentTime) {
1433                         // Set the desiredPresentTime:
1434                         ALOGV(
1435                             "Calling "
1436                             "native_window_set_buffers_timestamp(%" PRId64 ")",
1437                             time->desiredPresentTime);
1438                         native_window_set_buffers_timestamp(
1439                             window,
1440                             static_cast<int64_t>(time->desiredPresentTime));
1441                     }
1442                 }
1443
1444                 err = window->queueBuffer(window, img.buffer.get(), fence);
1445                 // queueBuffer always closes fence, even on error
1446                 if (err != 0) {
1447                     // TODO(jessehall): What now? We should probably cancel the
1448                     // buffer, I guess?
1449                     ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
1450                     swapchain_result = WorstPresentResult(
1451                         swapchain_result, VK_ERROR_OUT_OF_DATE_KHR);
1452                 }
1453                 if (img.dequeue_fence >= 0) {
1454                     close(img.dequeue_fence);
1455                     img.dequeue_fence = -1;
1456                 }
1457                 img.dequeued = false;
1458
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;
1465                     int fence_fd;
1466                     err = window->dequeueBuffer(window, &buffer, &fence_fd);
1467                     if (err != 0) {
1468                         ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
1469                         swapchain_result = WorstPresentResult(swapchain_result,
1470                             VK_ERROR_SURFACE_LOST_KHR);
1471                     }
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);
1476                     }
1477                     else {
1478                         img.dequeue_fence = fence_fd;
1479                         img.dequeued = true;
1480                     }
1481                 }
1482             }
1483             if (swapchain_result != VK_SUCCESS) {
1484                 ReleaseSwapchainImage(device, window, fence, img);
1485                 OrphanSwapchain(device, &swapchain);
1486             }
1487         } else {
1488             ReleaseSwapchainImage(device, nullptr, fence, img);
1489             swapchain_result = VK_ERROR_OUT_OF_DATE_KHR;
1490         }
1491
1492         if (present_info->pResults)
1493             present_info->pResults[sc] = swapchain_result;
1494
1495         if (swapchain_result != final_result)
1496             final_result = WorstPresentResult(final_result, swapchain_result);
1497     }
1498     if (rects) {
1499         allocator->pfnFree(allocator->pUserData, rects);
1500     }
1501
1502     return final_result;
1503 }
1504
1505 VKAPI_ATTR
1506 VkResult GetRefreshCycleDurationGOOGLE(
1507     VkDevice,
1508     VkSwapchainKHR swapchain_handle,
1509     VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) {
1510     Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1511     VkResult result = VK_SUCCESS;
1512
1513     pDisplayTimingProperties->refreshDuration =
1514             static_cast<uint64_t>(swapchain.refresh_duration);
1515
1516     return result;
1517 }
1518
1519 VKAPI_ATTR
1520 VkResult GetPastPresentationTimingGOOGLE(
1521     VkDevice,
1522     VkSwapchainKHR swapchain_handle,
1523     uint32_t* count,
1524     VkPastPresentationTimingGOOGLE* timings) {
1525     Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1526     ANativeWindow* window = swapchain.surface.window.get();
1527     VkResult result = VK_SUCCESS;
1528
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;
1533     }
1534
1535     if (timings) {
1536         // TODO(ianelliott): plumb return value (e.g. VK_INCOMPLETE)
1537         copy_ready_timings(swapchain, count, timings);
1538     } else {
1539         *count = get_num_ready_timings(swapchain);
1540     }
1541
1542     return result;
1543 }
1544
1545 VKAPI_ATTR
1546 VkResult GetSwapchainStatusKHR(
1547     VkDevice,
1548     VkSwapchainKHR swapchain_handle) {
1549     Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
1550     VkResult result = VK_SUCCESS;
1551
1552     if (swapchain.surface.swapchain_handle != swapchain_handle) {
1553         return VK_ERROR_OUT_OF_DATE_KHR;
1554     }
1555
1556     // TODO(chrisforbes): Implement this function properly
1557
1558     return result;
1559 }
1560
1561 VKAPI_ATTR void SetHdrMetadataEXT(
1562     VkDevice device,
1563     uint32_t swapchainCount,
1564     const VkSwapchainKHR* pSwapchains,
1565     const VkHdrMetadataEXT* pHdrMetadataEXTs) {
1566     // TODO: courtneygo: implement actual function
1567     (void)device;
1568     (void)swapchainCount;
1569     (void)pSwapchains;
1570     (void)pHdrMetadataEXTs;
1571     return;
1572 }
1573
1574 }  // namespace driver
1575 }  // namespace vulkan