layers/swapchain.cpp

/*
 * Vulkan
 *
 * Copyright (C) 2015 LunarG, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *   Ian Elliott <ian@lunarg.com>
 */

#include "swapchain.h"

// FIXME/TODO: Make sure this layer is thread-safe!

// The following is for logging error messages:
static layer_data mydata;


static const VkLayerProperties globalLayerProps[] = {
    {
        "Swapchain",
        VK_API_VERSION,                 // specVersion
        VK_MAKE_VERSION(0, 1, 0),       // implVersion
        "layer: Swapchain",
    }
};

static const VkLayerProperties deviceLayerProps[] = {
    {
        "Swapchain",
        VK_API_VERSION,                 // specVersion
        VK_MAKE_VERSION(0, 1, 0),       // implVersion
        "layer: Swapchain",
    }
};


static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(initOnce);

// NOTE: The following are for keeping track of info that is used for
// validating the WSI extensions.
static std::unordered_map<void *, SwpInstance>       instanceMap;
static std::unordered_map<void *, SwpPhysicalDevice> physicalDeviceMap;
static std::unordered_map<void *, SwpDevice>         deviceMap;
static std::unordered_map<uint64_t, SwpSwapchain>    swapchainMap;


static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
{
    uint32_t i;
    VkLayerDispatchTable *pDisp  = device_dispatch_table(device);
    PFN_vkGetDeviceProcAddr gpa = pDisp->GetDeviceProcAddr;
    pDisp->GetSurfacePropertiesKHR = (PFN_vkGetSurfacePropertiesKHR) gpa(device, "vkGetSurfacePropertiesKHR");
    pDisp->GetSurfaceFormatsKHR = (PFN_vkGetSurfaceFormatsKHR) gpa(device, "vkGetSurfaceFormatsKHR");
    pDisp->GetSurfacePresentModesKHR = (PFN_vkGetSurfacePresentModesKHR) gpa(device, "vkGetSurfacePresentModesKHR");
    pDisp->CreateSwapchainKHR = (PFN_vkCreateSwapchainKHR) gpa(device, "vkCreateSwapchainKHR");
    pDisp->DestroySwapchainKHR = (PFN_vkDestroySwapchainKHR) gpa(device, "vkDestroySwapchainKHR");
    pDisp->GetSwapchainImagesKHR = (PFN_vkGetSwapchainImagesKHR) gpa(device, "vkGetSwapchainImagesKHR");
    pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR");
    pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");

    SwpPhysicalDevice *pPhysicalDevice = &physicalDeviceMap[physicalDevice];
    if (pPhysicalDevice) {
        deviceMap[device].pPhysicalDevice = pPhysicalDevice;
        pPhysicalDevice->pDevice = &deviceMap[device];
    } else {
        LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_PHYSICAL_DEVICE,
                                physicalDevice,
                                "VkPhysicalDevice");
    }
    deviceMap[device].device = device;
    deviceMap[device].deviceSwapchainExtensionEnabled = false;
    deviceMap[device].gotSurfaceProperties = false;
    deviceMap[device].surfaceFormatCount = 0;
    deviceMap[device].pSurfaceFormats = NULL;
    deviceMap[device].presentModeCount = 0;
    deviceMap[device].pPresentModes = NULL;

    // Record whether the WSI device extension was enabled for this VkDevice.
    // No need to check if the extension was advertised by
    // vkEnumerateDeviceExtensionProperties(), since the loader handles that.
    for (i = 0; i < pCreateInfo->extensionCount; i++) {
        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0) {

            deviceMap[device].deviceSwapchainExtensionEnabled = true;
        }
    }
}

static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreateInfo, VkInstance instance)
{
    uint32_t i;
    VkLayerInstanceDispatchTable *pDisp  = instance_dispatch_table(instance);
    PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr;
    pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");

    // Remember this instance, and whether the VK_EXT_KHR_swapchain extension
    // was enabled for it:
    instanceMap[instance].instance = instance;
    instanceMap[instance].swapchainExtensionEnabled = false;

    // Record whether the WSI instance extension was enabled for this
    // VkInstance.  No need to check if the extension was advertised by
    // vkEnumerateInstanceExtensionProperties(), since the loader handles that.
    for (i = 0; i < pCreateInfo->extensionCount; i++) {
        if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {

            instanceMap[instance].swapchainExtensionEnabled = true;
        }
    }
}


