vulkan/libvulkan/swapchain.cpp

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

// #define LOG_NDEBUG 0

#include <algorithm>
#include <memory>

#include <gui/BufferQueue.h>
#include <log/log.h>
#include <sync/sync.h>

#include "loader.h"

using namespace vulkan;

// TODO(jessehall): Currently we don't have a good error code for when a native
// window operation fails. Just returning INITIALIZATION_FAILED for now. Later
// versions (post SDK 0.9) of the API/extension have a better error code.
// When updating to that version, audit all error returns.

namespace {

// ----------------------------------------------------------------------------
// These functions/classes form an adaptor that allows objects to be refcounted
// by both android::sp<> and std::shared_ptr<> simultaneously, and delegates
// allocation of the shared_ptr<> control structure to VkAllocCallbacks. The
// platform holds a reference to the ANativeWindow using its embedded reference
// count, and the ANativeWindow implementation holds references to the
// ANativeWindowBuffers using their embedded reference counts, so the
// shared_ptr *must* cooperate with these and hold at least one reference to
// the object using the embedded reference count.

template <typename T>
struct NativeBaseDeleter {
    void operator()(T* obj) { obj->common.decRef(&obj->common); }
};

template <typename T>
class VulkanAllocator {
   public:
    typedef T value_type;

    explicit VulkanAllocator(VkDevice device) : device_(device) {}

    template <typename U>
    explicit VulkanAllocator(const VulkanAllocator<U>& other)
        : device_(other.device_) {}

    T* allocate(size_t n) const {
        return static_cast<T*>(AllocDeviceMem(
            device_, n * sizeof(T), alignof(T), VK_SYSTEM_ALLOC_TYPE_INTERNAL));
    }
    void deallocate(T* p, size_t) const { return FreeDeviceMem(device_, p); }

   private:
    template <typename U>
    friend class VulkanAllocator;
    VkDevice device_;
};

template <typename T>
std::shared_ptr<T> InitSharedPtr(VkDevice device, T* obj) {
    obj->common.incRef(&obj->common);
    return std::shared_ptr<T>(obj, NativeBaseDeleter<T>(),
                              VulkanAllocator<T>(device));
}

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

struct Swapchain {
    Swapchain(std::shared_ptr<ANativeWindow> window_, uint32_t num_images_)
        : window(window_), num_images(num_images_) {}

    std::shared_ptr<ANativeWindow> window;
    uint32_t num_images;

    struct Image {
        Image() : image(VK_NULL_HANDLE), dequeue_fence(-1), dequeued(false) {}
        VkImage image;
        std::shared_ptr<ANativeWindowBuffer> buffer;
        // The fence is only valid when the buffer is dequeued, and should be
        // -1 any other time. When valid, we own the fd, and must ensure it is
        // closed: either by closing it explicitly when queueing the buffer,
        // or by passing ownership e.g. to ANativeWindow::cancelBuffer().
        int dequeue_fence;
        bool dequeued;
    } images[android::BufferQueue::NUM_BUFFER_SLOTS];
};

VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
    return VkSwapchainKHR(reinterpret_cast<uint64_t>(swapchain));
}

Swapchain* SwapchainFromHandle(VkSwapchainKHR handle) {
    return reinterpret_cast<Swapchain*>(handle.handle);
}

}  // anonymous namespace

