// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <fuchsia/sysmem/cpp/fidl.h>
#include <lib/fdio/directory.h>
#include <vk_dispatch_table_helper.h>
#include <vk_layer_data.h>
#include <vk_layer_extension_utils.h>
#include <vk_layer_utils_minimal.h>

#include <unordered_map>
#include <vector>

#include <fbl/auto_call.h>
#include <sdk/lib/syslog/cpp/macros.h>
#include <vulkan/vk_layer.h>

#define VK_LAYER_API_VERSION VK_MAKE_VERSION(1, 1, VK_HEADER_VERSION)

namespace compact_image {

constexpr VkExtensionProperties device_extensions[] = {{
    .extensionName = "VK_FUCHSIA_compact_image",
    .specVersion = 1,
}};

constexpr VkLayerProperties compact_image_layer = {
    "VK_LAYER_FUCHSIA_compact_image",
    VK_LAYER_API_VERSION,
    1,
    "Compact Image",
};

//
// Shaders
//

#include "pack.spv.h"
#include "unpack.spv.h"

// Push constant block used by all shaders.
struct PushConstantBlock {
  VkDeviceAddress image_address;
  VkDeviceAddress scratch_address;
  VkDeviceAddress aux_address;
  uint32_t body_offset;
  uint32_t block_count;
};

//
// AFBC constants
//

constexpr uint32_t kAfbcBodyAlignment = 4096u;
constexpr uint32_t kAfbcWidthAlignment = 128u;
constexpr uint32_t kAfbcHeightAlignment = 128u;
constexpr uint32_t kAfbcTilePixelWidth = 16u;
constexpr uint32_t kAfbcTilePixelHeight = 16u;
constexpr uint32_t kTileBytesPerPixel = 4u;
constexpr uint32_t kTileNumPixels = kAfbcTilePixelWidth * kAfbcTilePixelHeight;
constexpr uint32_t kTileNumBytes = kTileNumPixels * kTileBytesPerPixel;
constexpr uint32_t kAfbcBytesPerTileHeader = 16u;
constexpr uint32_t kAfbcSuperblockTileWidth = 8u;
constexpr uint32_t kAfbcSuperblockTileHeight = 8u;
constexpr uint32_t kAfbcSuperblockPixelWidth = kAfbcSuperblockTileWidth * kAfbcTilePixelWidth;
constexpr uint32_t kAfbcSuperblockPixelHeight = kAfbcSuperblockTileHeight * kAfbcTilePixelHeight;
constexpr uint32_t kAfbcSuperblockTileCount = kAfbcSuperblockTileWidth * kAfbcSuperblockTileHeight;
constexpr uint32_t kAfbcBytesPerSuperblockHeader =
    kAfbcSuperblockTileCount * kAfbcBytesPerTileHeader;

//
// Vulkan utility functions
//

struct vk_struct_common {
  VkStructureType sType;
  struct vk_struct_common* pNext;
};

#define vk_foreach_struct(__iter, __start)                                            \
  for (struct vk_struct_common* __iter = (struct vk_struct_common*)(__start); __iter; \
       __iter = __iter->pNext)

#define vk_foreach_struct_const(__iter, __start)                                                  \
  for (const struct vk_struct_common* __iter = (const struct vk_struct_common*)(__start); __iter; \
       __iter = __iter->pNext)

inline void* __vk_find_struct(void* start, VkStructureType sType) {
  vk_foreach_struct(s, start) {
    if (s->sType == sType)
      return s;
  }
  return nullptr;
}

#define vk_find_struct(__start, __sType) __vk_find_struct((__start), VK_STRUCTURE_TYPE_##__sType)

#define vk_find_struct_const(__start, __sType) \
  (const void*)__vk_find_struct((void*)(__start), VK_STRUCTURE_TYPE_##__sType)

//
// AFBC image compactor
//
// This class implements packing and unpacking of AFBC images
// when transitioning to/from image layouts that support packed
// mode.
//
// Compute shaders are used to pack/unpack images and dedicated
// memory allocations are required to control the exact tiling
// format used for images.
//
class ImageCompactor {
 public:
  ImageCompactor(VkDevice device, VkLayerDispatchTable* dispatch)
      : device_(device), dispatch_(dispatch) {}

  // Returns true if vendor ID and device ID are supported.
  static bool IsSupportedGPU(uint32_t vendor_id, uint32_t device_id) {
    switch (vendor_id) {
      case 0x13b5:  // ARM
        switch (device_id) {
          case 0x70930000:  // BIFROST4
          case 0x72120000:  // BIFROST8
            return true;
          default:
            break;
        }
      default:
        break;
    }
    return false;
  }

  // Returns compact image format properties if supported.
  static VkResult GetImageFormatProperties(const VkPhysicalDeviceProperties& gpu_properties,
                                           VkFormat format, VkImageType type, VkImageTiling tiling,
                                           VkImageUsageFlags usage, VkImageCreateFlags flags,
                                           VkImageFormatProperties* pImageFormatProperties) {
    if (!IsSupportedGPU(gpu_properties.vendorID, gpu_properties.deviceID)) {
      return VK_ERROR_FORMAT_NOT_SUPPORTED;
    }

    if (!IsSupportedFormat(format) || !IsSupportedUsage(usage)) {
      return VK_ERROR_FORMAT_NOT_SUPPORTED;
    }

    // 2D image type is supported.
    if (type != VK_IMAGE_TYPE_2D) {
      return VK_ERROR_FORMAT_NOT_SUPPORTED;
    }

    // Compaction is only supported for optimal tiling images.
    if (tiling != VK_IMAGE_TILING_OPTIMAL) {
      return VK_ERROR_FORMAT_NOT_SUPPORTED;
    }

    // Mutable formats are not supported.
    if (flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT) {
      return VK_ERROR_FORMAT_NOT_SUPPORTED;
    }

    // Return compact image properties.
    *pImageFormatProperties = VkImageFormatProperties{
        .maxExtent = VkExtent3D{.width = 8192, .height = 8192, .depth = 1},
        .maxMipLevels = 1,
        .maxArrayLayers = 1,
        .sampleCounts = 1,
        .maxResourceSize = 0x80000000,
    };
    return VK_SUCCESS;
  }

  // Initialize image compactor. Connects to sysmem and creates
  // compute pipelines needed for packing and unpacking.
  VkResult Init(PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr,
                const VkAllocationCallbacks* pAllocator) {
    // Connect to sysmem allocator service.
    zx_status_t status = fdio_service_connect(
        "/svc/fuchsia.sysmem.Allocator", sysmem_allocator_.NewRequest().TakeChannel().release());
    if (status != ZX_OK) {
      fprintf(stderr, "Couldn't connect to sysmem service\n");
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    auto cleanup = fbl::MakeAutoCall([this, pAllocator] { Cleanup(pAllocator); });

    // Create pipeline layout that will be used by all shaders.
    VkResult result =
        CreatePipelineLayout(sizeof(PushConstantBlock), pAllocator, &pipeline_layout_);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    // Create compute pipeline used to pack AFBC images.
    result = CreateComputePipeline(pack_comp_spv, sizeof(pack_comp_spv), pipeline_layout_,
                                   pAllocator, &pack_pipeline_);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    // Create compute pipeline used to unpack AFBC images.
    result = CreateComputePipeline(unpack_comp_spv, sizeof(unpack_comp_spv), pipeline_layout_,
                                   pAllocator, &unpack_pipeline_);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    result = CreateBuffer(kTileNumBytes * kAfbcSuperblockTileCount, nullptr, pAllocator,
                          &scratch_.buffer);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }
    result = AllocateAndBindBufferMemory(scratch_.buffer, nullptr, pAllocator, &scratch_.memory,
                                         &scratch_.device_address);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    cleanup.cancel();
    return VK_SUCCESS;
  }

  void Cleanup(const VkAllocationCallbacks* pAllocator) {
    if (scratch_.buffer != VK_NULL_HANDLE) {
      dispatch_->DestroyBuffer(device_, scratch_.buffer, pAllocator);
    }
    if (scratch_.memory != VK_NULL_HANDLE) {
      dispatch_->FreeMemory(device_, scratch_.memory, pAllocator);
    }
    if (pack_pipeline_ != VK_NULL_HANDLE) {
      dispatch_->DestroyPipeline(device_, pack_pipeline_, pAllocator);
    }
    if (unpack_pipeline_ != VK_NULL_HANDLE) {
      dispatch_->DestroyPipeline(device_, unpack_pipeline_, pAllocator);
    }
    if (pipeline_layout_ != VK_NULL_HANDLE) {
      dispatch_->DestroyPipelineLayout(device_, pipeline_layout_, pAllocator);
    }
  }

  VkResult CreateImage(const VkImageCreateInfo* pCreateInfo,
                       const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
    // Early out if this is a regular image.
    if (!(pCreateInfo->flags & VK_IMAGE_CREATE_COMPACT_BIT_FUCHSIA)) {
      return dispatch_->CreateImage(device_, pCreateInfo, pAllocator, pImage);
    }

    FX_CHECK(IsSupportedFormat(pCreateInfo->format));
    FX_CHECK(IsSupportedUsage(pCreateInfo->usage));
    FX_CHECK(pCreateInfo->imageType == VK_IMAGE_TYPE_2D);
    FX_CHECK(pCreateInfo->tiling == VK_IMAGE_TILING_OPTIMAL);
    FX_CHECK(!(pCreateInfo->flags & VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT));
    FX_CHECK(pCreateInfo->mipLevels == 1);
    FX_CHECK(pCreateInfo->arrayLayers == 1);
    FX_CHECK(pCreateInfo->samples == VK_SAMPLE_COUNT_1_BIT);

    // Calculate superblock dimensions for image.
    uint32_t width_in_superblocks =
        RoundUp(pCreateInfo->extent.width, kAfbcWidthAlignment) / kAfbcSuperblockPixelWidth;
    uint32_t height_in_superblocks =
        RoundUp(pCreateInfo->extent.height, kAfbcHeightAlignment) / kAfbcSuperblockPixelHeight;
    uint32_t num_superblocks = width_in_superblocks * height_in_superblocks;
    uint32_t body_offset =
        RoundUp(num_superblocks * kAfbcBytesPerSuperblockHeader, kAfbcBodyAlignment);

    // Create single buffer collection for image.
    fuchsia::sysmem::BufferCollectionTokenSyncPtr local_token;
    zx_status_t status = sysmem_allocator_->AllocateSharedCollection(local_token.NewRequest());
    if (status != ZX_OK) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }
    fuchsia::sysmem::BufferCollectionTokenSyncPtr vulkan_image_token;
    status = local_token->Duplicate(std::numeric_limits<uint32_t>::max(),
                                    vulkan_image_token.NewRequest());
    if (status != ZX_OK) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }
    fuchsia::sysmem::BufferCollectionTokenSyncPtr vulkan_buffer_token;
    status = local_token->Duplicate(std::numeric_limits<uint32_t>::max(),
                                    vulkan_buffer_token.NewRequest());
    if (status != ZX_OK) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }
    status = local_token->Sync();
    if (status != ZX_OK) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    VkBufferCollectionCreateInfoFUCHSIA image_collection_create_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
        .pNext = nullptr,
        .collectionToken = vulkan_image_token.Unbind().TakeChannel().release(),
    };
    VkBufferCollectionFUCHSIA collection;
    VkResult result = dispatch_->CreateBufferCollectionFUCHSIA(
        device_, &image_collection_create_info, nullptr, &collection);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    auto cleanup_collection = fbl::MakeAutoCall([this, collection, pAllocator] {
      dispatch_->DestroyBufferCollectionFUCHSIA(device_, collection, pAllocator);
    });

    VkSysmemColorSpaceFUCHSIA color_space = {
        .colorSpace = static_cast<uint32_t>(fuchsia::sysmem::ColorSpaceType::SRGB),
    };
    VkImageFormatConstraintsInfoFUCHSIA image_format_constraints_info = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA,
        .pNext = nullptr,
        .requiredFormatFeatures = 0,
        .flags = 0,
        .sysmemFormat = static_cast<uint32_t>(fuchsia::sysmem::PixelFormatType::R8G8B8A8),
        .colorSpaceCount = 1,
        .pColorSpaces = &color_space,
    };
    VkImageConstraintsInfoFUCHSIA image_constraints_info = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA,
        .pNext = nullptr,
        .createInfoCount = 1,
        .pCreateInfos = pCreateInfo,
        .pFormatConstraints = &image_format_constraints_info,
        .minBufferCount = 1,
        .maxBufferCount = 1,
        .minBufferCountForDedicatedSlack = 0,
        .minBufferCountForSharedSlack = 0,
    };
    result = dispatch_->SetBufferCollectionImageConstraintsFUCHSIA(device_, collection,
                                                                   &image_constraints_info);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    VkBufferCollectionCreateInfoFUCHSIA buffer_collection_create_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
        .pNext = nullptr,
        .collectionToken = vulkan_buffer_token.Unbind().TakeChannel().release(),
    };
    VkBufferCollectionFUCHSIA collection_for_buffer;
    result = dispatch_->CreateBufferCollectionFUCHSIA(device_, &buffer_collection_create_info,
                                                      nullptr, &collection_for_buffer);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    auto cleanup_collection_for_buffer =
        fbl::MakeAutoCall([this, collection_for_buffer, pAllocator] {
          dispatch_->DestroyBufferCollectionFUCHSIA(device_, collection_for_buffer, pAllocator);
        });

    VkBufferCreateInfo buffer_create_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .size = body_offset + num_superblocks * kAfbcSuperblockTileCount * kTileNumBytes,
        .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .queueFamilyIndexCount = 0,
        .pQueueFamilyIndices = nullptr,
    };
    VkBufferConstraintsInfoFUCHSIA buffer_constraints_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA,
        .pNext = nullptr,
        .pBufferCreateInfo = &buffer_create_info,
        .requiredFormatFeatures = 0,
        .minCount = 1,
    };
    result = dispatch_->SetBufferCollectionBufferConstraintsFUCHSIA(device_, collection_for_buffer,
                                                                    &buffer_constraints_info);
    if (result != VK_SUCCESS) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    fuchsia::sysmem::BufferCollectionSyncPtr buffer_collection;
    status = sysmem_allocator_->BindSharedCollection(std::move(local_token),
                                                     buffer_collection.NewRequest());
    if (status != ZX_OK) {
      return VK_ERROR_INITIALIZATION_FAILED;
    }

    fuchsia::sysmem::BufferCollectionConstraints constraints;
    constraints.min_buffer_count = 1;
    constraints.usage.vulkan = 0;
    if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
      constraints.usage.vulkan |= fuchsia::sysmem::VULKAN_IMAGE_USAGE_TRANSFER_SRC;
    }
    if (pCreateInfo->usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
      constraints.usage.vulkan |= fuchsia::sysmem::VULKAN_IMAGE_USAGE_TRANSFER_DST;
    }
    if (pCreateInfo->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
      constraints.usage.vulkan |= fuchsia::sysmem::VULKAN_IMAGE_USAGE_SAMPLED;
    }
    constraints.has_buffer_memory_constraints = true;
    constraints.buffer_memory_constraints.ram_domain_supported = true;
    constraints.buffer_memory_constraints.cpu_domain_supported = true;
    constraints.buffer_memory_constraints.inaccessible_domain_supported = true;
    constraints.image_format_constraints_count = 1;
    fuchsia::sysmem::ImageFormatConstraints& image_constraints =
        constraints.image_format_constraints[0];
    image_constraints = fuchsia::sysmem::ImageFormatConstraints();
    image_constraints.min_coded_width = pCreateInfo->extent.width;
    image_constraints.min_coded_height = pCreateInfo->extent.height;
    image_constraints.max_coded_width = pCreateInfo->extent.width;
    image_constraints.max_coded_height = pCreateInfo->extent.height;
    image_constraints.min_bytes_per_row = 0;
    image_constraints.pixel_format.type = fuchsia::sysmem::PixelFormatType::R8G8B8A8;
    image_constraints.color_spaces_count = 1;
    image_constraints.color_space[0].type = fuchsia::sysmem::ColorSpaceType::SRGB;
    image_constraints.pixel_format.has_format_modifier = true;
    image_constraints.pixel_format.format_modifier.value =
        fuchsia::sysmem::FORMAT_MODIFIER_ARM_AFBC_16X16_YUV_TILED_HEADER;

    status = buffer_collection->SetConstraints(true, constraints);
    FX_CHECK(status == ZX_OK);

    zx_status_t allocation_status;
    fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info = {};
    status =
        buffer_collection->WaitForBuffersAllocated(&allocation_status, &buffer_collection_info);
    FX_CHECK(status == ZX_OK);
    FX_CHECK(allocation_status == ZX_OK);
    FX_CHECK(buffer_collection_info.settings.image_format_constraints.pixel_format.type ==
             image_constraints.pixel_format.type);

    VkBufferCollectionBufferCreateInfoFUCHSIA collection_buffer_create_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA,
        .pNext = nullptr,
        .collection = collection_for_buffer,
        .index = 0,
    };
    buffer_create_info.pNext = &collection_buffer_create_info;
    VkBuffer buffer;
    result = dispatch_->CreateBuffer(device_, &buffer_create_info, pAllocator, &buffer);
    if (result != VK_SUCCESS) {
      return result;
    }

    auto cleanup_buffer = fbl::MakeAutoCall(
        [this, buffer, pAllocator] { dispatch_->DestroyBuffer(device_, buffer, pAllocator); });

    // Create memory allocation by importing the sysmem collection.
    VkImportMemoryBufferCollectionFUCHSIA import_info = {
        .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
        .pNext = nullptr,
        .collection = collection_for_buffer,
        .index = 0,
    };
    VkDeviceMemory buffer_memory;
    VkDeviceAddress buffer_device_address;
    result = AllocateAndBindBufferMemory(buffer, &import_info, pAllocator, &buffer_memory,
                                         &buffer_device_address);
    if (result != VK_SUCCESS) {
      return result;
    }

    auto cleanup_buffer_memory = fbl::MakeAutoCall([this, buffer_memory, pAllocator] {
      dispatch_->FreeMemory(device_, buffer_memory, pAllocator);
    });

    // Create 4 byte auxiliary buffer.
    VkBuffer aux_buffer;
    result = CreateBuffer(4, nullptr, pAllocator, &aux_buffer);
    if (result != VK_SUCCESS) {
      return result;
    }

    auto cleanup_aux_buffer = fbl::MakeAutoCall([this, aux_buffer, pAllocator] {
      dispatch_->DestroyBuffer(device_, aux_buffer, pAllocator);
    });

    VkDeviceMemory aux_buffer_memory;
    VkDeviceAddress aux_buffer_device_address;
    result = AllocateAndBindBufferMemory(aux_buffer, nullptr, pAllocator, &aux_buffer_memory,
                                         &aux_buffer_device_address);
    if (result != VK_SUCCESS) {
      return result;
    }

    auto cleanup_aux_buffer_memory = fbl::MakeAutoCall([this, aux_buffer_memory, pAllocator] {
      dispatch_->FreeMemory(device_, aux_buffer_memory, pAllocator);
    });

    // Create image after successfully initializing extra state.
    VkBufferCollectionImageCreateInfoFUCHSIA collection_image_create_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
        .pNext = nullptr,
        .collection = collection,
        .index = 0,
    };
    VkImageCreateInfo image_create_info = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
        .pNext = &collection_image_create_info,
        .flags = pCreateInfo->flags & ~VK_IMAGE_CREATE_COMPACT_BIT_FUCHSIA,
        .imageType = pCreateInfo->imageType,
        .format = pCreateInfo->format,
        .extent = pCreateInfo->extent,
        .mipLevels = pCreateInfo->mipLevels,
        .arrayLayers = pCreateInfo->arrayLayers,
        .samples = pCreateInfo->samples,
        .tiling = pCreateInfo->tiling,
        .usage = pCreateInfo->usage,
        .sharingMode = pCreateInfo->sharingMode,
        .initialLayout = pCreateInfo->initialLayout,
    };
    result = dispatch_->CreateImage(device_, &image_create_info, pAllocator, pImage);
    if (result != VK_SUCCESS) {
      return result;
    }

    // Buffer collection can be closed as vulkan handle is enough.
    buffer_collection->Close();

    // Reset cleanup handlers.
    cleanup_collection.cancel();
    cleanup_buffer.cancel();
    cleanup_buffer_memory.cancel();
    cleanup_aux_buffer.cancel();
    cleanup_aux_buffer_memory.cancel();

    compact_images_.insert(
        {*pImage, CompactImage{
                      .collection = collection,
                      .buffer = Buffer{.buffer = buffer,
                                       .memory = buffer_memory,
                                       .device_address = buffer_device_address},
                      .aux = Buffer{.buffer = aux_buffer,
                                    .memory = aux_buffer_memory,
                                    .device_address = aux_buffer_device_address},
                      .allocation_size = buffer_collection_info.settings.buffer_settings.size_bytes,
                      .width_in_superblocks = width_in_superblocks,
                      .height_in_superblocks = height_in_superblocks,
                      .compact_memory_bound = false,
                  }});
    return result;
  }

  void DestroyImage(VkImage image, const VkAllocationCallbacks* pAllocator) {
    auto it = compact_images_.find(image);
    if (it != compact_images_.end()) {
      dispatch_->DestroyBuffer(device_, it->second.buffer.buffer, pAllocator);
      dispatch_->FreeMemory(device_, it->second.buffer.memory, pAllocator);
      dispatch_->DestroyBuffer(device_, it->second.aux.buffer, pAllocator);
      dispatch_->FreeMemory(device_, it->second.aux.memory, pAllocator);
      dispatch_->DestroyBufferCollectionFUCHSIA(device_, it->second.collection, pAllocator);
      compact_images_.erase(it);
    }
    dispatch_->DestroyImage(device_, image, pAllocator);
  }

  void GetImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2* pInfo,
                                   VkMemoryRequirements2* pMemoryRequirements) {
    dispatch_->GetImageMemoryRequirements2(device_, pInfo, pMemoryRequirements);

    auto it = compact_images_.find(pInfo->image);
    if (it != compact_images_.end()) {
      VkBufferCollectionPropertiesFUCHSIA properties;
      dispatch_->GetBufferCollectionPropertiesFUCHSIA(device_, it->second.collection, &properties);
      pMemoryRequirements->memoryRequirements.memoryTypeBits &= properties.memoryTypeBits;
      auto dedicated_requirements = static_cast<VkMemoryDedicatedRequirements*>(
          vk_find_struct(pMemoryRequirements, MEMORY_DEDICATED_REQUIREMENTS));
      // Add dedicated allocation preference as required for compact images.
      if (dedicated_requirements) {
        dedicated_requirements->prefersDedicatedAllocation = VK_TRUE;
      }
    }
  }

  VkResult AllocateMemory(const VkMemoryAllocateInfo* pAllocateInfo,
                          const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
    auto dedicated_alloc_info = static_cast<const VkMemoryDedicatedAllocateInfo*>(
        vk_find_struct_const(pAllocateInfo, MEMORY_DEDICATED_ALLOCATE_INFO));

    // Early out if not a dedicated allocation.
    if (!dedicated_alloc_info) {
      return dispatch_->AllocateMemory(device_, pAllocateInfo, pAllocator, pMemory);
    }

    // Early out if dedicated image is not compact.
    auto it = compact_images_.find(dedicated_alloc_info->image);
    if (it == compact_images_.end()) {
      return dispatch_->AllocateMemory(device_, pAllocateInfo, pAllocator, pMemory);
    }

    // Create memory allocation by importing the sysmem collection.
    VkImportMemoryBufferCollectionFUCHSIA import_info = {
        .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
        .pNext = nullptr,
        .collection = it->second.collection,
        .index = 0,
    };
    VkMemoryAllocateInfo allocation_info = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .pNext = &import_info,
        .allocationSize = pAllocateInfo->allocationSize,
        .memoryTypeIndex = pAllocateInfo->memoryTypeIndex,
    };
    VkResult result = dispatch_->AllocateMemory(device_, &allocation_info, pAllocator, pMemory);
    if (result != VK_SUCCESS) {
      return result;
    }

    dedicated_image_memory_.insert({*pMemory, dedicated_alloc_info->image});
    return VK_SUCCESS;
  }

  void FreeMemory(VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
    dispatch_->FreeMemory(device_, memory, pAllocator);
    dedicated_image_memory_.erase(memory);
  }

  VkResult BindImageMemory(VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
    VkResult result = dispatch_->BindImageMemory(device_, image, memory, memoryOffset);
    if (result != VK_SUCCESS) {
      return result;
    }

    // Activate packing for compact image if bound to buffer collection
    // backed memory.
    auto it = compact_images_.find(image);
    if (it != compact_images_.end()) {
      it->second.compact_memory_bound = IsDedicatedImageMemory(memory, image);
    }

    return VK_SUCCESS;
  }

  VkResult BindImageMemory2(uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) {
    VkResult result = dispatch_->BindImageMemory2(device_, bindInfoCount, pBindInfos);
    if (result != VK_SUCCESS) {
      return result;
    }

    for (uint32_t i = 0; i < bindInfoCount; ++i) {
      // Activate packing for compact image if bound to buffer collection
      // backed memory.
      auto it = compact_images_.find(pBindInfos[i].image);
      if (it != compact_images_.end()) {
        it->second.compact_memory_bound =
            IsDedicatedImageMemory(pBindInfos[i].memory, pBindInfos[i].image);
      }
    }

    return VK_SUCCESS;
  }

  VkResult BeginCommandBuffer(VkCommandBuffer commandBuffer,
                              const VkCommandBufferBeginInfo* pBeginInfo) {
    command_buffer_state_[commandBuffer] = CommandBufferState();
    return dispatch_->BeginCommandBuffer(commandBuffer, pBeginInfo);
  }

  VkResult EndCommandBuffer(VkCommandBuffer commandBuffer) {
    command_buffer_state_.erase(commandBuffer);
    return dispatch_->EndCommandBuffer(commandBuffer);
  }

  void CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
                       VkPipeline pipeline) {
    if (pipelineBindPoint == VK_PIPELINE_BIND_POINT_COMPUTE) {
      command_buffer_state_[commandBuffer].pipeline = pipeline;
    }
    dispatch_->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
  }

  void CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
                        VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
                        const void* pValues) {
    auto& state = command_buffer_state_[commandBuffer];
    state.pipeline_layout = layout;
    state.stage_flags |= stageFlags;
    state.push_constants.resize(offset + size, 0);
    memcpy(state.push_constants.data() + offset, pValues, size);
    dispatch_->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
  }

  void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
                          VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
                          uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
                          uint32_t bufferMemoryBarrierCount,
                          const VkBufferMemoryBarrier* pBufferMemoryBarriers,
                          uint32_t imageMemoryBarrierCount,
                          const VkImageMemoryBarrier* pImageMemoryBarriers) {
    std::vector<VkImageMemoryBarrier> pack_image_memory_barriers;
    std::vector<VkImageMemoryBarrier> unpack_image_memory_barriers;
    std::vector<VkImageMemoryBarrier> other_image_memory_barriers;

    // Iterate over image barriers and extract barriers that required packing.
    for (uint32_t i = 0; i < imageMemoryBarrierCount; i++) {
      bool oldLayoutIsCompact = IsCompactLayout(pImageMemoryBarriers[i].oldLayout);
      bool newLayoutIsCompact = IsCompactLayout(pImageMemoryBarriers[i].newLayout);
      if (oldLayoutIsCompact != newLayoutIsCompact &&
          IsCompactImage(pImageMemoryBarriers[i].image)) {
        if (newLayoutIsCompact) {
          pack_image_memory_barriers.push_back(pImageMemoryBarriers[i]);
        } else {
          unpack_image_memory_barriers.push_back(pImageMemoryBarriers[i]);
        }
      } else {
        other_image_memory_barriers.push_back(pImageMemoryBarriers[i]);
      }
    }

    // Forward barriers that don't require packing.
    dispatch_->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
                                  memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
                                  pBufferMemoryBarriers,
                                  static_cast<uint32_t>(other_image_memory_barriers.size()),
                                  other_image_memory_barriers.data());

    // Check if we have at least one image barrier that require packing.
    if (!pack_image_memory_barriers.empty() || !pack_image_memory_barriers.empty()) {
      auto& state = command_buffer_state_[commandBuffer];

      // Emit commands for image barriers that use pack shader.
      for (auto& barrier : pack_image_memory_barriers) {
        PackingPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, barrier,
                               pack_pipeline_);
      }

      // Emit commands for image barriers that use unpack shader.
      for (auto& barrier : unpack_image_memory_barriers) {
        PackingPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, barrier,
                               unpack_pipeline_);
      }

      // Restore compute bind point if needed.
      if (state.pipeline != VK_NULL_HANDLE) {
        dispatch_->CmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, state.pipeline);
      }

      // Restore push constants if needed.
      if (state.pipeline_layout != VK_NULL_HANDLE) {
        dispatch_->CmdPushConstants(commandBuffer, state.pipeline_layout, state.stage_flags, 0,
                                    static_cast<uint32_t>(state.push_constants.size()),
                                    state.push_constants.data());
      }
    }
  }

  void CmdWriteCompactImageMemorySize(VkCommandBuffer commandBuffer, VkImage image,
                                      VkImageLayout imageLayout, VkBuffer buffer,
                                      VkDeviceSize bufferOffset,
                                      const VkImageSubresourceLayers* subresourceLayers) {
    FX_CHECK(compact_images_.find(image) != compact_images_.end());
    auto& compact_image = compact_images_[image];

    // Compact image support is limited to single layer 2D images.
    FX_CHECK(subresourceLayers->aspectMask == VK_IMAGE_ASPECT_COLOR_BIT);
    FX_CHECK(subresourceLayers->mipLevel == 0);
    FX_CHECK(subresourceLayers->baseArrayLayer == 0);
    FX_CHECK(subresourceLayers->layerCount == 1);

    if (IsCompactLayout(imageLayout) && compact_image.compact_memory_bound) {
      VkBufferCopy region = {
          .srcOffset = 0,
          .dstOffset = bufferOffset,
          .size = 4,
      };
      dispatch_->CmdCopyBuffer(commandBuffer, compact_image.aux.buffer, buffer, 1, &region);
    } else {
      dispatch_->CmdFillBuffer(commandBuffer, buffer, bufferOffset, 4,
                               static_cast<uint32_t>(compact_image.allocation_size));
    }
  }

 private:
  struct Buffer {
    VkBuffer buffer = VK_NULL_HANDLE;
    VkDeviceMemory memory = VK_NULL_HANDLE;
    VkDeviceAddress device_address;
  };
  struct CompactImage {
    VkBufferCollectionFUCHSIA collection = VK_NULL_HANDLE;
    Buffer buffer;
    Buffer aux;
    VkDeviceSize allocation_size;
    uint32_t width_in_superblocks;
    uint32_t height_in_superblocks;
    bool compact_memory_bound;
  };
  struct CommandBufferState {
    VkPipeline pipeline = VK_NULL_HANDLE;
    VkPipelineLayout pipeline_layout = VK_NULL_HANDLE;
    VkShaderStageFlags stage_flags = 0;
    std::vector<uint8_t> push_constants;
  };

  static bool IsSupportedUsage(VkImageUsageFlags usage) {
    // TODO(reveman): Add VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
    // after implementing render pass support.
    constexpr VkImageUsageFlags kSupportedUsage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
                                                  VK_IMAGE_USAGE_TRANSFER_DST_BIT |
                                                  VK_IMAGE_USAGE_SAMPLED_BIT;
    return !(usage & ~kSupportedUsage);
  }

  static bool IsSupportedFormat(VkFormat format) {
    constexpr VkFormat kSupportedFormats[] = {
        VK_FORMAT_R8G8B8A8_UNORM,
        VK_FORMAT_R8G8B8A8_SRGB,
    };
    return std::find(std::begin(kSupportedFormats), std::end(kSupportedFormats), format) !=
           std::end(kSupportedFormats);
  }

  static bool IsCompactLayout(VkImageLayout layout) {
    constexpr VkImageLayout compact_layouts[] = {
        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
    };
    return std::find(std::begin(compact_layouts), std::end(compact_layouts), layout) !=
           std::end(compact_layouts);
  }

  static uint32_t RoundUp(uint32_t value, uint32_t multiple) {
    return ((value + (multiple - 1)) / multiple) * multiple;
  }

  bool IsCompactImage(VkImage image) const {
    auto it = compact_images_.find(image);
    return it != compact_images_.end() && it->second.compact_memory_bound;
  }

  bool IsDedicatedImageMemory(VkDeviceMemory memory, VkImage image) const {
    auto it = dedicated_image_memory_.find(memory);
    if (it == dedicated_image_memory_.end()) {
      return false;
    }
    return it->second == image;
  }

  VkResult CreatePipelineLayout(uint32_t push_constant_block_size,
                                const VkAllocationCallbacks* pAllocator, VkPipelineLayout* layout) {
    VkPushConstantRange push_constant_range = {
        .stageFlags = 0,
        .offset = 0,
        .size = push_constant_block_size,
    };
    VkPipelineLayoutCreateInfo pipeline_layout_info = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .setLayoutCount = 0,
        .pSetLayouts = nullptr,
        .pushConstantRangeCount = 1,
        .pPushConstantRanges = &push_constant_range,
    };
    return dispatch_->CreatePipelineLayout(device_, &pipeline_layout_info, pAllocator, layout);
  }

  VkResult CreateComputePipeline(const uint32_t* spv, unsigned int spv_len,
                                 VkPipelineLayout pipeline_layout,
                                 const VkAllocationCallbacks* pAllocator, VkPipeline* pipeline) {
    VkShaderModule module;
    VkShaderModuleCreateInfo module_info = {
        .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .codeSize = spv_len,
        .pCode = spv,
    };
    VkResult result = dispatch_->CreateShaderModule(device_, &module_info, pAllocator, &module);
    if (result != VK_SUCCESS) {
      return result;
    }
    VkPipelineShaderStageCreateInfo stage_info = {
        .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .stage = VK_SHADER_STAGE_COMPUTE_BIT,
        .module = module,
        .pName = "main",
        .pSpecializationInfo = nullptr,
    };
    VkComputePipelineCreateInfo pipeline_info = {
        .sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .stage = stage_info,
        .layout = pipeline_layout,
        .basePipelineHandle = VK_NULL_HANDLE,
        .basePipelineIndex = 0,
    };
    result = dispatch_->CreateComputePipelines(device_, VK_NULL_HANDLE, 1, &pipeline_info,
                                               pAllocator, pipeline);
    dispatch_->DestroyShaderModule(device_, module, pAllocator);
    return result;
  }

  VkResult CreateBuffer(uint32_t size, const void* pNext, const VkAllocationCallbacks* pAllocator,
                        VkBuffer* pBuffer) {
    VkBufferCreateInfo buffer_create_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .pNext = pNext,
        .flags = 0,
        .size = size,
        .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
    };
    return dispatch_->CreateBuffer(device_, &buffer_create_info, pAllocator, pBuffer);
  }

  VkResult AllocateAndBindBufferMemory(VkBuffer buffer, const void* pNext,
                                       const VkAllocationCallbacks* pAllocator,
                                       VkDeviceMemory* pMemory, VkDeviceAddress* pDeviceAddress) {
    VkMemoryRequirements memory_requirements;
    dispatch_->GetBufferMemoryRequirements(device_, buffer, &memory_requirements);

    uint32_t memory_type_index = __builtin_ctz(memory_requirements.memoryTypeBits);
    VkMemoryAllocateInfo allocate_info = {
        .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        .pNext = pNext,
        .allocationSize = memory_requirements.size,
        .memoryTypeIndex = memory_type_index,
    };
    VkResult result = dispatch_->AllocateMemory(device_, &allocate_info, pAllocator, pMemory);
    if (result != VK_SUCCESS) {
      return result;
    }

    auto cleanup_memory = fbl::MakeAutoCall(
        [this, pMemory, pAllocator] { dispatch_->FreeMemory(device_, *pMemory, pAllocator); });

    result = dispatch_->BindBufferMemory(device_, buffer, *pMemory, 0);
    if (result != VK_SUCCESS) {
      return result;
    }

    VkBufferDeviceAddressInfo device_address_info = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
        .pNext = nullptr,
        .buffer = buffer,
    };

    *pDeviceAddress = dispatch_->GetBufferDeviceAddress(device_, &device_address_info);

    cleanup_memory.cancel();
    return VK_SUCCESS;
  }

  void PackingPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
                              VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
                              const VkImageMemoryBarrier& barrier, VkPipeline pipeline) {
    auto& compact_image = compact_images_[barrier.image];

    // Image barrier to ensure that image memory is available to
    // compute shader.
    VkImageMemoryBarrier pre_image_barrier = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .pNext = nullptr,
        .srcAccessMask = barrier.srcAccessMask,
        .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
        .oldLayout = barrier.oldLayout,
        .newLayout = VK_IMAGE_LAYOUT_GENERAL,
        .image = barrier.image,
        .subresourceRange = barrier.subresourceRange,
    };
    dispatch_->CmdPipelineBarrier(commandBuffer, srcStageMask, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                                  dependencyFlags | VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0,
                                  nullptr, 1, &pre_image_barrier);

    uint32_t num_superblocks =
        compact_image.width_in_superblocks * compact_image.height_in_superblocks;
    uint32_t body_offset =
        RoundUp(num_superblocks * kAfbcBytesPerSuperblockHeader, kAfbcBodyAlignment);

    // Bind pipeline used for this layout transition.
    dispatch_->CmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);

    // Update push constants.
    PushConstantBlock push_constants = {
        .image_address = compact_image.buffer.device_address,
        .scratch_address = scratch_.device_address,
        .aux_address = compact_image.aux.device_address,
        .body_offset = body_offset,
        .block_count = num_superblocks,
    };
    dispatch_->CmdPushConstants(commandBuffer, pipeline_layout_, VK_SHADER_STAGE_COMPUTE_BIT, 0,
                                sizeof(push_constants), &push_constants);

    // Dispatch compute shader that performs the layout transition.
    // TODO(reveman): Use multiple workgroups for improved performance.
    dispatch_->CmdDispatch(commandBuffer, 1, 1, 1);

    // Image and buffer barriers to ensure that memory written by
    // compute shader is visible to destination stage.
    VkImageMemoryBarrier post_image_barrier = {
        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
        .pNext = nullptr,
        .srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
        .dstAccessMask = barrier.dstAccessMask,
        .oldLayout = VK_IMAGE_LAYOUT_GENERAL,
        .newLayout = barrier.newLayout,
        .image = barrier.image,
        .subresourceRange = barrier.subresourceRange,
    };
    VkBufferMemoryBarrier post_buffer_barrier = {
        .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
        .pNext = nullptr,
        .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
        .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
        .buffer = compact_image.aux.buffer,
        .offset = 0,
        .size = 4,
    };
    dispatch_->CmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, dstStageMask,
                                  dependencyFlags | VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 1,
                                  &post_buffer_barrier, 1, &post_image_barrier);
  }

  VkDevice device_;
  VkLayerDispatchTable* dispatch_;
  fuchsia::sysmem::AllocatorSyncPtr sysmem_allocator_;
  Buffer scratch_;
  VkPipelineLayout pipeline_layout_ = VK_NULL_HANDLE;
  VkPipeline pack_pipeline_ = VK_NULL_HANDLE;
  VkPipeline unpack_pipeline_ = VK_NULL_HANDLE;
  std::unordered_map<VkImage, CompactImage> compact_images_;
  std::unordered_map<VkDeviceMemory, VkImage> dedicated_image_memory_;
  std::unordered_map<VkCommandBuffer, CommandBufferState> command_buffer_state_;
};