#include "vk_dispatch_table_helper.h"
static void initSwapchain(void)
{
    uint32_t report_flags = 0;
    uint32_t debug_action = 0;
    FILE *log_output = NULL;
    const char *option_str;

    // Initialize Swapchain options:
    report_flags = getLayerOptionFlags("SwapchainReportFlags", 0);
    getLayerOptionEnum("SwapchainDebugAction", (uint32_t *) &debug_action);

    if (debug_action & VK_DBG_LAYER_ACTION_LOG_MSG)
    {
        // Turn on logging, since it was requested:
        option_str = getLayerOption("SwapchainLogFilename");
        log_output = getLayerLogOutput(option_str, "Swapchain");
        layer_create_msg_callback(&mydata.report_data, report_flags,
                                  log_callback, (void *) log_output,
                                  &mydata.logging_callback);
    }
}

static const char *surfaceTransformStr(VkSurfaceTransformKHR value)
{
    static std::string surfaceTransformStrings[] = {
        "VK_SURFACE_TRANSFORM_NONE_KHR",
        "VK_SURFACE_TRANSFORM_ROT90_KHR",
        "VK_SURFACE_TRANSFORM_ROT180_KHR",
        "VK_SURFACE_TRANSFORM_ROT270_KHR",
        "VK_SURFACE_TRANSFORM_HMIRROR_KHR",
        "VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR",
        "VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR",
        "VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR",
        "Out-of-Range Value"};

    // Deal with a out-of-range value:
    switch (value) {
    case VK_SURFACE_TRANSFORM_NONE_KHR:
    case VK_SURFACE_TRANSFORM_ROT90_KHR:
    case VK_SURFACE_TRANSFORM_ROT180_KHR:
    case VK_SURFACE_TRANSFORM_ROT270_KHR:
    case VK_SURFACE_TRANSFORM_HMIRROR_KHR:
    case VK_SURFACE_TRANSFORM_HMIRROR_ROT90_KHR:
    case VK_SURFACE_TRANSFORM_HMIRROR_ROT180_KHR:
    case VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR:
        break;
    default:
        value =
            (VkSurfaceTransformKHR) (VK_SURFACE_TRANSFORM_HMIRROR_ROT270_KHR + 1);
        break;
    }

    // Return a string corresponding to the value:
    return surfaceTransformStrings[value].c_str();
}

static const char *presentModeStr(VkPresentModeKHR value)
{
    static std::string presentModeStrings[] = {
        "VK_PRESENT_MODE_IMMEDIATE_KHR",
        "VK_PRESENT_MODE_MAILBOX_KHR",
        "VK_PRESENT_MODE_FIFO_KHR",
        "Out-of-Range Value"};

    // Deal with a out-of-range value:
    switch (value) {
    case VK_PRESENT_MODE_IMMEDIATE_KHR:
    case VK_PRESENT_MODE_MAILBOX_KHR:
    case VK_PRESENT_MODE_FIFO_KHR:
        break;
    default:
        value = (VkPresentModeKHR) (VK_PRESENT_MODE_FIFO_KHR + 1);
        break;
    }

    // Return a string corresponding to the value:
    return presentModeStrings[value].c_str();
}


VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
{
    // Call down the call chain:
    VkResult result = instance_dispatch_table(*pInstance)->CreateInstance(pCreateInfo, pInstance);
    if (result == VK_SUCCESS) {
        // Since it succeeded, do layer-specific work:
        createInstanceRegisterExtensions(pCreateInfo, *pInstance);
    }
    return result;
}

VK_LAYER_EXPORT void VKAPI vkDestroyInstance(VkInstance instance)
{
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkInstance was used:
    SwpInstance *pInstance = &instanceMap[instance];
    if (!pInstance) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_INSTANCE,
                                            instance,
                                            "VkInstance");
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        dispatch_key key = get_dispatch_key(instance);
        VkLayerInstanceDispatchTable *pDisp = instance_dispatch_table(instance);
        pDisp->DestroyInstance(instance);
        destroy_instance_dispatch_table(key);
    }

    // Regardless of skipCall value, do some internal cleanup:
    if (pInstance) {
        // Delete all of the SwpPhysicalDevice's and the SwpInstance associated
        // with this instance:
        for (auto it = pInstance->physicalDevices.begin() ;
             it != pInstance->physicalDevices.end() ; it++) {
            // Erase the SwpPhysicalDevice's from the physicalDeviceMap (which
            // are simply pointed to by the SwpInstance):
            physicalDeviceMap.erase(it->second->physicalDevice);
        }
        instanceMap.erase(instance);
    }
}