namespace vulkan {

VkResult GetPhysicalDeviceSurfaceSupportKHR(
    VkPhysicalDevice /*pdev*/,
    uint32_t /*queue_family*/,
    const VkSurfaceDescriptionKHR* surface_desc,
    VkBool32* supported) {
// TODO(jessehall): Fix the header, preferrably upstream, so values added to
// existing enums don't trigger warnings like this.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wold-style-cast"
#pragma clang diagnostic ignored "-Wsign-conversion"
    ALOGE_IF(
        surface_desc->sType != VK_STRUCTURE_TYPE_SURFACE_DESCRIPTION_WINDOW_KHR,
        "vkGetPhysicalDeviceSurfaceSupportKHR: pSurfaceDescription->sType=%#x "
        "not supported",
        surface_desc->sType);
#pragma clang diagnostic pop

    const VkSurfaceDescriptionWindowKHR* window_desc =
        reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(surface_desc);

    // TODO(jessehall): Also check whether the physical device exports the
    // VK_EXT_ANDROID_native_buffer extension. For now, assume it does.
    *supported = (window_desc->platform == VK_PLATFORM_ANDROID_KHR &&
                  !window_desc->pPlatformHandle &&
                  static_cast<ANativeWindow*>(window_desc->pPlatformWindow)
                          ->common.magic == ANDROID_NATIVE_WINDOW_MAGIC);

    return VK_SUCCESS;
}

VkResult GetSurfacePropertiesKHR(VkDevice /*device*/,
                                 const VkSurfaceDescriptionKHR* surface_desc,
                                 VkSurfacePropertiesKHR* properties) {
    const VkSurfaceDescriptionWindowKHR* window_desc =
        reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(surface_desc);
    ANativeWindow* window =
        static_cast<ANativeWindow*>(window_desc->pPlatformWindow);

    int err;

    // TODO(jessehall): Currently the window must be connected for several
    // queries -- including default dimensions -- to work, since Surface caches
    // the queried values at connect() and queueBuffer(), and query() returns
    // those cached values.
    //
    // The proposed refactoring to create a VkSurface object (bug 14596) will
    // give us a place to connect once per window. If that doesn't end up
    // happening, we'll probably need to maintain an internal list of windows
    // that have swapchains created for them, search that list here, and
    // only temporarily connect if the window doesn't have a swapchain.

    bool disconnect = true;
    err = native_window_api_connect(window, NATIVE_WINDOW_API_EGL);
    if (err == -EINVAL) {
        // This is returned if the window is already connected, among other
        // things. We'll just assume we're already connected and charge ahead.
        // See TODO above, this is not cool.
        ALOGW(
            "vkGetSurfacePropertiesKHR: native_window_api_connect returned "
            "-EINVAL, assuming already connected");
        err = 0;
        disconnect = false;
    } else if (err != 0) {
        // TODO(jessehall): Improve error reporting. Can we enumerate possible
        // errors and translate them to valid Vulkan result codes?
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    int width, height;
    err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width);
    if (err != 0) {
        ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
              strerror(-err), err);
        if (disconnect)
            native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
        return VK_ERROR_INITIALIZATION_FAILED;
    }
    err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height);
    if (err != 0) {
        ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)",
              strerror(-err), err);
        if (disconnect)
            native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    if (disconnect)
        native_window_api_disconnect(window, NATIVE_WINDOW_API_EGL);

    properties->currentExtent = VkExtent2D{width, height};

    // TODO(jessehall): Figure out what the min/max values should be.
    properties->minImageCount = 2;
    properties->maxImageCount = 3;

    // TODO(jessehall): Figure out what the max extent should be. Maximum
    // texture dimension maybe?
    properties->minImageExtent = VkExtent2D{1, 1};
    properties->maxImageExtent = VkExtent2D{4096, 4096};

    // TODO(jessehall): We can support all transforms, fix this once
    // implemented.
    properties->supportedTransforms = VK_SURFACE_TRANSFORM_NONE_BIT_KHR;

    // TODO(jessehall): Implement based on NATIVE_WINDOW_TRANSFORM_HINT.
    properties->currentTransform = VK_SURFACE_TRANSFORM_NONE_KHR;

    properties->maxImageArraySize = 1;

    // TODO(jessehall): I think these are right, but haven't thought hard about
    // it. Do we need to query the driver for support of any of these?
    // Currently not included:
    // - VK_IMAGE_USAGE_GENERAL: maybe? does this imply cpu mappable?
    // - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
    // - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
    properties->supportedUsageFlags =
        VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
        VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
        VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
        VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;

    return VK_SUCCESS;
}

VkResult GetSurfaceFormatsKHR(VkDevice /*device*/,
                              const VkSurfaceDescriptionKHR* /*surface_desc*/,
                              uint32_t* count,
                              VkSurfaceFormatKHR* formats) {
    // TODO(jessehall): Fill out the set of supported formats. Open question
    // whether we should query the driver for support -- how does it know what
    // the consumer can support? Should we support formats that don't
    // correspond to gralloc formats?

    const VkSurfaceFormatKHR kFormats[] = {
        {VK_FORMAT_R8G8B8A8_UNORM, VK_COLORSPACE_SRGB_NONLINEAR_KHR},
        {VK_FORMAT_R8G8B8A8_SRGB, VK_COLORSPACE_SRGB_NONLINEAR_KHR},
    };
    const uint32_t kNumFormats = sizeof(kFormats) / sizeof(kFormats[0]);

    VkResult result = VK_SUCCESS;
    if (formats) {
        if (*count < kNumFormats)
            result = VK_INCOMPLETE;
        std::copy(kFormats, kFormats + std::min(*count, kNumFormats), formats);
    }
    *count = kNumFormats;
    return result;
}