struct LayerData {
  VkInstance instance;
  std::unique_ptr<VkLayerDispatchTable> device_dispatch_table;
  std::unique_ptr<VkLayerInstanceDispatchTable> instance_dispatch_table;
  std::unique_ptr<ImageCompactor> compactor;
};

small_unordered_map<void*, LayerData*, 2> layer_data_map;

VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
                                              const VkAllocationCallbacks* pAllocator,
                                              VkInstance* pInstance) {
  VkLayerInstanceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);

  FX_CHECK(chain_info->u.pLayerInfo);
  PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
      chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
  PFN_vkCreateInstance fpCreateInstance =
      reinterpret_cast<PFN_vkCreateInstance>(fpGetInstanceProcAddr(nullptr, "vkCreateInstance"));
  if (!fpCreateInstance) {
    return VK_ERROR_INITIALIZATION_FAILED;
  }

  // Advance the link info for the next element on the chain.
  chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;

  VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
  if (result != VK_SUCCESS) {
    return result;
  }

  LayerData* instance_layer_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
  instance_layer_data->instance = *pInstance;
  instance_layer_data->instance_dispatch_table = std::make_unique<VkLayerInstanceDispatchTable>();
  layer_init_instance_dispatch_table(*pInstance, instance_layer_data->instance_dispatch_table.get(),
                                     fpGetInstanceProcAddr);
  return result;
}

VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance,
                                           const VkAllocationCallbacks* pAllocator) {
  dispatch_key instance_key = get_dispatch_key(instance);
  LayerData* instance_layer_data = GetLayerDataPtr(instance_key, layer_data_map);

  instance_layer_data->instance_dispatch_table->DestroyInstance(instance, pAllocator);

  // Remove from |layer_data_map| and free LayerData struct.
  FreeLayerDataPtr(instance_key, layer_data_map);
}

VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
    VkPhysicalDevice gpu, VkFormat format, VkImageType type, VkImageTiling tiling,
    VkImageUsageFlags usage, VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties) {
  void* gpu_key = get_dispatch_key(gpu);
  LayerData* gpu_layer_data = GetLayerDataPtr(gpu_key, layer_data_map);

  if (flags & VK_IMAGE_CREATE_COMPACT_BIT_FUCHSIA) {
    VkPhysicalDeviceProperties gpu_properties;
    gpu_layer_data->instance_dispatch_table->GetPhysicalDeviceProperties(gpu, &gpu_properties);
    return ImageCompactor::GetImageFormatProperties(gpu_properties, format, type, tiling, usage,
                                                    flags, pImageFormatProperties);
  }

  return gpu_layer_data->instance_dispatch_table->GetPhysicalDeviceImageFormatProperties(
      gpu, format, type, tiling, usage, flags, pImageFormatProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice gpu, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties) {
  void* gpu_key = get_dispatch_key(gpu);
  LayerData* gpu_layer_data = GetLayerDataPtr(gpu_key, layer_data_map);

  if (pImageFormatInfo->flags & VK_IMAGE_CREATE_COMPACT_BIT_FUCHSIA) {
    VkPhysicalDeviceProperties gpu_properties;
    gpu_layer_data->instance_dispatch_table->GetPhysicalDeviceProperties(gpu, &gpu_properties);
    return ImageCompactor::GetImageFormatProperties(
        gpu_properties, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling,
        pImageFormatInfo->usage, pImageFormatInfo->flags,
        &pImageFormatProperties->imageFormatProperties);
  }
  return gpu_layer_data->instance_dispatch_table->GetPhysicalDeviceImageFormatProperties2(
      gpu, pImageFormatInfo, pImageFormatProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu,
                                            const VkDeviceCreateInfo* pCreateInfo,
                                            const VkAllocationCallbacks* pAllocator,
                                            VkDevice* pDevice) {
  void* gpu_key = get_dispatch_key(gpu);
  LayerData* gpu_layer_data = GetLayerDataPtr(gpu_key, layer_data_map);

  bool khr_buffer_device_address = false;
  bool fuchsia_buffer_collection_extension_available = false;
  uint32_t device_extension_count;
  VkResult result = gpu_layer_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(
      gpu, nullptr, &device_extension_count, nullptr);
  if (result == VK_SUCCESS && device_extension_count > 0) {
    std::vector<VkExtensionProperties> device_extensions(device_extension_count);
    result = gpu_layer_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(
        gpu, nullptr, &device_extension_count, device_extensions.data());
    if (result == VK_SUCCESS) {
      for (uint32_t i = 0; i < device_extension_count; i++) {
        if (!strcmp(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME,
                    device_extensions[i].extensionName)) {
          khr_buffer_device_address = true;
        }
        if (!strcmp(VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME,
                    device_extensions[i].extensionName)) {
          fuchsia_buffer_collection_extension_available = true;
        }
      }
    }
  }
  if (!khr_buffer_device_address) {
    fprintf(stderr, "Device extension not available: %s\n",
            VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME);
  }
  if (!fuchsia_buffer_collection_extension_available) {
    fprintf(stderr, "Device extension not available: %s\n",
            VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
  }
  if (!khr_buffer_device_address || !fuchsia_buffer_collection_extension_available) {
    return VK_ERROR_INITIALIZATION_FAILED;
  }

  VkPhysicalDeviceProperties gpu_properties;
  gpu_layer_data->instance_dispatch_table->GetPhysicalDeviceProperties(gpu, &gpu_properties);

  VkDeviceCreateInfo create_info = *pCreateInfo;
  std::vector<const char*> enabled_extensions;
  for (uint32_t i = 0; i < create_info.enabledExtensionCount; i++) {
    enabled_extensions.push_back(create_info.ppEnabledExtensionNames[i]);
  }
  enabled_extensions.push_back(VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME);
  enabled_extensions.push_back(VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME);
  create_info.enabledExtensionCount = static_cast<uint32_t>(enabled_extensions.size());
  create_info.ppEnabledExtensionNames = enabled_extensions.data();

  VkLayerDeviceCreateInfo* chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);

  FX_CHECK(chain_info->u.pLayerInfo);
  PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr =
      chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
  PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
  PFN_vkCreateDevice fpCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(
      fpGetInstanceProcAddr(gpu_layer_data->instance, "vkCreateDevice"));
  if (!fpCreateDevice) {
    return VK_ERROR_INITIALIZATION_FAILED;
  }

  // Advance the link info for the next element on the chain.
  chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;

  result = fpCreateDevice(gpu, &create_info, pAllocator, pDevice);
  if (result != VK_SUCCESS) {
    return result;
  }

  LayerData* device_layer_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);

  // Setup device dispatch table.
  device_layer_data->device_dispatch_table = std::make_unique<VkLayerDispatchTable>();
  device_layer_data->instance = gpu_layer_data->instance;
  layer_init_device_dispatch_table(*pDevice, device_layer_data->device_dispatch_table.get(),
                                   fpGetDeviceProcAddr);

  // Create image compactor if GPU is supported.
  if (ImageCompactor::IsSupportedGPU(gpu_properties.vendorID, gpu_properties.deviceID)) {
    device_layer_data->compactor =
        std::make_unique<ImageCompactor>(*pDevice, device_layer_data->device_dispatch_table.get());
    return device_layer_data->compactor->Init(fpGetDeviceProcAddr, pAllocator);
  }

  return VK_SUCCESS;
}

VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);

  device_layer_data->device_dispatch_table->DestroyDevice(device, pAllocator);

  // Remove from |layer_data_map| and free LayerData struct.
  FreeLayerDataPtr(device_key, layer_data_map);
}

VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
                                           const VkAllocationCallbacks* pAllocator,
                                           VkImage* pImage) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->CreateImage(pCreateInfo, pAllocator, pImage);
}

VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image,
                                        const VkAllocationCallbacks* pAllocator) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  compactor->DestroyImage(image, pAllocator);
}

VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(VkDevice device,
                                                       const VkImageMemoryRequirementsInfo2* pInfo,
                                                       VkMemoryRequirements2* pMemoryRequirements) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  compactor->GetImageMemoryRequirements2(pInfo, pMemoryRequirements);
}

VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device,
                                              const VkMemoryAllocateInfo* pAllocateInfo,
                                              const VkAllocationCallbacks* pAllocator,
                                              VkDeviceMemory* pMemory) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->AllocateMemory(pAllocateInfo, pAllocator, pMemory);
}

VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory,
                                      const VkAllocationCallbacks* pAllocator) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  compactor->FreeMemory(memory, pAllocator);
}

VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image,
                                               VkDeviceMemory memory, VkDeviceSize memoryOffset) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->BindImageMemory(image, memory, memoryOffset);
}

VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
                                                const VkBindImageMemoryInfo* pBindInfos) {
  dispatch_key device_key = get_dispatch_key(device);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->BindImageMemory2(bindInfoCount, pBindInfos);
}

VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer,
                                                  const VkCommandBufferBeginInfo* pBeginInfo) {
  dispatch_key device_key = get_dispatch_key(commandBuffer);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->BeginCommandBuffer(commandBuffer, pBeginInfo);
}

VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) {
  dispatch_key device_key = get_dispatch_key(commandBuffer);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->EndCommandBuffer(commandBuffer);
}

VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer,
                                           VkPipelineBindPoint pipelineBindPoint,
                                           VkPipeline pipeline) {
  dispatch_key device_key = get_dispatch_key(commandBuffer);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}

VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
                                            VkShaderStageFlags stageFlags, uint32_t offset,
                                            uint32_t size, const void* pValues) {
  dispatch_key device_key = get_dispatch_key(commandBuffer);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  return compactor->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
}

VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
    VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
    uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
    uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
  dispatch_key device_key = get_dispatch_key(commandBuffer);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);
  ImageCompactor* compactor = device_layer_data->compactor.get();

  FX_CHECK(compactor);

  compactor->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
                                memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
                                pBufferMemoryBarriers, imageMemoryBarrierCount,
                                pImageMemoryBarriers);
}

VKAPI_ATTR void VKAPI_CALL CmdWriteCompactImageMemorySizeFUCHSIA(
    VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, VkBuffer buffer,
    VkDeviceSize bufferOffset, const VkImageSubresourceLayers* subresourceLayers) {
  dispatch_key device_key = get_dispatch_key(commandBuffer);
  LayerData* device_layer_data = GetLayerDataPtr(device_key, layer_data_map);

  device_layer_data->compactor->CmdWriteCompactImageMemorySize(
      commandBuffer, image, imageLayout, buffer, bufferOffset, subresourceLayers);
}

VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(uint32_t* pCount,
                                                                VkLayerProperties* pProperties) {
  return util_GetLayerProperties(1, &compact_image_layer, pCount, pProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
                                                              uint32_t* pCount,
                                                              VkLayerProperties* pProperties) {
  return util_GetLayerProperties(1, &compact_image_layer, pCount, pProperties);
}

VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
    const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
  if (pLayerName && !strcmp(pLayerName, compact_image_layer.layerName)) {
    return util_GetExtensionProperties(0, nullptr, pCount, pProperties);
  }

  return VK_ERROR_LAYER_NOT_PRESENT;
}

VKAPI_ATTR VkResult VKAPI_CALL
EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName,
                                   uint32_t* pCount, VkExtensionProperties* pProperties) {
  if (pLayerName && !strcmp(pLayerName, compact_image_layer.layerName)) {
    return util_GetExtensionProperties(ARRAY_SIZE(device_extensions), device_extensions, pCount,
                                       pProperties);
  }

  FX_CHECK(physicalDevice);

  dispatch_key key = get_dispatch_key(physicalDevice);
  LayerData* data = GetLayerDataPtr(key, layer_data_map);

  return data->instance_dispatch_table->EnumerateDeviceExtensionProperties(physicalDevice, nullptr,
                                                                           pCount, pProperties);
}

VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName);
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance,
                                                             const char* funcName);

static inline PFN_vkVoidFunction layer_intercept_proc(const char* name) {
  if (!name || name[0] != 'v' || name[1] != 'k') {
    return nullptr;
  }
  name += 2;
  if (!strcmp(name, "GetDeviceProcAddr")) {
    return reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr);
  }
  if (!strcmp(name, "CreateInstance")) {
    return reinterpret_cast<PFN_vkVoidFunction>(CreateInstance);
  }
  if (!strcmp(name, "DestroyInstance")) {
    return reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance);
  }
  if (!strcmp(name, "CreateDevice")) {
    return reinterpret_cast<PFN_vkVoidFunction>(CreateDevice);
  }
  if (!strcmp(name, "DestroyDevice")) {
    return reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice);
  }
  if (!strcmp(name, "CreateImage")) {
    return reinterpret_cast<PFN_vkVoidFunction>(CreateImage);
  }
  if (!strcmp(name, "DestroyImage")) {
    return reinterpret_cast<PFN_vkVoidFunction>(DestroyImage);
  }
  if (!strcmp(name, "GetImageMemoryRequirements2")) {
    return reinterpret_cast<PFN_vkVoidFunction>(GetImageMemoryRequirements2);
  }
  if (!strcmp(name, "AllocateMemory")) {
    return reinterpret_cast<PFN_vkVoidFunction>(AllocateMemory);
  }
  if (!strcmp(name, "FreeMemory")) {
    return reinterpret_cast<PFN_vkVoidFunction>(FreeMemory);
  }
  if (!strcmp(name, "BindImageMemory")) {
    return reinterpret_cast<PFN_vkVoidFunction>(BindImageMemory);
  }
  if (!strcmp(name, "BindImageMemory2")) {
    return reinterpret_cast<PFN_vkVoidFunction>(BindImageMemory2);
  }
  if (!strcmp(name, "BeginCommandBuffer")) {
    return reinterpret_cast<PFN_vkVoidFunction>(BeginCommandBuffer);
  }
  if (!strcmp(name, "EndCommandBuffer")) {
    return reinterpret_cast<PFN_vkVoidFunction>(EndCommandBuffer);
  }
  if (!strcmp(name, "CmdPipelineBarrier")) {
    return reinterpret_cast<PFN_vkVoidFunction>(CmdPipelineBarrier);
  }
  if (!strcmp(name, "CmdWriteCompactImageMemorySizeFUCHSIA")) {
    return reinterpret_cast<PFN_vkVoidFunction>(CmdWriteCompactImageMemorySizeFUCHSIA);
  }
  if (!strcmp("EnumerateDeviceExtensionProperties", name)) {
    return reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties);
  }
  if (!strcmp("EnumerateInstanceExtensionProperties", name)) {
    return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties);
  }
  if (!strcmp("EnumerateDeviceLayerProperties", name)) {
    return reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties);
  }
  if (!strcmp("EnumerateInstanceLayerProperties", name)) {
    return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties);
  }
  return nullptr;
}