VK_LAYER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkInstance was used:
    SwpInstance *pInstance = &instanceMap[instance];
    if (!pInstance) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_INSTANCE,
                                            instance,
                                            "VkInstance");
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = instance_dispatch_table(instance)->EnumeratePhysicalDevices(
                instance, pPhysicalDeviceCount, pPhysicalDevices);

        if ((result == VK_SUCCESS) && pInstance && pPhysicalDevices &&
            (*pPhysicalDeviceCount > 0)) {
            // Record the VkPhysicalDevices returned by the ICD:
            SwpInstance *pInstance = &instanceMap[instance];
            for (int i = 0; i < *pPhysicalDeviceCount; i++) {
                physicalDeviceMap[pPhysicalDevices[i]].physicalDevice =
                    pPhysicalDevices[i];
                physicalDeviceMap[pPhysicalDevices[i]].pInstance = pInstance;
                physicalDeviceMap[pPhysicalDevices[i]].pDevice = NULL;
                // Point to the associated SwpInstance:
                pInstance->physicalDevices[pPhysicalDevices[i]] =
                    &physicalDeviceMap[pPhysicalDevices[i]];
            }
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkPhysicalDevice was used:
    SwpPhysicalDevice *pPhysicalDevice = &physicalDeviceMap[physicalDevice];
    if (!pPhysicalDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_PHYSICAL_DEVICE,
                                            physicalDevice,
                                            "VkPhysicalDevice");
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(*pDevice)->CreateDevice(
                physicalDevice, pCreateInfo, pDevice);
        if (result == VK_SUCCESS) {
            // Since it succeeded, do layer-specific work:
            createDeviceRegisterExtensions(physicalDevice, pCreateInfo,
                                           *pDevice);
        }
        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
{
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        dispatch_key key = get_dispatch_key(device);
        VkLayerDispatchTable *pDisp  =  device_dispatch_table(device);
        pDisp->DestroyDevice(device);
        destroy_device_dispatch_table(key);
    }

    // Regardless of skipCall value, do some internal cleanup:
    if (pDevice) {
        // Delete the SwpDevice associated with this device:
        if (pDevice->pPhysicalDevice) {
            pDevice->pPhysicalDevice->pDevice = NULL;
        }
        if (deviceMap[device].pSurfaceFormats) {
            free(deviceMap[device].pSurfaceFormats);
        }
        if (deviceMap[device].pPresentModes) {
            free(deviceMap[device].pPresentModes);
        }
        deviceMap.erase(device);
        if (!pDevice->swapchains.empty()) {
            LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                      "%s() called before all of its associated "
                      "VkSwapchainKHRs were destroyed.",
                      __FUNCTION__);
            // Empty and then delete all SwpSwapchain's
            for (auto it = pDevice->swapchains.begin() ;
                 it != pDevice->swapchains.end() ; it++) {
                // Delete all SwpImage's
                it->second->images.clear();
            }
            pDevice->swapchains.clear();
        }
    }
}

VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkBool32* pSupported)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkPhysicalDevice was used, and that the instance
    // extension was enabled:
    SwpPhysicalDevice *pPhysicalDevice = &physicalDeviceMap[physicalDevice];
    if (!pPhysicalDevice || !pPhysicalDevice->pInstance) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_PHYSICAL_DEVICE,
                                            physicalDevice,
                                            "VkPhysicalDevice");
    } else if (!pPhysicalDevice->pInstance->swapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_INSTANCE,
                              pPhysicalDevice->pInstance,
                              "VkInstance",
                              "%s() called even though the "
                              VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkInstance.",
                              __FUNCTION__);
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportKHR(
                physicalDevice, queueFamilyIndex, pSurfaceDescription,
                pSupported);

        if ((result == VK_SUCCESS) && pSupported && pPhysicalDevice) {
            // Record the result of this query:
            pPhysicalDevice->queueFamilyIndexSupport[queueFamilyIndex] =
                *pSupported;
            // TODO: We need to compare this with the actual queue used for
            // presentation, to ensure it was advertised to the application as
            // supported for presentation.
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkGetSurfacePropertiesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, VkSurfacePropertiesKHR* pSurfaceProperties)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called even though the "
                              VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkDevice.",
                              __FUNCTION__);
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(device)->GetSurfacePropertiesKHR(
                device, pSurfaceDescription, pSurfaceProperties);

        if ((result == VK_SUCCESS) && pDevice) {
            pDevice->gotSurfaceProperties = true;
            pDevice->surfaceProperties = *pSurfaceProperties;
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkGetSurfaceFormatsKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called even though the "
                              VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkDevice.",
                              __FUNCTION__);
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(device)->GetSurfaceFormatsKHR(
                device, pSurfaceDescription, pCount, pSurfaceFormats);

        if ((result == VK_SUCCESS) && pDevice && pSurfaceFormats && pCount &&
            (*pCount > 0)) {
            pDevice->surfaceFormatCount = *pCount;
            pDevice->pSurfaceFormats = (VkSurfaceFormatKHR *)
                malloc(*pCount * sizeof(VkSurfaceFormatKHR));
            if (pDevice->pSurfaceFormats) {
                for (int i = 0 ; i < *pCount ; i++) {
                    pDevice->pSurfaceFormats[i] = pSurfaceFormats[i];
                }
            } else {
                pDevice->surfaceFormatCount = 0;
            }
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkGetSurfacePresentModesKHR(VkDevice device, const VkSurfaceDescriptionKHR* pSurfaceDescription, uint32_t* pCount, VkPresentModeKHR* pPresentModes)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called even though the "
                              VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkDevice.",
                              __FUNCTION__);
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(device)->GetSurfacePresentModesKHR(
                device, pSurfaceDescription, pCount, pPresentModes);

        if ((result == VK_SUCCESS) && pDevice && pPresentModes && pCount &&
            (*pCount > 0)) {
            pDevice->presentModeCount = *pCount;
            pDevice->pPresentModes = (VkPresentModeKHR *)
                malloc(*pCount * sizeof(VkPresentModeKHR));
            if (pDevice->pSurfaceFormats) {
                for (int i = 0 ; i < *pCount ; i++) {
                    pDevice->pPresentModes[i] = pPresentModes[i];
                }
            } else {
                pDevice->presentModeCount = 0;
            }
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

// This function does the up-front validation work for vkCreateSwapchainKHR(),
// and returns VK_TRUE if a logging callback indicates that the call down the
// chain should be skipped:
static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain)
{
// TODO: Validate cases of re-creating a swapchain (the current code
// assumes a new swapchain is being created).
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;
    char fn[] = "vkCreateSwapchainKHR";

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        return LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                         "%s() called with a non-valid %s.",
                         fn, "VkDevice");

    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        return LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                         "%s() called even though the "
                         VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                         "extension was not enabled for this VkDevice.",
                         fn);
    }

    // Validate pCreateInfo with the results for previous queries:
    if (!pDevice->gotSurfaceProperties) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called before calling "
                              "vkGetSurfacePropertiesKHR().",
                              fn);
    } else {
        // Validate pCreateInfo->minImageCount against
        // VkSurfacePropertiesKHR::{min|max}ImageCount:
        VkSurfacePropertiesKHR *pProps = &pDevice->surfaceProperties;
        if ((pCreateInfo->minImageCount < pProps->minImageCount) ||
            ((pProps->maxImageCount > 0) &&
             (pCreateInfo->minImageCount > pProps->maxImageCount))) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                  "%s() called with pCreateInfo->minImageCount "
                                  "= %d, which is outside the bounds returned "
                                  "by vkGetSurfacePropertiesKHR() (i.e. "
                                  "minImageCount = %d, maxImageCount = %d).",
                                  fn,
                                  pCreateInfo->minImageCount,
                                  pProps->minImageCount,
                                  pProps->maxImageCount);
        }
        // Validate pCreateInfo->imageExtent against
        // VkSurfacePropertiesKHR::{current|min|max}ImageExtent:
        if ((pProps->currentExtent.width == -1) &&
            ((pCreateInfo->imageExtent.width < pProps->minImageExtent.width) ||
             (pCreateInfo->imageExtent.width > pProps->maxImageExtent.width) ||
             (pCreateInfo->imageExtent.height < pProps->minImageExtent.height) ||
             (pCreateInfo->imageExtent.height > pProps->maxImageExtent.height))) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                  "%s() called with pCreateInfo->imageExtent = "
                                  "(%d,%d), which is outside the bounds "
                                  "returned by vkGetSurfacePropertiesKHR(): "
                                  "currentExtent = (%d,%d), minImageExtent = "
                                  "(%d,%d), maxImageExtent = (%d,%d).",
                                  fn,
                                  pCreateInfo->imageExtent.width,
                                  pCreateInfo->imageExtent.height,
                                  pProps->currentExtent.width,
                                  pProps->currentExtent.height,
                                  pProps->minImageExtent.width,
                                  pProps->minImageExtent.height,
                                  pProps->maxImageExtent.width,
                                  pProps->maxImageExtent.height);
        }
        if ((pProps->currentExtent.width != -1) &&
            ((pCreateInfo->imageExtent.width != pProps->currentExtent.width) ||
             (pCreateInfo->imageExtent.height != pProps->currentExtent.height))) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                  "%s() called with pCreateInfo->imageExtent = "
                                  "(%d,%d), which is not equal to the "
                                  "currentExtent = (%d,%d) returned by "
                                  "vkGetSurfacePropertiesKHR().",
                                  fn,
                                  pCreateInfo->imageExtent.width,
                                  pCreateInfo->imageExtent.height,
                                  pProps->currentExtent.width,
                                  pProps->currentExtent.height);
        }
        // Validate pCreateInfo->preTransform against
        // VkSurfacePropertiesKHR::supportedTransforms:
        if (!((1 << pCreateInfo->preTransform) & pProps->supportedTransforms)) {
            // This is an error situation; one for which we'd like to give
            // the developer a helpful, multi-line error message.  Build it
            // up a little at a time, and then log it:
            std::string errorString = "";
            char str[1024];
            // Here's the first part of the message:
            sprintf(str, "%s() called with a non-supported "
                    "pCreateInfo->preTransform (i.e. %s).  "
                    "Supported values are:\n",
                    fn,
                    surfaceTransformStr(pCreateInfo->preTransform));
            errorString += str;
            for (int i = VK_SURFACE_TRANSFORM_NONE_KHR ;
                 i < VK_SURFACE_TRANSFORM_INHERIT_KHR ; i++) {
                // Build up the rest of the message:
                if ((1 << i) & pProps->supportedTransforms) {
                    const char *newStr =
                        surfaceTransformStr((VkSurfaceTransformKHR) (1 << i));
                    sprintf(str, "    %s\n", newStr);
                    errorString += str;
                }
            }
            // Log the message that we've built up:
            skipCall |= debug_report_log_msg(&mydata.report_data,
                                             VK_DBG_REPORT_ERROR_BIT,
                                             VK_OBJECT_TYPE_DEVICE,
                                             (uint64_t) device,
                                             0, 0, LAYER_NAME,
                                             errorString.c_str());
        }
        // Validate pCreateInfo->imageArraySize against
        // VkSurfacePropertiesKHR::maxImageArraySize:
        if (pCreateInfo->imageArraySize <= pProps->maxImageArraySize) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                  "%s() called with a non-supported "
                                  "pCreateInfo->imageArraySize (i.e. %d).  "
                                  "Maximum value is %d.",
                                  fn,
                                  pCreateInfo->imageArraySize,
                                  pProps->maxImageArraySize);
        }
        // Validate pCreateInfo->imageUsageFlags against
        // VkSurfacePropertiesKHR::supportedUsageFlags:
        if (pCreateInfo->imageUsageFlags &&
            (pCreateInfo->imageUsageFlags !=
             (pCreateInfo->imageUsageFlags & pProps->supportedUsageFlags))) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                  "%s() called with a non-supported "
                                  "pCreateInfo->imageUsageFlags (i.e. 0x%08x)."
                                  "  Supported flag bits are 0x%08x.",
                                  fn,
                                  pCreateInfo->imageUsageFlags,
                                  pProps->supportedUsageFlags);
        }
    }
    if (!pDevice->surfaceFormatCount) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called before calling "
                              "vkGetSurfaceFormatsKHR().",
                              fn);
    } else {
        // Validate pCreateInfo->imageFormat against
        // VkSurfaceFormatKHR::format:
        bool foundFormat = false;
        bool foundColorSpace = false;
        bool foundMatch = false;
        for (int i = 0 ; i < pDevice->surfaceFormatCount ; i++) {
            if (pCreateInfo->imageFormat == pDevice->pSurfaceFormats[i].format) {
                // Validate pCreateInfo->imageColorSpace against
                // VkSurfaceFormatKHR::colorSpace:
                foundFormat = true;
                if (pCreateInfo->imageColorSpace == pDevice->pSurfaceFormats[i].colorSpace) {
                    foundMatch = true;
                    break;
                }
            } else {
                if (pCreateInfo->imageColorSpace == pDevice->pSurfaceFormats[i].colorSpace) {
                    foundColorSpace = true;
                }
            }
        }
        if (!foundMatch) {
            if (!foundFormat) {
                if (!foundColorSpace) {
                    skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device,
                                          "VkDevice",
                                          "%s() called with neither a "
                                          "supported pCreateInfo->imageFormat "
                                          "(i.e. %d) nor a supported "
                                          "pCreateInfo->imageColorSpace "
                                          "(i.e. %d).",
                                          fn,
                                          pCreateInfo->imageFormat,
                                          pCreateInfo->imageColorSpace);
                } else {
                    skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device,
                                              "VkDevice",
                                          "%s() called with a non-supported "
                                          "pCreateInfo->imageFormat (i.e. %d).",
                                          fn, pCreateInfo->imageFormat);
                }
            } else if (!foundColorSpace) {
                skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                      "%s() called with a non-supported "
                                      "pCreateInfo->imageColorSpace (i.e. %d).",
                                      fn, pCreateInfo->imageColorSpace);
            }
        }
    }
    if (!pDevice->presentModeCount) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called before calling "
                              "vkGetSurfacePresentModesKHR().",
                              fn);
    } else {
        // Validate pCreateInfo->presentMode against
        // vkGetSurfacePresentModesKHR():
        bool foundMatch = false;
        for (int i = 0 ; i < pDevice->presentModeCount ; i++) {
            if (pDevice->pPresentModes[i] == pCreateInfo->presentMode) {
                foundMatch = true;
                break;
            }
        }
        if (!foundMatch) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                                  "%s() called with a non-supported "
                                  "pCreateInfo->presentMode (i.e. %s).",
                                  fn,
                                  presentModeStr(pCreateInfo->presentMode));
        }
    }

    // TODO: Validate the following values:
    // - pCreateInfo->sharingMode
    // - pCreateInfo->queueFamilyCount
    // - pCreateInfo->pQueueFamilyIndices
    // - pCreateInfo->oldSwapchain

    return skipCall;
}

VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = validateCreateSwapchainKHR(device, pCreateInfo,
                                                   pSwapchain);

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(device)->CreateSwapchainKHR(
                device, pCreateInfo, pSwapchain);

        if (result == VK_SUCCESS) {
            // Remember the swapchain's handle, and link it to the device:
            SwpDevice *pDevice = &deviceMap[device];

            swapchainMap[pSwapchain->handle].swapchain = *pSwapchain;
            pDevice->swapchains[pSwapchain->handle] =
                &swapchainMap[pSwapchain->handle];
            swapchainMap[pSwapchain->handle].pDevice = pDevice;
            swapchainMap[pSwapchain->handle].imageCount = 0;
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain)
{
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called even though the "
                              VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkDevice.",
                              __FUNCTION__);
    }

    // Regardless of skipCall value, do some internal cleanup:
    SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
    if (pSwapchain) {
        // Delete the SwpSwapchain associated with this swapchain:
        if (pSwapchain->pDevice) {
            pSwapchain->pDevice->swapchains.erase(swapchain.handle);
            if (device != pSwapchain->pDevice->device) {
                LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                          "%s() called with a different VkDevice than the "
                          "VkSwapchainKHR was created with.",
                          __FUNCTION__);
            }
        }
        if (pSwapchain->imageCount) {
            pSwapchain->images.clear();
        }
        swapchainMap.erase(swapchain.handle);
    } else {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                            swapchain.handle,
                                            "VkSwapchainKHR");
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        VkResult result = device_dispatch_table(device)->DestroySwapchainKHR(device, swapchain);
        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages)
{
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called even though the "
                              VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkDevice.",
                              __FUNCTION__);
    }
    SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
    if (!pSwapchain) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                            swapchain.handle,
                                            "VkSwapchainKHR");
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(device)->GetSwapchainImagesKHR(
                device, swapchain, pCount, pSwapchainImages);

        if ((result == VK_SUCCESS) && pSwapchain &&pSwapchainImages &&
            pCount && (*pCount > 0)) {
            // Record the images and their state:
            if (pSwapchain) {
                pSwapchain->imageCount = *pCount;
                for (int i = 0 ; i < *pCount ; i++) {
                    pSwapchain->images[i].image = pSwapchainImages[i];
                    pSwapchain->images[i].pSwapchain = pSwapchain;
                    pSwapchain->images[i].ownedByApp = false;
                }
            }
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, uint32_t* pImageIndex)
{
// TODO: Record/update the state of the swapchain, in case an error occurs
// (e.g. VK_ERROR_OUT_OF_DATE_KHR).
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    // Validate that a valid VkDevice was used, and that the device
    // extension was enabled:
    SwpDevice *pDevice = &deviceMap[device];
    if (!pDevice) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_DEVICE,
                                            device,
                                            "VkDevice");
    } else if (!pDevice->deviceSwapchainExtensionEnabled) {
        skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                              "%s() called even though the "
                              VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                              "extension was not enabled for this VkDevice.",
                              __FUNCTION__);
    }
    // Validate that a valid VkSwapchainKHR was used:
    SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
    if (!pSwapchain) {
        skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                            swapchain.handle,
                                            "VkSwapchainKHR");
    } else {
        // Look to see if the application is trying to own too many images at
        // the same time (i.e. not leave any to display):
        int imagesOwnedByApp = 0;
        for (int i = 0 ; i < pSwapchain->imageCount ; i++) {
            if (pSwapchain->images[i].ownedByApp) {
                imagesOwnedByApp++;
            }
        }
        if (imagesOwnedByApp >= (pSwapchain->imageCount - 1)) {
            skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR, swapchain,
                                  "VkSwapchainKHR",
                                  "%s() called when the application already "
                                  "owns all presentable images in this "
                                  "swapchain except for the image currently "
                                  "being displayed.  This call to %s() cannot "
                                  "succeed unless another thread calls the "
                                  "vkQueuePresentKHR() function in order to "
                                  "release ownership of one of the presentable "
                                  "images of this swapchain.",
                                  __FUNCTION__, __FUNCTION__);
        }
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(device)->AcquireNextImageKHR(
                device, swapchain, timeout, semaphore, pImageIndex);

        if (((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR)) &&
            pSwapchain) {
            if (*pImageIndex >= pSwapchain->imageCount) {
                LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR, swapchain,
                          "VkSwapchainKHR",
                          "%s() returned an index that's too large (i.e. %d).  "
                          "There are only %d images in this VkSwapchainKHR.",
                          __FUNCTION__, *pImageIndex, pSwapchain->imageCount);
            }
            if (pSwapchain->images[*pImageIndex].ownedByApp) {
                LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR, swapchain,
                          "VkSwapchainKHR",
                          "%s() returned an index (i.e. %d) for an image that "
                          "is already owned by the application.\n",
                          __FUNCTION__, *pImageIndex);
            }
            // Change the state of the image (now owned by the application):
            pSwapchain->images[*pImageIndex].ownedByApp = true;
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