VkResult GetSurfacePresentModesKHR(
    VkDevice /*device*/,
    const VkSurfaceDescriptionKHR* /*surface_desc*/,
    uint32_t* count,
    VkPresentModeKHR* modes) {
    const VkPresentModeKHR kModes[] = {
        VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
    };
    const uint32_t kNumModes = sizeof(kModes) / sizeof(kModes[0]);

    VkResult result = VK_SUCCESS;
    if (modes) {
        if (*count < kNumModes)
            result = VK_INCOMPLETE;
        std::copy(kModes, kModes + std::min(*count, kNumModes), modes);
    }
    *count = kNumModes;
    return result;
}

VkResult CreateSwapchainKHR(VkDevice device,
                            const VkSwapchainCreateInfoKHR* create_info,
                            VkSwapchainKHR* swapchain_handle) {
    int err;
    VkResult result = VK_SUCCESS;

    ALOGV_IF(create_info->imageArraySize != 1,
             "Swapchain imageArraySize (%u) != 1 not supported",
             create_info->imageArraySize);

    ALOGE_IF(create_info->imageFormat != VK_FORMAT_R8G8B8A8_UNORM,
             "swapchain formats other than R8G8B8A8_UNORM not yet implemented");
    ALOGE_IF(create_info->imageColorSpace != VK_COLORSPACE_SRGB_NONLINEAR_KHR,
             "color spaces other than SRGB_NONLINEAR not yet implemented");
    ALOGE_IF(create_info->oldSwapchain,
             "swapchain re-creation not yet implemented");
    ALOGE_IF(create_info->preTransform != VK_SURFACE_TRANSFORM_NONE_KHR,
             "swapchain preTransform not yet implemented");
    ALOGE_IF(create_info->presentMode != VK_PRESENT_MODE_FIFO_KHR,
             "present modes other than FIFO are not yet implemented");

    // -- Configure the native window --
    // Failure paths from here on need to disconnect the window.

    std::shared_ptr<ANativeWindow> window = InitSharedPtr(
        device, static_cast<ANativeWindow*>(
                    reinterpret_cast<const VkSurfaceDescriptionWindowKHR*>(
                        create_info->pSurfaceDescription)
                        ->pPlatformWindow));

    // TODO(jessehall): Create and use NATIVE_WINDOW_API_VULKAN.
    err = native_window_api_connect(window.get(), NATIVE_WINDOW_API_EGL);
    if (err != 0) {
        // TODO(jessehall): Improve error reporting. Can we enumerate possible
        // errors and translate them to valid Vulkan result codes?
        ALOGE("native_window_api_connect() failed: %s (%d)", strerror(-err),
              err);
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    err = native_window_set_buffers_dimensions(window.get(),
                                               create_info->imageExtent.width,
                                               create_info->imageExtent.height);
    if (err != 0) {
        // TODO(jessehall): Improve error reporting. Can we enumerate possible
        // errors and translate them to valid Vulkan result codes?
        ALOGE("native_window_set_buffers_dimensions(%d,%d) failed: %s (%d)",
              create_info->imageExtent.width, create_info->imageExtent.height,
              strerror(-err), err);
        native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    uint32_t min_undequeued_buffers;
    err = window->query(window.get(), NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS,
                        reinterpret_cast<int*>(&min_undequeued_buffers));
    if (err != 0) {
        // TODO(jessehall): Improve error reporting. Can we enumerate possible
        // errors and translate them to valid Vulkan result codes?
        ALOGE("window->query failed: %s (%d)", strerror(-err), err);
        native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
        return VK_ERROR_INITIALIZATION_FAILED;
    }
    uint32_t num_images =
        (create_info->minImageCount - 1) + min_undequeued_buffers;
    err = native_window_set_buffer_count(window.get(), num_images);
    if (err != 0) {
        // TODO(jessehall): Improve error reporting. Can we enumerate possible
        // errors and translate them to valid Vulkan result codes?
        ALOGE("native_window_set_buffer_count failed: %s (%d)", strerror(-err),
              err);
        native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    // TODO(jessehall): Do we need to call modify native_window_set_usage()
    // based on create_info->imageUsageFlags?

    // -- Allocate our Swapchain object --
    // After this point, we must deallocate the swapchain on error.

    void* mem = AllocDeviceMem(device, sizeof(Swapchain), alignof(Swapchain),
                               VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
    if (!mem) {
        native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
        return VK_ERROR_OUT_OF_HOST_MEMORY;
    }
    Swapchain* swapchain = new (mem) Swapchain(window, num_images);

    // -- Dequeue all buffers and create a VkImage for each --
    // Any failures during or after this must cancel the dequeued buffers.

    VkNativeBufferANDROID image_native_buffer = {
// TODO(jessehall): Figure out how to make extension headers not horrible.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wold-style-cast"
        .sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
#pragma clang diagnostic pop
        .pNext = nullptr,
    };
    VkImageCreateInfo image_create = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .pNext = &image_native_buffer,
        .imageType = VK_IMAGE_TYPE_2D,
        .format = VK_FORMAT_R8G8B8A8_UNORM,  // TODO(jessehall)
        .extent = {0, 0, 1},
        .mipLevels = 1,
        .arraySize = 1,
        .samples = 1,
        .tiling = VK_IMAGE_TILING_OPTIMAL,
        .usage = create_info->imageUsageFlags,
        .flags = 0,
        .sharingMode = create_info->sharingMode,
        .queueFamilyCount = create_info->queueFamilyCount,
        .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
    };

    const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
    for (uint32_t i = 0; i < num_images; i++) {
        Swapchain::Image& img = swapchain->images[i];

        ANativeWindowBuffer* buffer;
        err = window->dequeueBuffer(window.get(), &buffer, &img.dequeue_fence);
        if (err != 0) {
            // TODO(jessehall): Improve error reporting. Can we enumerate
            // possible errors and translate them to valid Vulkan result codes?
            ALOGE("dequeueBuffer[%u] failed: %s (%d)", i, strerror(-err), err);
            result = VK_ERROR_INITIALIZATION_FAILED;
            break;
        }
        img.buffer = InitSharedPtr(device, buffer);
        img.dequeued = true;

        image_create.extent =
            VkExtent3D{img.buffer->width, img.buffer->height, 1};
        image_native_buffer.handle = img.buffer->handle;
        image_native_buffer.stride = img.buffer->stride;
        image_native_buffer.format = img.buffer->format;
        image_native_buffer.usage = img.buffer->usage;

        result = driver_vtbl.CreateImage(device, &image_create, &img.image);
        if (result != VK_SUCCESS) {
            ALOGD("vkCreateImage w/ native buffer failed: %u", result);
            break;
        }
    }

    // -- Cancel all buffers, returning them to the queue --
    // If an error occurred before, also destroy the VkImage and release the
    // buffer reference. Otherwise, we retain a strong reference to the buffer.
    //
    // TODO(jessehall): The error path here is the same as DestroySwapchain,
    // but not the non-error path. Should refactor/unify.
    for (uint32_t i = 0; i < num_images; i++) {
        Swapchain::Image& img = swapchain->images[i];
        if (img.dequeued) {
            window->cancelBuffer(window.get(), img.buffer.get(),
                                 img.dequeue_fence);
            img.dequeue_fence = -1;
            img.dequeued = false;
        }
        if (result != VK_SUCCESS) {
            if (img.image)
                driver_vtbl.DestroyImage(device, img.image);
        }
    }

    if (result != VK_SUCCESS) {
        native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
        swapchain->~Swapchain();
        FreeDeviceMem(device, swapchain);
        return result;
    }

    *swapchain_handle = HandleFromSwapchain(swapchain);
    return VK_SUCCESS;
}

VkResult DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain_handle) {
    const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
    Swapchain* swapchain = SwapchainFromHandle(swapchain_handle);
    const std::shared_ptr<ANativeWindow>& window = swapchain->window;

    for (uint32_t i = 0; i < swapchain->num_images; i++) {
        Swapchain::Image& img = swapchain->images[i];
        if (img.dequeued) {
            window->cancelBuffer(window.get(), img.buffer.get(),
                                 img.dequeue_fence);
            img.dequeue_fence = -1;
            img.dequeued = false;
        }
        if (img.image) {
            driver_vtbl.DestroyImage(device, img.image);
        }
    }

    native_window_api_disconnect(window.get(), NATIVE_WINDOW_API_EGL);
    swapchain->~Swapchain();
    FreeDeviceMem(device, swapchain);

    return VK_SUCCESS;
}

VkResult GetSwapchainImagesKHR(VkDevice,
                               VkSwapchainKHR swapchain_handle,
                               uint32_t* count,
                               VkImage* images) {
    Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
    VkResult result = VK_SUCCESS;
    if (images) {
        uint32_t n = swapchain.num_images;
        if (*count < swapchain.num_images) {
            n = *count;
            result = VK_INCOMPLETE;
        }
        for (uint32_t i = 0; i < n; i++)
            images[i] = swapchain.images[i].image;
    }
    *count = swapchain.num_images;
    return result;
}

VkResult AcquireNextImageKHR(VkDevice device,
                             VkSwapchainKHR swapchain_handle,
                             uint64_t timeout,
                             VkSemaphore semaphore,
                             uint32_t* image_index) {
    Swapchain& swapchain = *SwapchainFromHandle(swapchain_handle);
    VkResult result;
    int err;

    ALOGW_IF(
        timeout != UINT64_MAX,
        "vkAcquireNextImageKHR: non-infinite timeouts not yet implemented");

    ANativeWindowBuffer* buffer;
    int fence;
    err = swapchain.window->dequeueBuffer(swapchain.window.get(), &buffer,
                                          &fence);
    if (err != 0) {
        // TODO(jessehall): Improve error reporting. Can we enumerate possible
        // errors and translate them to valid Vulkan result codes?
        ALOGE("dequeueBuffer failed: %s (%d)", strerror(-err), err);
        return VK_ERROR_INITIALIZATION_FAILED;
    }

    uint32_t idx;
    for (idx = 0; idx < swapchain.num_images; idx++) {
        if (swapchain.images[idx].buffer.get() == buffer) {
            swapchain.images[idx].dequeued = true;
            swapchain.images[idx].dequeue_fence = fence;
            break;
        }
    }
    if (idx == swapchain.num_images) {
        ALOGE("dequeueBuffer returned unrecognized buffer");
        swapchain.window->cancelBuffer(swapchain.window.get(), buffer, fence);
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wold-style-cast"
        return VK_ERROR_OUT_OF_DATE_KHR;
#pragma clang diagnostic pop
    }

    int fence_clone = -1;
    if (fence != -1) {
        fence_clone = dup(fence);
        if (fence_clone == -1) {
            ALOGE("dup(fence) failed, stalling until signalled: %s (%d)",
                  strerror(errno), errno);
            sync_wait(fence, -1 /* forever */);
        }
    }

    const DeviceVtbl& driver_vtbl = GetDriverVtbl(device);
    result =
        driver_vtbl.ImportNativeFenceANDROID(device, semaphore, fence_clone);
    if (result != VK_SUCCESS) {
        // NOTE: we're relying on ImportNativeFenceANDROID to close
        // fence_clone, even if the call fails. We could close it ourselves on
        // failure, but that would create a race condition if the driver closes
        // it on a failure path. We must assume one of: the driver *always*
        // closes it even on failure, or *never* closes it on failure.
        swapchain.window->cancelBuffer(swapchain.window.get(), buffer, fence);
        swapchain.images[idx].dequeued = false;
        swapchain.images[idx].dequeue_fence = -1;
        return result;
    }

    *image_index = idx;
    return VK_SUCCESS;
}

VkResult QueuePresentKHR(VkQueue queue, VkPresentInfoKHR* present_info) {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wold-style-cast"
#pragma clang diagnostic ignored "-Wsign-conversion"
    ALOGV_IF(present_info->sType != VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
             "vkQueuePresentKHR: invalid VkPresentInfoKHR structure type %d",
             present_info->sType);
#pragma clang diagnostic pop
    ALOGV_IF(present_info->pNext, "VkPresentInfo::pNext != NULL");

    const DeviceVtbl& driver_vtbl = GetDriverVtbl(queue);
    VkResult final_result = VK_SUCCESS;
    for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
        Swapchain& swapchain =
            *SwapchainFromHandle(present_info->swapchains[sc]);
        uint32_t image_idx = present_info->imageIndices[sc];
        Swapchain::Image& img = swapchain.images[image_idx];
        VkResult result;
        int err;

        int fence = -1;
        result = driver_vtbl.QueueSignalNativeFenceANDROID(queue, &fence);
        if (result != VK_SUCCESS) {
            ALOGE("vkQueueSignalNativeFenceANDROID failed: %d", result);
            if (final_result == VK_SUCCESS)
                final_result = result;
            // TODO(jessehall): What happens to the buffer here? Does the app
            // still own it or not, i.e. should we cancel the buffer? Hard to
            // do correctly without synchronizing, though I guess we could wait
            // for the queue to idle.
            continue;
        }

        err = swapchain.window->queueBuffer(swapchain.window.get(),
                                            img.buffer.get(), fence);
        if (err != 0) {
            // TODO(jessehall): What now? We should probably cancel the buffer,
            // I guess?
            ALOGE("queueBuffer failed: %s (%d)", strerror(-err), err);
            if (final_result == VK_SUCCESS)
                final_result = VK_ERROR_INITIALIZATION_FAILED;
            continue;
        }

        if (img.dequeue_fence != -1) {
            close(img.dequeue_fence);
            img.dequeue_fence = -1;
        }
        img.dequeued = false;
    }

    return final_result;
}

}  // namespace vulkan