static inline PFN_vkVoidFunction layer_intercept_instance_proc(const char* name) {
  if (!name || name[0] != 'v' || name[1] != 'k') {
    return nullptr;
  }
  name += 2;
  if (!strcmp(name, "GetInstanceProcAddr")) {
    return reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr);
  }
  if (!strcmp(name, "CreateInstance")) {
    return reinterpret_cast<PFN_vkVoidFunction>(CreateInstance);
  }
  if (!strcmp(name, "DestroyInstance")) {
    return reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance);
  }
  if (!strcmp("GetPhysicalDeviceImageFormatProperties", name)) {
    return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceImageFormatProperties);
  }
  if (!strcmp("GetPhysicalDeviceImageFormatProperties2", name)) {
    return reinterpret_cast<PFN_vkVoidFunction>(GetPhysicalDeviceImageFormatProperties2);
  }
  return nullptr;
}

VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char* funcName) {
  PFN_vkVoidFunction addr;
  LayerData* data;

  FX_CHECK(device);

  data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
  if (data->compactor) {
    addr = layer_intercept_proc(funcName);
    if (addr) {
      return addr;
    }
  }

  VkLayerDispatchTable* pTable = data->device_dispatch_table.get();

  if (!pTable->GetDeviceProcAddr) {
    return nullptr;
  }
  return pTable->GetDeviceProcAddr(device, funcName);
}

VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance,
                                                             const char* funcName) {
  PFN_vkVoidFunction addr;
  LayerData* data;

  addr = layer_intercept_instance_proc(funcName);
  if (!addr) {
    addr = layer_intercept_proc(funcName);
  }
  if (addr) {
    return addr;
  }
  if (!instance) {
    return nullptr;
  }

  data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);

  VkLayerInstanceDispatchTable* pTable = data->instance_dispatch_table.get();
  if (!pTable->GetInstanceProcAddr) {
    return nullptr;
  }
  addr = pTable->GetInstanceProcAddr(instance, funcName);
  return addr;
}

}  // namespace compact_image

VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
    const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
  return compact_image::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
}

VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkEnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
  return compact_image::EnumerateInstanceLayerProperties(pCount, pProperties);
}

VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
    VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) {
  FX_CHECK(physicalDevice == VK_NULL_HANDLE);
  return compact_image::EnumerateDeviceLayerProperties(VK_NULL_HANDLE, pCount, pProperties);
}

VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName,
                                     uint32_t* pCount, VkExtensionProperties* pProperties) {
  FX_CHECK(physicalDevice == VK_NULL_HANDLE);
  return compact_image::EnumerateDeviceExtensionProperties(VK_NULL_HANDLE, pLayerName, pCount,
                                                           pProperties);
}

VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev,
                                                                             const char* funcName) {
  return compact_image::GetDeviceProcAddr(dev, funcName);
}

VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
vkGetInstanceProcAddr(VkInstance instance, const char* funcName) {
  return compact_image::GetInstanceProcAddr(instance, funcName);
}