VK_LAYER_EXPORT VkResult VKAPI vkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo)
{
// TODOs:
//
// - Ensure that the queue is active, and is one of the queueFamilyIndex's
//   that was returned by a previuos query.
// - Record/update the state of the swapchain, in case an error occurs
//   (e.g. VK_ERROR_OUT_OF_DATE_KHR).
    VkResult result = VK_SUCCESS;
    VkBool32 skipCall = VK_FALSE;

    for (int i = 0; i < pPresentInfo->swapchainCount ; i++) {
        int index = pPresentInfo->imageIndices[i];
        SwpSwapchain *pSwapchain =
            &swapchainMap[pPresentInfo->swapchains[i].handle];
        if (pSwapchain) {
            if (!pSwapchain->pDevice->deviceSwapchainExtensionEnabled) {
                skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE,
                                      pSwapchain->pDevice, "VkDevice",
                                      "%s() called even though the "
                                      VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
                                      "extension was not enabled for this "
                                      "VkDevice.",
                                      __FUNCTION__);
            }
            if (index >= pSwapchain->imageCount) {
                skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                      pPresentInfo->swapchains[i].handle,
                                      "VkSwapchainKHR",
                                      "%s() called for an index that is too "
                                      "large (i.e. %d).  There are only %d "
                                      "images in this VkSwapchainKHR.\n",
                                      __FUNCTION__, index,
                                      pSwapchain->imageCount);
            } else {
                if (!pSwapchain->images[index].ownedByApp) {
                    skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                          pPresentInfo->swapchains[i].handle,
                                          "VkSwapchainKHR",
                                          "%s() returned an index (i.e. %d) "
                                          "for an image that is not owned by "
                                          "the application.",
                                          __FUNCTION__, index);
                }
            }
        } else {
            skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                                pPresentInfo->swapchains[i].handle,
                                                "VkSwapchainKHR");
        }
    }

    if (VK_FALSE == skipCall) {
        // Call down the call chain:
        result = device_dispatch_table(queue)->QueuePresentKHR(queue,
                                                               pPresentInfo);

        if ((result == VK_SUCCESS) || (result == VK_SUBOPTIMAL_KHR)) {
            for (int i = 0; i < pPresentInfo->swapchainCount ; i++) {
                int index = pPresentInfo->imageIndices[i];
                SwpSwapchain *pSwapchain =
                    &swapchainMap[pPresentInfo->swapchains[i].handle];
                if (pSwapchain) {
                    // Change the state of the image (no longer owned by the
                    // application):
                    pSwapchain->images[index].ownedByApp = false;
                }
            }
        }

        return result;
    }
    return VK_ERROR_VALIDATION_FAILED;
}

static inline PFN_vkVoidFunction layer_intercept_proc(const char *name)
{
    if (!name || name[0] != 'v' || name[1] != 'k')
        return NULL;

    name += 2;
    if (!strcmp(name, "CreateInstance"))
        return (PFN_vkVoidFunction) vkCreateInstance;
    if (!strcmp(name, "DestroyInstance"))
        return (PFN_vkVoidFunction) vkDestroyInstance;
    if (!strcmp(name, "EnumeratePhysicalDevices"))
        return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;
    if (!strcmp(name, "CreateDevice"))
        return (PFN_vkVoidFunction) vkCreateDevice;
    if (!strcmp(name, "DestroyDevice"))
        return (PFN_vkVoidFunction) vkDestroyDevice;

    return NULL;
}
static inline PFN_vkVoidFunction layer_intercept_instance_proc(const char *name)
{
    if (!name || name[0] != 'v' || name[1] != 'k')
        return NULL;

    name += 2;
    if (!strcmp(name, "CreateInstance"))
        return (PFN_vkVoidFunction) vkCreateInstance;
    if (!strcmp(name, "DestroyInstance"))
        return (PFN_vkVoidFunction) vkDestroyInstance;
    if (!strcmp(name, "EnumeratePhysicalDevices"))
        return (PFN_vkVoidFunction) vkEnumeratePhysicalDevices;

    return NULL;
}

VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDbgMsgCallback* pMsgCallback)
{
    return layer_create_msg_callback(&mydata.report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
}

VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(VkInstance instance, VkDbgMsgCallback msgCallback)
{
    layer_destroy_msg_callback(&mydata.report_data, msgCallback);
    return VK_SUCCESS;
}

VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
{
    PFN_vkVoidFunction addr;
    if (device == VK_NULL_HANDLE) {
        return NULL;
    }
    loader_platform_thread_once(&initOnce, initSwapchain);

    /* loader uses this to force layer initialization; device object is wrapped */
    if (!strcmp("vkGetDeviceProcAddr", funcName)) {
        initDeviceTable((const VkBaseLayerObject *) device);
        return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
    }

    addr = layer_intercept_proc(funcName);
    if (addr)
        return addr;

    VkLayerDispatchTable *pDisp =  device_dispatch_table(device);
    if (deviceMap.size() != 0 &&
        deviceMap[pDisp].deviceSwapchainExtensionEnabled)
    {
        if (!strcmp("vkGetSurfacePropertiesKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePropertiesKHR);
        if (!strcmp("vkGetSurfaceFormatsKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfaceFormatsKHR);
        if (!strcmp("vkGetSurfacePresentModesKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSurfacePresentModesKHR);
        if (!strcmp("vkCreateSwapchainKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR);
        if (!strcmp("vkDestroySwapchainKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR);
        if (!strcmp("vkGetSwapchainImagesKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR);
        if (!strcmp("vkAcquireNextImageKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR);
        if (!strcmp("vkQueuePresentKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR);
    }
    {
        if (pDisp->GetDeviceProcAddr == NULL)
            return NULL;
        return pDisp->GetDeviceProcAddr(device, funcName);
    }
}

VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instance, const char* funcName)
{
    PFN_vkVoidFunction addr;
    if (instance == VK_NULL_HANDLE) {
        return NULL;
    }
    loader_platform_thread_once(&initOnce, initSwapchain);

    /* loader uses this to force layer initialization; instance object is wrapped */
    if (!strcmp("vkGetInstanceProcAddr", funcName)) {
        initInstanceTable((const VkBaseLayerObject *) instance);
        return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
    }

    addr = layer_intercept_instance_proc(funcName);
    if (addr)
        return addr;

    VkLayerInstanceDispatchTable* pTable = instance_dispatch_table(instance);
    if (instanceMap.size() != 0 &&
        instanceMap[instance].swapchainExtensionEnabled)
    {
        if (!strcmp("vkGetPhysicalDeviceSurfaceSupportKHR", funcName))
            return reinterpret_cast<PFN_vkVoidFunction>(vkGetPhysicalDeviceSurfaceSupportKHR);
    }

    if (pTable->GetInstanceProcAddr == NULL)
        return NULL;
    return pTable->GetInstanceProcAddr(instance, funcName);
}