diff --git a/guest/vulkan_enc/Android.bp b/guest/vulkan_enc/Android.bp
index 09cd26e..031ebad 100644
--- a/guest/vulkan_enc/Android.bp
+++ b/guest/vulkan_enc/Android.bp
@@ -19,46 +19,69 @@
     default_applicable_licenses: ["hardware_google_gfxstream_license"],
 }
 
+genrule {
+    name: "gfxstream_vk_entrypoints_header",
+    srcs: [":libmesa_vulkan_xml"],
+    out: ["gfxstream_vk_entrypoints.h"],
+    tools: ["vk_entrypoints_gen"],
+    cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+        "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+        "$(location gfxstream_vk_entrypoints.h) --out-c " +
+        "$(genDir)/placeholder.c --prefix gfxstream_vk --beta false",
+}
 
-cc_defaults {
-    name: "libgfxstream_guest_vulkan_encoder_defaults",
+genrule {
+    name: "gfxstream_vk_entrypoints_impl",
+    srcs: [":libmesa_vulkan_xml"],
+    out: ["gfxstream_vk_entrypoints.c"],
+    tools: ["vk_entrypoints_gen"],
+    cmd: "python3 $(location vk_entrypoints_gen) --xml " +
+        "$(location :libmesa_vulkan_xml) --proto --weak --out-h " +
+        "$(genDir)/gfxstream_vk_entrypoints.h --out-c " +
+        "$(location gfxstream_vk_entrypoints.c) --prefix gfxstream_vk " +
+        "--beta false",
+}
+
+cc_library_static {
+    name: "libgfxstream_guest_vulkan_entrypoints",
     host_supported: true,
     vendor: true,
     defaults: [
-        "libgfxstream_guest_cc_defaults",
+        "mesa_common_defaults_gfxstream",
     ],
     header_libs: [
-        "gfxstream_vulkan_headers",
-        "libgfxstream_guest_graphics_headers",
-        "libgfxstream_guest_iostream",
-        "libnativewindow_headers",
-    ],
-    shared_libs: [
-        "libandroidemu",
-        "libcutils",
-        "liblog",
-        "libOpenglCodecCommon",
-        "lib_renderControl_enc",
+        "mesa_common_headers_gfxstream",
     ],
     static_libs: [
-        "libarect",
-        "libdrm",
-        "libGoldfishAddressSpace",
-        "libgfxstream_guest_gralloc",
+        "libmesa_vulkan_util_gfxstream",
     ],
-    cflags: [
-        "-DLOG_TAG=\"goldfish_vulkan\"",
-        "-DVIRTIO_GPU",
-        "-DVK_ANDROID_native_buffer",
-        "-DVK_EXT_device_memory_report",
-        "-DVK_GOOGLE_gfxstream",
-        "-DVK_NO_PROTOTYPES",
-        "-DVK_USE_PLATFORM_ANDROID_KHR",
-        "-fstrict-aliasing",
-        "-Werror",
-        "-Wno-missing-field-initializers",
-        "-Wno-unused-parameter",
+    shared_libs: [
+        "libcutils",
     ],
+    generated_headers: [
+        "gfxstream_vk_entrypoints_header",
+    ],
+    generated_sources: [
+        "gfxstream_vk_entrypoints_impl",
+    ],
+    ldflags: [
+        "-Wl,-Bsymbolic",
+        "-Wl,--gc-sections",
+    ],
+    export_generated_headers: [
+        "gfxstream_vk_entrypoints_header",
+    ],
+}
+
+cc_library_headers {
+    name: "vulkan_enc_headers",
+    export_include_dirs: ["."],
+    host_supported: true,
+    vendor_available: true,
+}
+
+filegroup {
+    name: "vulkan_enc_impl",
     srcs: [
         "AndroidHardwareBuffer.cpp",
         "CommandBufferStagingStream.cpp",
@@ -77,10 +100,76 @@
         "VkEncoder.cpp",
         "VulkanHandleMapping.cpp",
         "VulkanStreamGuest.cpp",
+        "gfxstream_vk_private.cpp",
+    ],
+}
+
+cc_defaults {
+    name: "libgfxstream_guest_vulkan_encoder_defaults",
+    host_supported: true,
+    vendor: true,
+    defaults: [
+        "libgfxstream_guest_cc_defaults",
+    ],
+    header_libs: [
+        "gfxstream_vulkan_headers",
+        "libgfxstream_guest_iostream",
+        "libnativewindow_headers",
+        "mesa_common_headers_gfxstream",
+    ],
+    generated_headers: [
+        "vk_cmd_queue_header",
+        "vk_physical_device_features_header",
+        "vk_physical_device_properties_header",
+        "u_format_pack_header",
+    ],
+    shared_libs: [
+        "libcutils",
+        "liblog",
+        "libOpenglCodecCommon",
+    ],
+    static_libs: [
+        "libarect",
+        "libdrm",
+        "libandroidemu_static",
+        "libGoldfishAddressSpace",
+        "libgfxstream_guest_gralloc",
+        "libmesa_vulkan_util_gfxstream",
+        "libmesa_vulkan_runtime_gfxstream",
+        "libgfxstream_guest_vulkan_entrypoints",
+        "libmesa_util_gfxstream",
+        "libmesa_util_format_gfxstream",
+        "libmesa_util_c11_gfxstream",
+    ],
+    cflags: [
+        "-DLOG_TAG=\"goldfish_vulkan\"",
+        "-DVIRTIO_GPU",
+        "-DVK_ANDROID_native_buffer",
+        "-DVK_EXT_device_memory_report",
+        "-DVK_GOOGLE_gfxstream",
+        "-DVK_NO_PROTOTYPES",
+        "-DVK_USE_PLATFORM_ANDROID_KHR",
+        "-fstrict-aliasing",
+        "-Werror",
+        "-Wno-missing-field-initializers",
+        "-Wno-unused-parameter",
+        "-DHAVE_PTHREAD=1",
+        "-DHAVE_TIMESPEC_GET",
+        "-DHAVE_STRUCT_TIMESPEC",
+    ],
+    srcs: [
+        ":vulkan_enc_impl",
     ],
     export_include_dirs: [
         ".",
     ],
+    ldflags: [
+        // Mesa always adds Bsymbolic when available (see 'ld_args_bsymbolic' in Meson build). Duplicate that
+        // behavior here. '--gc-sections' has stronger justification: this lets drivers drop
+        // shared code unused by that specific driver (particularly relevant for Vulkan drivers).
+        "-Wl,-Bsymbolic",
+        "-Wl,--gc-sections",
+    ],
     target: {
         android: {
             shared_libs: [
@@ -89,11 +178,11 @@
             header_libs: [
                 "hwvulkan_headers",
             ],
-        }
-    }
+        },
+    },
 }
 
-cc_library_shared {
+cc_library_static {
     name: "libvulkan_enc",
     defaults: [
         "libgfxstream_guest_vulkan_encoder_defaults",
@@ -103,16 +192,14 @@
     ],
 }
 
-cc_library_shared {
+cc_library_static {
     name: "libgfxstream_guest_vulkan_encoder_with_host",
     defaults: [
         "libgfxstream_guest_vulkan_encoder_defaults",
     ],
     shared_libs: [
-        "libgfxstream_backend",
-    ],
-    static_libs: [
         "libplatform_rutabaga",
+        "libgfxstream_backend",
     ],
     target: {
         host: {
diff --git a/guest/vulkan_enc/AndroidHardwareBuffer.cpp b/guest/vulkan_enc/AndroidHardwareBuffer.cpp
index 3f0c34a..eac0caf 100644
--- a/guest/vulkan_enc/AndroidHardwareBuffer.cpp
+++ b/guest/vulkan_enc/AndroidHardwareBuffer.cpp
@@ -21,11 +21,11 @@
 #endif
 #endif
 
-#include "../OpenglSystemCommon/HostConnection.h"
+#include <assert.h>
 
+#include "../OpenglSystemCommon/HostConnection.h"
 #include "vk_format_info.h"
 #include "vk_util.h"
-#include <assert.h>
 
 namespace gfxstream {
 namespace vk {
@@ -34,36 +34,28 @@
 /* Construct ahw usage mask from image usage bits, see
  * 'AHardwareBuffer Usage Equivalence' in Vulkan spec.
  */
-uint64_t
-getAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags vk_create,
-                                 const VkImageUsageFlags vk_usage)
-{
-   uint64_t ahw_usage = 0;
+uint64_t getAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags vk_create,
+                                                  const VkImageUsageFlags vk_usage) {
+    uint64_t ahw_usage = 0;
 
-   if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT)
-      ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+    if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT) ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
 
-   if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
-      ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+    if (vk_usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)
+        ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
 
-   if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
-      ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
+    if (vk_usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
+        ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
 
-   if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
-      ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
+    if (vk_create & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
+        ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
 
-   if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT)
-      ahw_usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
+    if (vk_create & VK_IMAGE_CREATE_PROTECTED_BIT)
+        ahw_usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
 
-   /* No usage bits set - set at least one GPU usage. */
-   if (ahw_usage == 0)
-      ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
+    /* No usage bits set - set at least one GPU usage. */
+    if (ahw_usage == 0) ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
 
-   return ahw_usage;
-}
-
-void updateMemoryTypeBits(uint32_t* memoryTypeBits, uint32_t colorBufferMemoryIndex) {
-   *memoryTypeBits = 1u << colorBufferMemoryIndex;
+    return ahw_usage;
 }
 
 VkResult getAndroidHardwareBufferPropertiesANDROID(
@@ -74,45 +66,45 @@
 
     const auto format = grallocHelper->getFormat(buffer);
     if (ahbFormatProps) {
-        switch(format) {
+        switch (format) {
             case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
+                break;
             case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_R8G8B8A8_UNORM;
+                break;
             case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_R8G8B8_UNORM;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_R8G8B8_UNORM;
+                break;
             case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_R5G6B5_UNORM_PACK16;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_R5G6B5_UNORM_PACK16;
+                break;
             case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
-                  ahbFormatProps->format = VK_FORMAT_R16G16B16A16_SFLOAT;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_R16G16B16A16_SFLOAT;
+                break;
             case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+                break;
             case AHARDWAREBUFFER_FORMAT_D16_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_D16_UNORM;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_D16_UNORM;
+                break;
             case AHARDWAREBUFFER_FORMAT_D24_UNORM:
-                  ahbFormatProps->format = VK_FORMAT_X8_D24_UNORM_PACK32;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_X8_D24_UNORM_PACK32;
+                break;
             case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
-                  ahbFormatProps->format = VK_FORMAT_D24_UNORM_S8_UINT;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_D24_UNORM_S8_UINT;
+                break;
             case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
-                  ahbFormatProps->format = VK_FORMAT_D32_SFLOAT;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_D32_SFLOAT;
+                break;
             case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
-                  ahbFormatProps->format = VK_FORMAT_D32_SFLOAT_S8_UINT;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_D32_SFLOAT_S8_UINT;
+                break;
             case AHARDWAREBUFFER_FORMAT_S8_UINT:
-                  ahbFormatProps->format = VK_FORMAT_S8_UINT;
-                  break;
+                ahbFormatProps->format = VK_FORMAT_S8_UINT;
+                break;
             default:
-                  ahbFormatProps->format = VK_FORMAT_UNDEFINED;
+                ahbFormatProps->format = VK_FORMAT_UNDEFINED;
         }
         ahbFormatProps->externalFormat = format;
 
@@ -128,10 +120,8 @@
         // VK_FORMAT_FEATURE_TRANSFER_DST_BIT
         // VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
         ahbFormatProps->formatFeatures =
-            VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
-            VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT |
-            VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
-            VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
+            VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT |
+            VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
             VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
 
         // "Implementations may not always be able to determine the color model,
@@ -166,7 +156,8 @@
                 //  * U (CB) comes from the B-channel (after swizzle)
                 //  * V (CR) comes from the R-channel (after swizzle)
                 //
-                // See https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#textures-sampler-YCbCr-conversion
+                // See
+                // https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#textures-sampler-YCbCr-conversion
                 //
                 // To match the above, the guest needs to swizzle such that:
                 //
@@ -204,10 +195,9 @@
 #endif
 #endif
 
-        ahbFormatProps->suggestedYcbcrModel =
-            android_format_is_yuv(format) ?
-                VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 :
-                VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+        ahbFormatProps->suggestedYcbcrModel = android_format_is_yuv(format)
+                                                  ? VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601
+                                                  : VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
         ahbFormatProps->suggestedYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
 
         ahbFormatProps->suggestedXChromaOffset = VK_CHROMA_LOCATION_MIDPOINT;
@@ -281,26 +271,24 @@
 
     /* If caller passed dedicated information. */
     if (hasDedicatedImage) {
-       w = imageExtent.width;
-       h = imageExtent.height;
-       layers = imageLayers;
-       format = android_format_from_vk(imageFormat);
-       usage = getAndroidHardwareBufferUsageFromVkUsage(imageCreateFlags, imageUsage);
+        w = imageExtent.width;
+        h = imageExtent.height;
+        layers = imageLayers;
+        format = android_format_from_vk(imageFormat);
+        usage = getAndroidHardwareBufferUsageFromVkUsage(imageCreateFlags, imageUsage);
     } else if (hasDedicatedBuffer) {
-       w = bufferSize;
-       format = AHARDWAREBUFFER_FORMAT_BLOB;
-       usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-               AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-               AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
+        w = bufferSize;
+        format = AHARDWAREBUFFER_FORMAT_BLOB;
+        usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
     } else {
-       w = allocationInfoAllocSize;
-       format = AHARDWAREBUFFER_FORMAT_BLOB;
-       usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
-               AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
-               AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
+        w = allocationInfoAllocSize;
+        format = AHARDWAREBUFFER_FORMAT_BLOB;
+        usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN | AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER;
     }
 
-    struct AHardwareBuffer *ahb = NULL;
+    struct AHardwareBuffer* ahb = NULL;
 
     if (gralloc->allocate(w, h, format, usage, &ahb) != 0) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
diff --git a/guest/vulkan_enc/AndroidHardwareBuffer.h b/guest/vulkan_enc/AndroidHardwareBuffer.h
index b4085b6..0389f09 100644
--- a/guest/vulkan_enc/AndroidHardwareBuffer.h
+++ b/guest/vulkan_enc/AndroidHardwareBuffer.h
@@ -25,10 +25,8 @@
 namespace gfxstream {
 namespace vk {
 
-uint64_t
-getAndroidHardwareBufferUsageFromVkUsage(
-    const VkImageCreateFlags vk_create,
-    const VkImageUsageFlags vk_usage);
+uint64_t getAndroidHardwareBufferUsageFromVkUsage(const VkImageCreateFlags vk_create,
+                                                  const VkImageUsageFlags vk_usage);
 
 void updateMemoryTypeBits(uint32_t* memoryTypeBits, uint32_t colorBufferMemoryIndex);
 
diff --git a/guest/vulkan_enc/CommandBufferStagingStream.cpp b/guest/vulkan_enc/CommandBufferStagingStream.cpp
index 1f57387..63db2fa 100644
--- a/guest/vulkan_enc/CommandBufferStagingStream.cpp
+++ b/guest/vulkan_enc/CommandBufferStagingStream.cpp
@@ -1,18 +1,18 @@
 /*
-* Copyright (C) 2021 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "CommandBufferStagingStream.h"
 
 #if PLATFORM_SDK_VERSION < 26
@@ -204,37 +204,33 @@
     return (void*)(getDataPtr() + m_writePos);
 }
 
-int CommandBufferStagingStream::commitBuffer(size_t size)
-{
+int CommandBufferStagingStream::commitBuffer(size_t size) {
     m_writePos += size;
     return 0;
 }
 
-const unsigned char *CommandBufferStagingStream::readFully(void*, size_t) {
+const unsigned char* CommandBufferStagingStream::readFully(void*, size_t) {
     // Not supported
     ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
     abort();
     return nullptr;
 }
 
-const unsigned char *CommandBufferStagingStream::read(void*, size_t*) {
+const unsigned char* CommandBufferStagingStream::read(void*, size_t*) {
     // Not supported
     ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
     abort();
     return nullptr;
 }
 
-int CommandBufferStagingStream::writeFully(const void*, size_t)
-{
+int CommandBufferStagingStream::writeFully(const void*, size_t) {
     // Not supported
     ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
     abort();
     return 0;
 }
 
-const unsigned char *CommandBufferStagingStream::commitBufferAndReadFully(
-    size_t, void *, size_t) {
-
+const unsigned char* CommandBufferStagingStream::commitBufferAndReadFully(size_t, void*, size_t) {
     // Not supported
     ALOGE("CommandBufferStagingStream::%s: Fatal: not supported\n", __func__);
     abort();
diff --git a/guest/vulkan_enc/CommandBufferStagingStream.h b/guest/vulkan_enc/CommandBufferStagingStream.h
index 8e754b7..45af8dc 100644
--- a/guest/vulkan_enc/CommandBufferStagingStream.h
+++ b/guest/vulkan_enc/CommandBufferStagingStream.h
@@ -1,18 +1,18 @@
 /*
-* Copyright (C) 2021 The Android Open Source Project
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-* http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
+ * Copyright (C) 2021 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #ifndef __COMMAND_BUFFER_STAGING_STREAM_H
 #define __COMMAND_BUFFER_STAGING_STREAM_H
 
@@ -26,91 +26,91 @@
 namespace vk {
 
 class CommandBufferStagingStream : public gfxstream::guest::IOStream {
-public:
- // host will write kSyncDataReadComplete to the sync bytes to indicate memory is no longer being
- // used by host. This is only used with custom allocators. The sync bytes are used to ensure that,
- // during reallocations the guest does not free memory being read by the host. The guest ensures
- // that the sync bytes are marked as read complete before releasing the memory.
- static constexpr size_t kSyncDataSize = 8;
- // indicates read is complete
- static constexpr uint32_t kSyncDataReadComplete = 0X0;
- // indicates read is pending
- static constexpr uint32_t kSyncDataReadPending = 0X1;
+   public:
+    // host will write kSyncDataReadComplete to the sync bytes to indicate memory is no longer being
+    // used by host. This is only used with custom allocators. The sync bytes are used to ensure
+    // that, during reallocations the guest does not free memory being read by the host. The guest
+    // ensures that the sync bytes are marked as read complete before releasing the memory.
+    static constexpr size_t kSyncDataSize = 8;
+    // indicates read is complete
+    static constexpr uint32_t kSyncDataReadComplete = 0X0;
+    // indicates read is pending
+    static constexpr uint32_t kSyncDataReadPending = 0X1;
 
- // \struct backing memory structure
- struct Memory {
-     VkDeviceMemory deviceMemory =
-         VK_NULL_HANDLE;                   // device memory associated with allocated memory
-     void* ptr = nullptr;                  // pointer to allocated memory
-     bool operator==(const Memory& rhs) const {
-         return (deviceMemory == rhs.deviceMemory) && (ptr == rhs.ptr);
-     }
- };
+    // \struct backing memory structure
+    struct Memory {
+        VkDeviceMemory deviceMemory =
+            VK_NULL_HANDLE;   // device memory associated with allocated memory
+        void* ptr = nullptr;  // pointer to allocated memory
+        bool operator==(const Memory& rhs) const {
+            return (deviceMemory == rhs.deviceMemory) && (ptr == rhs.ptr);
+        }
+    };
 
- // allocator
- // param size to allocate
- // return allocated memory
- using Alloc = std::function<Memory(size_t)>;
- // free function
- // param memory to free
- using Free = std::function<void(const Memory&)>;
- // constructor
- // \param allocFn is the allocation function provided.
- // \param freeFn is the free function provided
- explicit CommandBufferStagingStream(const Alloc& allocFn, const Free& freeFn);
- // constructor
- explicit CommandBufferStagingStream();
- ~CommandBufferStagingStream();
+    // allocator
+    // param size to allocate
+    // return allocated memory
+    using Alloc = std::function<Memory(size_t)>;
+    // free function
+    // param memory to free
+    using Free = std::function<void(const Memory&)>;
+    // constructor
+    // \param allocFn is the allocation function provided.
+    // \param freeFn is the free function provided
+    explicit CommandBufferStagingStream(const Alloc& allocFn, const Free& freeFn);
+    // constructor
+    explicit CommandBufferStagingStream();
+    ~CommandBufferStagingStream();
 
- virtual size_t idealAllocSize(size_t len);
- virtual void* allocBuffer(size_t minSize);
- virtual int commitBuffer(size_t size);
- virtual const unsigned char* readFully(void* buf, size_t len);
- virtual const unsigned char* read(void* buf, size_t* inout_len);
- virtual int writeFully(const void* buf, size_t len);
- virtual const unsigned char* commitBufferAndReadFully(size_t size, void* buf, size_t len);
+    virtual size_t idealAllocSize(size_t len);
+    virtual void* allocBuffer(size_t minSize);
+    virtual int commitBuffer(size_t size);
+    virtual const unsigned char* readFully(void* buf, size_t len);
+    virtual const unsigned char* read(void* buf, size_t* inout_len);
+    virtual int writeFully(const void* buf, size_t len);
+    virtual const unsigned char* commitBufferAndReadFully(size_t size, void* buf, size_t len);
 
- void getWritten(unsigned char** bufOut, size_t* sizeOut);
- void reset();
+    void getWritten(unsigned char** bufOut, size_t* sizeOut);
+    void reset();
 
- // marks the command buffer stream as flushing. The owner of CommandBufferStagingStream
- // should call markFlushing after finishing writing to the stream.
- // This will mark the sync data to kSyncDataReadPending. This is only applicable when
- // using custom allocators. markFlushing will be a no-op if called
- // when not using custom allocators
- void markFlushing();
+    // marks the command buffer stream as flushing. The owner of CommandBufferStagingStream
+    // should call markFlushing after finishing writing to the stream.
+    // This will mark the sync data to kSyncDataReadPending. This is only applicable when
+    // using custom allocators. markFlushing will be a no-op if called
+    // when not using custom allocators
+    void markFlushing();
 
- // gets the device memory associated with the stream. This is VK_NULL_HANDLE for default allocation
- // \return device memory
- VkDeviceMemory getDeviceMemory();
+    // gets the device memory associated with the stream. This is VK_NULL_HANDLE for default
+    // allocation \return device memory
+    VkDeviceMemory getDeviceMemory();
 
-private:
- // underlying memory for data
- Memory m_mem;
- // size of portion of memory available for data.
- // for custom allocation, this size excludes size of sync data.
- size_t m_size;
- // current write position in data buffer
- uint32_t m_writePos;
+   private:
+    // underlying memory for data
+    Memory m_mem;
+    // size of portion of memory available for data.
+    // for custom allocation, this size excludes size of sync data.
+    size_t m_size;
+    // current write position in data buffer
+    uint32_t m_writePos;
 
- // alloc function
- Alloc m_alloc;
- // free function
- Free m_free;
+    // alloc function
+    Alloc m_alloc;
+    // free function
+    Free m_free;
 
- // realloc function
- // \param size of memory to be allocated
- // \ param reference size to update with actual size allocated. This size can be < requested size
- // for custom allocation to account for sync data
- using Realloc = std::function<Memory(const Memory&, size_t)>;
- Realloc m_realloc;
+    // realloc function
+    // \param size of memory to be allocated
+    // \ param reference size to update with actual size allocated. This size can be < requested
+    // size for custom allocation to account for sync data
+    using Realloc = std::function<Memory(const Memory&, size_t)>;
+    Realloc m_realloc;
 
- // flag tracking use of custom allocation/free
- bool m_usingCustomAlloc = false;
+    // flag tracking use of custom allocation/free
+    bool m_usingCustomAlloc = false;
 
- // adjusted memory location to point to start of data after accounting for metadata
- // \return pointer to data start
- unsigned char* getDataPtr();
+    // adjusted memory location to point to start of data after accounting for metadata
+    // \return pointer to data start
+    unsigned char* getDataPtr();
 };
 
 }  // namespace vk
diff --git a/guest/vulkan_enc/DescriptorSetVirtualization.cpp b/guest/vulkan_enc/DescriptorSetVirtualization.cpp
index fa0cb78..d2389a4 100644
--- a/guest/vulkan_enc/DescriptorSetVirtualization.cpp
+++ b/guest/vulkan_enc/DescriptorSetVirtualization.cpp
@@ -13,6 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 #include "DescriptorSetVirtualization.h"
+
 #include "Resources.h"
 
 namespace gfxstream {
@@ -27,7 +28,8 @@
     set->pendingWriteArrayRanges.clear();
 }
 
-void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings, DescriptorWriteTable& table) {
+void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings,
+                              DescriptorWriteTable& table) {
     uint32_t highestBindingNumber = 0;
 
     for (uint32_t i = 0; i < layoutBindings.size(); ++i) {
@@ -39,8 +41,7 @@
     std::vector<uint32_t> countsEachBinding(highestBindingNumber + 1, 0);
 
     for (uint32_t i = 0; i < layoutBindings.size(); ++i) {
-        countsEachBinding[layoutBindings[i].binding] =
-            layoutBindings[i].descriptorCount;
+        countsEachBinding[layoutBindings[i].binding] = layoutBindings[i].descriptorCount;
     }
 
     table.resize(countsEachBinding.size());
@@ -55,8 +56,8 @@
     }
 }
 
-static void initializeReifiedDescriptorSet(VkDescriptorPool pool, VkDescriptorSetLayout setLayout, ReifiedDescriptorSet* set) {
-
+static void initializeReifiedDescriptorSet(VkDescriptorPool pool, VkDescriptorSetLayout setLayout,
+                                           ReifiedDescriptorSet* set) {
     set->pendingWriteArrayRanges.clear();
 
     const auto& layoutInfo = *(as_goldfish_VkDescriptorSetLayout(setLayout)->layoutInfo);
@@ -73,8 +74,7 @@
         set->bindingIsImmutableSampler[bindingIndex] =
             binding.descriptorCount > 0 &&
             (binding.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER ||
-             binding.descriptorType ==
-             VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) &&
+             binding.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) &&
             binding.pImmutableSamplers;
     }
 
@@ -185,7 +185,8 @@
     }
 }
 
-void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src, ReifiedDescriptorSet* dst) {
+void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src,
+                              ReifiedDescriptorSet* dst) {
     const DescriptorWriteTable& srcTable = src->allWrites;
     DescriptorWriteTable& dstTable = dst->allWrites;
 
@@ -214,14 +215,10 @@
     }
 }
 
-void doEmulatedDescriptorImageInfoWriteFromTemplate(
-    VkDescriptorType descType,
-    uint32_t binding,
-    uint32_t dstArrayElement,
-    uint32_t count,
-    const VkDescriptorImageInfo* imageInfos,
-    ReifiedDescriptorSet* set) {
-
+void doEmulatedDescriptorImageInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+                                                    uint32_t dstArrayElement, uint32_t count,
+                                                    const VkDescriptorImageInfo* imageInfos,
+                                                    ReifiedDescriptorSet* set) {
     DescriptorWriteTable& table = set->allWrites;
 
     uint32_t currBinding = binding;
@@ -239,14 +236,10 @@
     }
 }
 
-void doEmulatedDescriptorBufferInfoWriteFromTemplate(
-    VkDescriptorType descType,
-    uint32_t binding,
-    uint32_t dstArrayElement,
-    uint32_t count,
-    const VkDescriptorBufferInfo* bufferInfos,
-    ReifiedDescriptorSet* set) {
-
+void doEmulatedDescriptorBufferInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+                                                     uint32_t dstArrayElement, uint32_t count,
+                                                     const VkDescriptorBufferInfo* bufferInfos,
+                                                     ReifiedDescriptorSet* set) {
     DescriptorWriteTable& table = set->allWrites;
 
     uint32_t currBinding = binding;
@@ -264,14 +257,10 @@
     }
 }
 
-void doEmulatedDescriptorBufferViewWriteFromTemplate(
-    VkDescriptorType descType,
-    uint32_t binding,
-    uint32_t dstArrayElement,
-    uint32_t count,
-    const VkBufferView* bufferViews,
-    ReifiedDescriptorSet* set) {
-
+void doEmulatedDescriptorBufferViewWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+                                                     uint32_t dstArrayElement, uint32_t count,
+                                                     const VkBufferView* bufferViews,
+                                                     ReifiedDescriptorSet* set) {
     DescriptorWriteTable& table = set->allWrites;
 
     uint32_t currBinding = binding;
@@ -305,22 +294,19 @@
 static bool isBindingFeasibleForAlloc(
     const DescriptorPoolAllocationInfo::DescriptorCountInfo& countInfo,
     const VkDescriptorSetLayoutBinding& binding) {
-
     if (binding.descriptorCount && (countInfo.type != binding.descriptorType)) {
         return false;
     }
 
-    uint32_t availDescriptorCount =
-        countInfo.descriptorCount - countInfo.used;
+    uint32_t availDescriptorCount = countInfo.descriptorCount - countInfo.used;
 
     if (availDescriptorCount < binding.descriptorCount) {
-        ALOGV("%s: Ran out of descriptors of type 0x%x. "
-              "Wanted %u from layout but "
-              "we only have %u free (total in pool: %u)\n", __func__,
-              binding.descriptorType,
-              binding.descriptorCount,
-              countInfo.descriptorCount - countInfo.used,
-              countInfo.descriptorCount);
+        ALOGV(
+            "%s: Ran out of descriptors of type 0x%x. "
+            "Wanted %u from layout but "
+            "we only have %u free (total in pool: %u)\n",
+            __func__, binding.descriptorType, binding.descriptorCount,
+            countInfo.descriptorCount - countInfo.used, countInfo.descriptorCount);
         return false;
     }
 
@@ -330,31 +316,27 @@
 static bool isBindingFeasibleForFree(
     const DescriptorPoolAllocationInfo::DescriptorCountInfo& countInfo,
     const VkDescriptorSetLayoutBinding& binding) {
-
     if (countInfo.type != binding.descriptorType) return false;
     if (countInfo.used < binding.descriptorCount) {
-        ALOGV("%s: Was a descriptor set double freed? "
-              "Ran out of descriptors of type 0x%x. "
-              "Wanted to free %u from layout but "
-              "we only have %u used (total in pool: %u)\n", __func__,
-              binding.descriptorType,
-              binding.descriptorCount,
-              countInfo.used,
-              countInfo.descriptorCount);
+        ALOGV(
+            "%s: Was a descriptor set double freed? "
+            "Ran out of descriptors of type 0x%x. "
+            "Wanted to free %u from layout but "
+            "we only have %u used (total in pool: %u)\n",
+            __func__, binding.descriptorType, binding.descriptorCount, countInfo.used,
+            countInfo.descriptorCount);
         return false;
     }
     return true;
 }
 
-static void allocBindingFeasible(
-    const VkDescriptorSetLayoutBinding& binding,
-    DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
+static void allocBindingFeasible(const VkDescriptorSetLayoutBinding& binding,
+                                 DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
     poolState.used += binding.descriptorCount;
 }
 
-static void freeBindingFeasible(
-    const VkDescriptorSetLayoutBinding& binding,
-    DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
+static void freeBindingFeasible(const VkDescriptorSetLayoutBinding& binding,
+                                DescriptorPoolAllocationInfo::DescriptorCountInfo& poolState) {
     poolState.used -= binding.descriptorCount;
 }
 
@@ -366,11 +348,11 @@
     auto setsAvailable = poolInfo->maxSets - poolInfo->usedSets;
 
     if (setsAvailable < pAllocateInfo->descriptorSetCount) {
-        ALOGV("%s: Error: VkDescriptorSetAllocateInfo wants %u sets "
-              "but we only have %u available. "
-              "Bailing with VK_ERROR_OUT_OF_POOL_MEMORY.\n", __func__,
-              pAllocateInfo->descriptorSetCount,
-              setsAvailable);
+        ALOGV(
+            "%s: Error: VkDescriptorSetAllocateInfo wants %u sets "
+            "but we only have %u available. "
+            "Bailing with VK_ERROR_OUT_OF_POOL_MEMORY.\n",
+            __func__, pAllocateInfo->descriptorSetCount, setsAvailable);
         return VK_ERROR_OUT_OF_POOL_MEMORY;
     }
 
@@ -381,11 +363,13 @@
 
     for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
         if (!pAllocateInfo->pSetLayouts[i]) {
-            ALOGV("%s: Error: Tried to allocate a descriptor set with null set layout.\n", __func__);
+            ALOGV("%s: Error: Tried to allocate a descriptor set with null set layout.\n",
+                  __func__);
             return VK_ERROR_INITIALIZATION_FAILED;
         }
 
-        auto setLayoutInfo = as_goldfish_VkDescriptorSetLayout(pAllocateInfo->pSetLayouts[i])->layoutInfo;
+        auto setLayoutInfo =
+            as_goldfish_VkDescriptorSetLayout(pAllocateInfo->pSetLayouts[i])->layoutInfo;
         if (!setLayoutInfo) {
             return VK_ERROR_INITIALIZATION_FAILED;
         }
@@ -423,7 +407,8 @@
     }
 }
 
-void removeDescriptorSetAllocation(VkDescriptorPool pool, const std::vector<VkDescriptorSetLayoutBinding>& bindings) {
+void removeDescriptorSetAllocation(VkDescriptorPool pool,
+                                   const std::vector<VkDescriptorSetLayoutBinding>& bindings) {
     auto allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
 
     if (0 == allocInfo->usedSets) {
@@ -442,7 +427,8 @@
     }
 }
 
-void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout, VkDescriptorSet set) {
+void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout,
+                                  VkDescriptorSet set) {
     DescriptorPoolAllocationInfo* allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
 
     ReifiedDescriptorSet* newReified = new ReifiedDescriptorSet;
@@ -457,7 +443,8 @@
     initializeReifiedDescriptorSet(pool, setLayout, newReified);
 }
 
-VkResult validateAndApplyVirtualDescriptorSetAllocation(const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets) {
+VkResult validateAndApplyVirtualDescriptorSetAllocation(
+    const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets) {
     VkResult validateRes = validateDescriptorSetAllocation(pAllocateInfo);
 
     if (validateRes != VK_SUCCESS) return validateRes;
@@ -470,15 +457,15 @@
     DescriptorPoolAllocationInfo* allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
 
     if (allocInfo->freePoolIds.size() < pAllocateInfo->descriptorSetCount) {
-        ALOGE("%s: FATAL: Somehow out of descriptor pool IDs. Wanted %u IDs but only have %u free IDs remaining. The count for maxSets was %u and used was %u\n", __func__,
-                pAllocateInfo->descriptorSetCount,
-                (uint32_t)allocInfo->freePoolIds.size(),
-                allocInfo->maxSets,
-                allocInfo->usedSets);
+        ALOGE(
+            "%s: FATAL: Somehow out of descriptor pool IDs. Wanted %u IDs but only have %u free "
+            "IDs remaining. The count for maxSets was %u and used was %u\n",
+            __func__, pAllocateInfo->descriptorSetCount, (uint32_t)allocInfo->freePoolIds.size(),
+            allocInfo->maxSets, allocInfo->usedSets);
         abort();
     }
 
-    for (uint32_t i = 0 ; i < pAllocateInfo->descriptorSetCount; ++i) {
+    for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) {
         uint64_t id = allocInfo->freePoolIds.back();
         allocInfo->freePoolIds.pop_back();
 
@@ -498,7 +485,8 @@
     DescriptorPoolAllocationInfo* allocInfo = as_goldfish_VkDescriptorPool(pool)->allocInfo;
 
     if (usePoolIds) {
-        // Look for the set's pool Id in the pool. If not found, then this wasn't really allocated, and bail.
+        // Look for the set's pool Id in the pool. If not found, then this wasn't really allocated,
+        // and bail.
         if (allocInfo->allocedPoolIds.find(reified->poolId) == allocInfo->allocedPoolIds.end()) {
             return false;
         }
@@ -522,7 +510,7 @@
         toClear.push_back(set);
     }
 
-    for (auto set: toClear) {
+    for (auto set : toClear) {
         removeDescriptorSetFromPool(set, usePoolIds);
     }
 
diff --git a/guest/vulkan_enc/DescriptorSetVirtualization.h b/guest/vulkan_enc/DescriptorSetVirtualization.h
index c6a6c42..0491102 100644
--- a/guest/vulkan_enc/DescriptorSetVirtualization.h
+++ b/guest/vulkan_enc/DescriptorSetVirtualization.h
@@ -14,13 +14,13 @@
 // limitations under the License.
 #pragma once
 
-#include "aemu/base/containers/EntityManager.h"
-
 #include <vulkan/vulkan.h>
 
 #include <unordered_set>
 #include <vector>
 
+#include "aemu/base/containers/EntityManager.h"
+
 namespace gfxstream {
 namespace vk {
 
@@ -37,7 +37,7 @@
     DescriptorWriteType type;
     VkDescriptorType descriptorType;
 
-    uint32_t dstArrayElement; // Only used for inlineUniformBlock and accelerationStructure.
+    uint32_t dstArrayElement;  // Only used for inlineUniformBlock and accelerationStructure.
 
     union {
         VkDescriptorImageInfo imageInfo;
@@ -105,7 +105,8 @@
 
 void clearReifiedDescriptorSet(ReifiedDescriptorSet* set);
 
-void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings, DescriptorWriteTable& table);
+void initDescriptorWriteTable(const std::vector<VkDescriptorSetLayoutBinding>& layoutBindings,
+                              DescriptorWriteTable& table);
 
 bool isDescriptorTypeImageInfo(VkDescriptorType descType);
 bool isDescriptorTypeBufferInfo(VkDescriptorType descType);
@@ -114,31 +115,23 @@
 bool isDescriptorTypeAccelerationStructure(VkDescriptorType descType);
 
 void doEmulatedDescriptorWrite(const VkWriteDescriptorSet* write, ReifiedDescriptorSet* toWrite);
-void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src, ReifiedDescriptorSet* dst);
+void doEmulatedDescriptorCopy(const VkCopyDescriptorSet* copy, const ReifiedDescriptorSet* src,
+                              ReifiedDescriptorSet* dst);
 
-void doEmulatedDescriptorImageInfoWriteFromTemplate(
-    VkDescriptorType descType,
-    uint32_t binding,
-    uint32_t dstArrayElement,
-    uint32_t count,
-    const VkDescriptorImageInfo* imageInfos,
-    ReifiedDescriptorSet* set);
+void doEmulatedDescriptorImageInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+                                                    uint32_t dstArrayElement, uint32_t count,
+                                                    const VkDescriptorImageInfo* imageInfos,
+                                                    ReifiedDescriptorSet* set);
 
-void doEmulatedDescriptorBufferInfoWriteFromTemplate(
-    VkDescriptorType descType,
-    uint32_t binding,
-    uint32_t dstArrayElement,
-    uint32_t count,
-    const VkDescriptorBufferInfo* bufferInfos,
-    ReifiedDescriptorSet* set);
+void doEmulatedDescriptorBufferInfoWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+                                                     uint32_t dstArrayElement, uint32_t count,
+                                                     const VkDescriptorBufferInfo* bufferInfos,
+                                                     ReifiedDescriptorSet* set);
 
-void doEmulatedDescriptorBufferViewWriteFromTemplate(
-    VkDescriptorType descType,
-    uint32_t binding,
-    uint32_t dstArrayElement,
-    uint32_t count,
-    const VkBufferView* bufferViews,
-    ReifiedDescriptorSet* set);
+void doEmulatedDescriptorBufferViewWriteFromTemplate(VkDescriptorType descType, uint32_t binding,
+                                                     uint32_t dstArrayElement, uint32_t count,
+                                                     const VkBufferView* bufferViews,
+                                                     ReifiedDescriptorSet* set);
 
 void doEmulatedDescriptorInlineUniformBlockFromTemplate(VkDescriptorType descType, uint32_t binding,
                                                         uint32_t dstArrayElement, uint32_t count,
@@ -146,8 +139,10 @@
                                                         ReifiedDescriptorSet* set);
 
 void applyDescriptorSetAllocation(VkDescriptorPool pool, VkDescriptorSetLayout setLayout);
-void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout, VkDescriptorSet set);
-VkResult validateAndApplyVirtualDescriptorSetAllocation(const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets);
+void fillDescriptorSetInfoForPool(VkDescriptorPool pool, VkDescriptorSetLayout setLayout,
+                                  VkDescriptorSet set);
+VkResult validateAndApplyVirtualDescriptorSetAllocation(
+    const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pSets);
 
 // Returns false if set wasn't found in its pool.
 bool removeDescriptorSetFromPool(VkDescriptorSet set, bool usePoolIds);
diff --git a/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp b/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
index 3f2f75c..dcf9f65 100644
--- a/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
+++ b/guest/vulkan_enc/HostVisibleMemoryVirtualization.cpp
@@ -45,10 +45,9 @@
                                VkDevice device, VkDeviceMemory memory)
     : mSize(size), mBlock(block), mDevice(device), mMemory(memory) {
     void* address = block->mmap(gpuAddr);
-    mAllocator =
-        std::make_unique<gfxstream::guest::SubAllocator>(address, mSize, kLargestPageSize);
+    mAllocator = std::make_unique<gfxstream::guest::SubAllocator>(address, mSize, kLargestPageSize);
 }
-#endif // defined(__ANDROID__)
+#endif  // defined(__ANDROID__)
 
 CoherentMemory::~CoherentMemory() {
     ResourceTracker::getThreadLocalEncoder()->vkFreeMemorySyncGOOGLE(mDevice, mMemory, nullptr,
diff --git a/guest/vulkan_enc/HostVisibleMemoryVirtualization.h b/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
index 051ea69..92acd5e 100644
--- a/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
+++ b/guest/vulkan_enc/HostVisibleMemoryVirtualization.h
@@ -47,7 +47,7 @@
 #if defined(__ANDROID__)
     CoherentMemory(GoldfishAddressSpaceBlockPtr block, uint64_t gpuAddr, uint64_t size,
                    VkDevice device, VkDeviceMemory memory);
-#endif // defined(__ANDROID__)
+#endif  // defined(__ANDROID__)
 
     ~CoherentMemory();
 
diff --git a/guest/vulkan_enc/ResourceTracker.cpp b/guest/vulkan_enc/ResourceTracker.cpp
index 4e4d0e7..202090a 100644
--- a/guest/vulkan_enc/ResourceTracker.cpp
+++ b/guest/vulkan_enc/ResourceTracker.cpp
@@ -23,6 +23,7 @@
 #include "Resources.h"
 #include "VkEncoder.h"
 #include "aemu/base/AlignedBuf.h"
+#include "gfxstream_vk_private.h"
 #include "goldfish_address_space.h"
 #include "goldfish_vk_private_defs.h"
 #include "util.h"
@@ -200,10 +201,10 @@
     std::unordered_set<VkDescriptorSet> sets;
 };
 
-#define HANDLE_REGISTER_IMPL_IMPL(type)                \
-    void ResourceTracker::register_##type(type obj) {  \
-        AutoLock<RecursiveLock> lock(mLock);           \
-        info_##type[obj] = type##_Info();              \
+#define HANDLE_REGISTER_IMPL_IMPL(type)               \
+    void ResourceTracker::register_##type(type obj) { \
+        AutoLock<RecursiveLock> lock(mLock);          \
+        info_##type[obj] = type##_Info();             \
     }
 
 #define HANDLE_UNREGISTER_IMPL_IMPL(type)               \
@@ -286,7 +287,8 @@
     return as_goldfish_VkDescriptorSet(dstSet)->reified->bindingIsImmutableSampler[dstBinding];
 }
 
-VkDescriptorImageInfo ResourceTracker::filterNonexistentSampler(const VkDescriptorImageInfo& inputInfo) {
+VkDescriptorImageInfo ResourceTracker::filterNonexistentSampler(
+    const VkDescriptorImageInfo& inputInfo) {
     VkSampler sampler = inputInfo.sampler;
 
     VkDescriptorImageInfo res = inputInfo;
@@ -300,9 +302,11 @@
     return res;
 }
 
-void ResourceTracker::emitDeviceMemoryReport(VkDevice_Info info, VkDeviceMemoryReportEventTypeEXT type,
-                            uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType,
-                            uint64_t objectHandle, uint32_t heapIndex) {
+void ResourceTracker::emitDeviceMemoryReport(VkDevice_Info info,
+                                             VkDeviceMemoryReportEventTypeEXT type,
+                                             uint64_t memoryObjectId, VkDeviceSize size,
+                                             VkObjectType objectType, uint64_t objectHandle,
+                                             uint32_t heapIndex) {
     if (info.deviceMemoryReportCallbacks.empty()) return;
 
     const VkDeviceMemoryReportCallbackDataEXT callbackData = {
@@ -640,9 +644,10 @@
         createInfoDup.pNext = nullptr;
         enc->vkGetLinearImageLayout2GOOGLE(device, &createInfoDup, &offset, &rowPitchAlignment,
                                            true /* do lock */);
-        ALOGD("vkGetLinearImageLayout2GOOGLE: format %d offset %lu "
-          "rowPitchAlignment = %lu",
-          (int)createInfo->format, offset, rowPitchAlignment);
+        ALOGD(
+            "vkGetLinearImageLayout2GOOGLE: format %d offset %lu "
+            "rowPitchAlignment = %lu",
+            (int)createInfo->format, offset, rowPitchAlignment);
     }
 
     imageConstraints.min_coded_width = createInfo->extent.width;
@@ -721,8 +726,8 @@
     dedicatedReqs->requiresDedicatedAllocation = VK_TRUE;
 }
 
-void ResourceTracker::setMemoryRequirementsForSysmemBackedImage(VkImage image,
-    VkMemoryRequirements* pMemoryRequirements) {
+void ResourceTracker::transformImageMemoryRequirementsForGuestLocked(VkImage image,
+                                                                     VkMemoryRequirements* reqs) {
 #ifdef VK_USE_PLATFORM_FUCHSIA
     auto it = info_VkImage.find(image);
     if (it == info_VkImage.end()) return;
@@ -730,21 +735,25 @@
     if (info.isSysmemBackedMemory) {
         auto width = info.createInfo.extent.width;
         auto height = info.createInfo.extent.height;
-        pMemoryRequirements->size = width * height * 4;
+        reqs->size = width * height * 4;
+    }
+#elif defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+    auto it = info_VkImage.find(image);
+    if (it == info_VkImage.end()) return;
+    auto& info = it->second;
+    if (info.isWsiImage) {
+        static const uint32_t kColorBufferBpp = 4;
+        reqs->size = kColorBufferBpp * info.createInfo.extent.width * info.createInfo.extent.height;
     }
 #else
     // Bypass "unused parameter" checks.
     (void)image;
-    (void)pMemoryRequirements;
+    (void)reqs;
 #endif
 }
 
-void ResourceTracker::transformImageMemoryRequirementsForGuestLocked(VkImage image,
-    VkMemoryRequirements* reqs) {
-    setMemoryRequirementsForSysmemBackedImage(image, reqs);
-}
-
-CoherentMemoryPtr ResourceTracker::freeCoherentMemoryLocked(VkDeviceMemory memory, VkDeviceMemory_Info& info) {
+CoherentMemoryPtr ResourceTracker::freeCoherentMemoryLocked(VkDeviceMemory memory,
+                                                            VkDeviceMemory_Info& info) {
     if (info.coherentMemory && info.ptr) {
         if (info.coherentMemory->getDeviceMemory() != memory) {
             delete_goldfish_VkDeviceMemory(memory);
@@ -1341,7 +1350,8 @@
 void ResourceTracker::setDeviceMemoryInfo(VkDevice device, VkDeviceMemory memory,
                                           VkDeviceSize allocationSize, uint8_t* ptr,
                                           uint32_t memoryTypeIndex, AHardwareBuffer* ahw,
-                                          bool imported, zx_handle_t vmoHandle) {
+                                          bool imported, zx_handle_t vmoHandle,
+                                          VirtGpuBlobPtr blobPtr) {
     AutoLock<RecursiveLock> lock(mLock);
     auto& info = info_VkDeviceMemory[memory];
 
@@ -1354,6 +1364,7 @@
 #endif
     info.imported = imported;
     info.vmoHandle = vmoHandle;
+    info.blobPtr = blobPtr;
 }
 
 void ResourceTracker::setImageInfo(VkImage image, VkDevice device,
@@ -1763,6 +1774,7 @@
         "VK_EXT_scalar_block_layout",
         "VK_KHR_descriptor_update_template",
         "VK_KHR_storage_buffer_storage_class",
+        "VK_EXT_depth_clip_enable",
 #if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
         "VK_KHR_external_semaphore",
         "VK_KHR_external_semaphore_fd",
@@ -1772,7 +1784,7 @@
         "VK_KHR_external_fence_fd",
         "VK_EXT_device_memory_report",
 #endif
-#if !defined(VK_USE_PLATFORM_ANDROID_KHR) && defined(__linux__)
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
         "VK_KHR_create_renderpass2",
         "VK_KHR_imageless_framebuffer",
 #endif
@@ -1847,9 +1859,11 @@
     bool win32ExtMemAvailable = getHostDeviceExtensionIndex("VK_KHR_external_memory_win32") != -1;
     bool posixExtMemAvailable = getHostDeviceExtensionIndex("VK_KHR_external_memory_fd") != -1;
     bool moltenVkExtAvailable = getHostDeviceExtensionIndex("VK_MVK_moltenvk") != -1;
+    bool qnxExtMemAvailable =
+        getHostDeviceExtensionIndex("VK_QNX_external_memory_screen_buffer") != -1;
 
     bool hostHasExternalMemorySupport =
-        win32ExtMemAvailable || posixExtMemAvailable || moltenVkExtAvailable;
+        win32ExtMemAvailable || posixExtMemAvailable || moltenVkExtAvailable || qnxExtMemAvailable;
 
     if (hostHasExternalMemorySupport) {
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
@@ -2029,7 +2043,19 @@
 }
 
 void ResourceTracker::on_vkGetPhysicalDeviceProperties(void*, VkPhysicalDevice,
-                                                       VkPhysicalDeviceProperties*) {}
+                                                       VkPhysicalDeviceProperties* pProperties) {
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (pProperties) {
+        if (VK_PHYSICAL_DEVICE_TYPE_CPU == pProperties->deviceType) {
+            /* For Linux guest: Even if host driver reports DEVICE_TYPE_CPU,
+             * override this to VIRTUAL_GPU, otherwise Linux DRM interfaces
+             * will take unexpected code paths to deal with "software" driver
+             */
+            pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU;
+        }
+    }
+#endif
+}
 
 void ResourceTracker::on_vkGetPhysicalDeviceFeatures2(void*, VkPhysicalDevice,
                                                       VkPhysicalDeviceFeatures2* pFeatures) {
@@ -2048,7 +2074,8 @@
     on_vkGetPhysicalDeviceFeatures2(context, physicalDevice, pFeatures);
 }
 
-void ResourceTracker::on_vkGetPhysicalDeviceProperties2(void*, VkPhysicalDevice,
+void ResourceTracker::on_vkGetPhysicalDeviceProperties2(void* context,
+                                                        VkPhysicalDevice physicalDevice,
                                                         VkPhysicalDeviceProperties2* pProperties) {
     if (pProperties) {
         VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* memoryReportFeaturesEXT =
@@ -2056,6 +2083,7 @@
         if (memoryReportFeaturesEXT) {
             memoryReportFeaturesEXT->deviceMemoryReport = VK_TRUE;
         }
+        on_vkGetPhysicalDeviceProperties(context, physicalDevice, &pProperties->properties);
     }
 }
 
@@ -2142,6 +2170,12 @@
     }
 }
 
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
+void updateMemoryTypeBits(uint32_t* memoryTypeBits, uint32_t memoryIndex) {
+    *memoryTypeBits = 1u << memoryIndex;
+}
+#endif
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
 VkResult ResourceTracker::on_vkGetAndroidHardwareBufferPropertiesANDROID(
@@ -2843,6 +2877,33 @@
 }
 #endif
 
+static uint32_t getVirglFormat(VkFormat vkFormat) {
+    uint32_t virglFormat = 0;
+
+    switch (vkFormat) {
+        case VK_FORMAT_R8G8B8A8_SINT:
+        case VK_FORMAT_R8G8B8A8_UNORM:
+        case VK_FORMAT_R8G8B8A8_SRGB:
+        case VK_FORMAT_R8G8B8A8_SNORM:
+        case VK_FORMAT_R8G8B8A8_SSCALED:
+        case VK_FORMAT_R8G8B8A8_USCALED:
+            virglFormat = VIRGL_FORMAT_R8G8B8A8_UNORM;
+            break;
+        case VK_FORMAT_B8G8R8A8_SINT:
+        case VK_FORMAT_B8G8R8A8_UNORM:
+        case VK_FORMAT_B8G8R8A8_SRGB:
+        case VK_FORMAT_B8G8R8A8_SNORM:
+        case VK_FORMAT_B8G8R8A8_SSCALED:
+        case VK_FORMAT_B8G8R8A8_USCALED:
+            virglFormat = VIRGL_FORMAT_B8G8R8A8_UNORM;
+            break;
+        default:
+            break;
+    }
+
+    return virglFormat;
+}
+
 CoherentMemoryPtr ResourceTracker::createCoherentMemory(
     VkDevice device, VkDeviceMemory mem, const VkMemoryAllocateInfo& hostAllocationInfo,
     VkEncoder* enc, VkResult& res) {
@@ -3221,6 +3282,13 @@
     const void* importAhbInfoPtr = nullptr;
 #endif
 
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+    const VkImportMemoryFdInfoKHR* importFdInfoPtr =
+        vk_find_struct<VkImportMemoryFdInfoKHR>(pAllocateInfo);
+#else
+    const VkImportMemoryFdInfoKHR* importFdInfoPtr = nullptr;
+#endif
+
 #ifdef VK_USE_PLATFORM_FUCHSIA
     const VkImportMemoryBufferCollectionFUCHSIA* importBufferCollectionInfoPtr =
         vk_find_struct<VkImportMemoryBufferCollectionFUCHSIA>(pAllocateInfo);
@@ -3268,9 +3336,11 @@
     // State needed for import/export.
     bool exportAhb = false;
     bool exportVmo = false;
+    bool exportDmabuf = false;
     bool importAhb = false;
     bool importBufferCollection = false;
     bool importVmo = false;
+    bool importDmabuf = false;
     (void)exportVmo;
 
     // Even if we export allocate, the underlying operation
@@ -3291,6 +3361,9 @@
         exportVmo = exportAllocateInfoPtr->handleTypes &
                     VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA;
 #endif  // VK_USE_PLATFORM_FUCHSIA
+        exportDmabuf =
+            exportAllocateInfoPtr->handleTypes & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
+                                                  VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
     } else if (importAhbInfoPtr) {
         importAhb = true;
     } else if (importBufferCollectionInfoPtr) {
@@ -3298,7 +3371,13 @@
     } else if (importVmoInfoPtr) {
         importVmo = true;
     }
-    bool isImport = importAhb || importBufferCollection || importVmo;
+
+    if (importFdInfoPtr) {
+        importDmabuf =
+            (importFdInfoPtr->handleType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
+                                            VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT));
+    }
+    bool isImport = importAhb || importBufferCollection || importVmo || importDmabuf;
 
 #if defined(VK_USE_PLATFORM_ANDROID_KHR)
     if (exportAhb) {
@@ -3671,7 +3750,96 @@
     }
 #endif
 
-    if (ahw || !requestedMemoryIsHostVisible) {
+    VirtGpuBlobPtr colorBufferBlob = nullptr;
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (exportDmabuf) {
+        VirtGpuDevice* instance = VirtGpuDevice::getInstance();
+        // // TODO: any special action for VK_STRUCTURE_TYPE_WSI_MEMORY_ALLOCATE_INFO_MESA? Can mark
+        // special state if needed.
+        // // const wsi_memory_allocate_info* wsiAllocateInfoPtr =
+        // vk_find_struct<wsi_memory_allocate_info>(pAllocateInfo);
+        bool hasDedicatedImage =
+            dedicatedAllocInfoPtr && (dedicatedAllocInfoPtr->image != VK_NULL_HANDLE);
+        bool hasDedicatedBuffer =
+            dedicatedAllocInfoPtr && (dedicatedAllocInfoPtr->buffer != VK_NULL_HANDLE);
+        if (!hasDedicatedImage && !hasDedicatedBuffer) {
+            ALOGE(
+                "%s: dma-buf exportable memory requires dedicated Image or Buffer information.\n");
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+
+        if (hasDedicatedImage) {
+            VkImageCreateInfo imageCreateInfo;
+            {
+                AutoLock<RecursiveLock> lock(mLock);
+
+                auto it = info_VkImage.find(dedicatedAllocInfoPtr->image);
+                if (it == info_VkImage.end()) return VK_ERROR_INITIALIZATION_FAILED;
+                const auto& imageInfo = it->second;
+
+                imageCreateInfo = imageInfo.createInfo;
+            }
+            uint32_t virglFormat = gfxstream::vk::getVirglFormat(imageCreateInfo.format);
+            if (virglFormat < 0) {
+                ALOGE("%s: Unsupported VK format for colorBuffer, vkFormat: 0x%x", __func__,
+                      imageCreateInfo.format);
+                return VK_ERROR_FORMAT_NOT_SUPPORTED;
+            }
+            colorBufferBlob = instance->createVirglBlob(imageCreateInfo.extent.width,
+                                                        imageCreateInfo.extent.height, virglFormat);
+            if (!colorBufferBlob) {
+                ALOGE("%s: Failed to create colorBuffer resource for Image memory\n", __func__);
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+            if (0 != colorBufferBlob->wait()) {
+                ALOGE("%s: Failed to wait for colorBuffer resource for Image memory\n", __func__);
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+        }
+
+        if (hasDedicatedBuffer) {
+            VkBufferCreateInfo bufferCreateInfo;
+            {
+                AutoLock<RecursiveLock> lock(mLock);
+
+                auto it = info_VkBuffer.find(dedicatedAllocInfoPtr->buffer);
+                if (it == info_VkBuffer.end()) return VK_ERROR_INITIALIZATION_FAILED;
+                const auto& bufferInfo = it->second;
+                bufferCreateInfo = bufferInfo.createInfo;
+            }
+            colorBufferBlob = instance->createVirglBlob(bufferCreateInfo.size / 4, 1,
+                                                        VIRGL_FORMAT_R8G8B8A8_UNORM);
+            if (!colorBufferBlob) {
+                ALOGE("%s: Failed to create colorBuffer resource for Buffer memory\n", __func__);
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+            if (0 != colorBufferBlob->wait()) {
+                ALOGE("%s: Failed to wait for colorBuffer resource for Buffer memory\n", __func__);
+                return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+            }
+        }
+    }
+
+    if (importDmabuf) {
+        VirtGpuExternalHandle importHandle = {};
+        importHandle.osHandle = importFdInfoPtr->fd;
+        importHandle.type = kMemHandleDmabuf;
+
+        auto instance = VirtGpuDevice::getInstance();
+        colorBufferBlob = instance->importBlob(importHandle);
+        if (!colorBufferBlob) {
+            ALOGE("%s: Failed to import colorBuffer resource\n", __func__);
+            return VK_ERROR_OUT_OF_DEVICE_MEMORY;
+        }
+    }
+
+    if (colorBufferBlob) {
+        importCbInfo.colorBuffer = colorBufferBlob->getResourceHandle();
+        vk_append_struct(&structChainIter, &importCbInfo);
+    }
+#endif
+
+    if (ahw || colorBufferBlob || !requestedMemoryIsHostVisible) {
         input_result =
             enc->vkAllocateMemory(device, &finalAllocInfo, pAllocator, pMemory, true /* do lock */);
 
@@ -3679,7 +3847,7 @@
 
         VkDeviceSize allocationSize = finalAllocInfo.allocationSize;
         setDeviceMemoryInfo(device, *pMemory, 0, nullptr, finalAllocInfo.memoryTypeIndex, ahw,
-                            isImport, vmo_handle);
+                            isImport, vmo_handle, colorBufferBlob);
 
         _RETURN_SCUCCESS_WITH_DEVICE_MEMORY_REPORT;
     }
@@ -3714,7 +3882,7 @@
 
         setDeviceMemoryInfo(device, *pMemory, finalAllocInfo.allocationSize,
                             reinterpret_cast<uint8_t*>(addr), finalAllocInfo.memoryTypeIndex,
-                            /*ahw=*/nullptr, isImport, vmo_handle);
+                            /*ahw=*/nullptr, isImport, vmo_handle, /*blobPtr=*/nullptr);
         return VK_SUCCESS;
     }
 #endif
@@ -3857,11 +4025,11 @@
     auto& info = it->second;
 
     if (!info.external || !info.externalCreateInfo.handleTypes) {
-        setMemoryRequirementsForSysmemBackedImage(image, &reqs2->memoryRequirements);
+        transformImageMemoryRequirementsForGuestLocked(image, &reqs2->memoryRequirements);
         return;
     }
 
-    setMemoryRequirementsForSysmemBackedImage(image, &reqs2->memoryRequirements);
+    transformImageMemoryRequirementsForGuestLocked(image, &reqs2->memoryRequirements);
 
     VkMemoryDedicatedRequirements* dedicatedReqs =
         vk_find_struct<VkMemoryDedicatedRequirements>(reqs2);
@@ -3909,11 +4077,29 @@
 
     const VkExternalMemoryImageCreateInfo* extImgCiPtr =
         vk_find_struct<VkExternalMemoryImageCreateInfo>(pCreateInfo);
+
     if (extImgCiPtr) {
         localExtImgCi = vk_make_orphan_copy(*extImgCiPtr);
         vk_append_struct(&structChainIter, &localExtImgCi);
     }
 
+    bool isWsiImage = false;
+
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (extImgCiPtr &&
+        (extImgCiPtr->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT)) {
+        // Assumes that handleType with DMA_BUF_BIT indicates creation of a
+        // image for WSI use; no other external dma_buf usage is supported
+        isWsiImage = true;
+        // Must be linear. Otherwise querying stride and other properties
+        // can be implementation-dependent.
+        localCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
+        if (gfxstream::vk::getVirglFormat(localCreateInfo.format) < 0) {
+            localCreateInfo.format = VK_FORMAT_R8G8B8A8_UNORM;
+        }
+    }
+#endif
+
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     VkNativeBufferANDROID localAnb;
     const VkNativeBufferANDROID* anbInfoPtr = vk_find_struct<VkNativeBufferANDROID>(pCreateInfo);
@@ -4085,13 +4271,16 @@
     }
 #endif
 
+    info.isWsiImage = isWsiImage;
+
 // Delete `protocolVersion` check goldfish drivers are gone.
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
     if (mCaps.vulkanCapset.colorBufferMemoryIndex == 0xFFFFFFFF) {
         mCaps.vulkanCapset.colorBufferMemoryIndex = getColorBufferMemoryIndex(context, device);
     }
-    if (extImgCiPtr && (extImgCiPtr->handleTypes &
-                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
+    if (isWsiImage ||
+        (extImgCiPtr && (extImgCiPtr->handleTypes &
+                         VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID))) {
         updateMemoryTypeBits(&memReqs.memoryTypeBits, mCaps.vulkanCapset.colorBufferMemoryIndex);
     }
 #endif
@@ -4981,7 +5170,6 @@
         vk_append_struct(&structChainIter, &localExtBufCi);
     }
 
-
     VkBufferOpaqueCaptureAddressCreateInfo localCapAddrCi;
     const VkBufferOpaqueCaptureAddressCreateInfo* pCapAddrCi =
         vk_find_struct<VkBufferOpaqueCaptureAddressCreateInfo>(pCreateInfo);
@@ -5057,12 +5245,14 @@
 
     if (res != VK_SUCCESS) return res;
 
-#ifdef VK_USE_PLATFORM_ANDROID_KHR
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
     if (mCaps.vulkanCapset.colorBufferMemoryIndex == 0xFFFFFFFF) {
         mCaps.vulkanCapset.colorBufferMemoryIndex = getColorBufferMemoryIndex(context, device);
     }
-    if (extBufCiPtr && (extBufCiPtr->handleTypes &
-                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)) {
+    if (extBufCiPtr &&
+        ((extBufCiPtr->handleTypes &
+          VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) ||
+         (extBufCiPtr->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))) {
         updateMemoryTypeBits(&memReqs.memoryTypeBits, mCaps.vulkanCapset.colorBufferMemoryIndex);
     }
 #endif
@@ -5354,6 +5544,53 @@
 #endif
 }
 
+VkResult ResourceTracker::on_vkGetMemoryFdKHR(void* context, VkResult, VkDevice device,
+                                              const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) {
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+    if (!pGetFdInfo) return VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (!pGetFdInfo->memory) return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+    if (!(pGetFdInfo->handleType & (VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
+                                    VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT))) {
+        ALOGE("%s: Export operation not defined for handleType: 0x%x\n", __func__,
+              pGetFdInfo->handleType);
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    // Sanity-check device
+    AutoLock<RecursiveLock> lock(mLock);
+    auto deviceIt = info_VkDevice.find(device);
+    if (deviceIt == info_VkDevice.end()) {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    auto deviceMemIt = info_VkDeviceMemory.find(pGetFdInfo->memory);
+    if (deviceMemIt == info_VkDeviceMemory.end()) {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    auto& info = deviceMemIt->second;
+
+    if (!info.blobPtr) {
+        ALOGE("%s: VkDeviceMemory does not have a resource available for export.\n", __func__);
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+
+    VirtGpuExternalHandle handle{};
+    int ret = info.blobPtr->exportBlob(handle);
+    if (ret != 0 || handle.osHandle < 0) {
+        ALOGE("%s: Failed to export host resource to FD.\n", __func__);
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+    *pFd = handle.osHandle;
+    return VK_SUCCESS;
+#else
+    (void)context;
+    (void)device;
+    (void)pGetFdInfo;
+    (void)pFd;
+    return VK_ERROR_INCOMPATIBLE_DRIVER;
+#endif
+}
+
 void ResourceTracker::flushCommandBufferPendingCommandsBottomUp(
     void* context, VkQueue queue, const std::vector<VkCommandBuffer>& workingSet) {
     if (workingSet.empty()) return;
@@ -5704,9 +5941,14 @@
     }
 
     auto* gralloc = ResourceTracker::threadingCallbacks.hostConnectionGetFunc()->grallocHelper();
+    const native_handle_t* nativeHandle = (const native_handle_t*)inputNativeInfo->handle;
 
-    *(uint32_t*)(outputNativeInfo->handle) =
-        gralloc->getHostHandle((const native_handle_t*)inputNativeInfo->handle);
+#if defined(END2END_TESTS)
+    // This is valid since the testing backend creates the handle and we know the layout.
+    *(uint32_t*)(outputNativeInfo->handle) = (uint32_t)nativeHandle->data[0];
+#else
+    *(uint32_t*)(outputNativeInfo->handle) = gralloc->getHostHandle(nativeHandle);
+#endif
 }
 
 void ResourceTracker::unwrap_VkBindImageMemorySwapchainInfoKHR(
@@ -6040,6 +6282,14 @@
 
                 memcpy(((uint8_t*)imageInfos) + currImageInfoOffset, user,
                        sizeof(VkDescriptorImageInfo));
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+                // Convert mesa to internal for objects in the user buffer
+                VkDescriptorImageInfo* internalImageInfo =
+                    (VkDescriptorImageInfo*)(((uint8_t*)imageInfos) + currImageInfoOffset);
+                VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_image_view,
+                               internalImageInfo->imageView);
+                internalImageInfo->imageView = gfxstream_image_view->internal_object;
+#endif
                 currImageInfoOffset += sizeof(VkDescriptorImageInfo);
             }
 
@@ -6059,6 +6309,13 @@
 
                 memcpy(((uint8_t*)bufferInfos) + currBufferInfoOffset, user,
                        sizeof(VkDescriptorBufferInfo));
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+                // Convert mesa to internal for objects in the user buffer
+                VkDescriptorBufferInfo* internalBufferInfo =
+                    (VkDescriptorBufferInfo*)(((uint8_t*)bufferInfos) + currBufferInfoOffset);
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internalBufferInfo->buffer);
+                internalBufferInfo->buffer = gfxstream_buffer->internal_object;
+#endif
                 currBufferInfoOffset += sizeof(VkDescriptorBufferInfo);
             }
 
@@ -6077,6 +6334,15 @@
                 const VkBufferView* user = (const VkBufferView*)(userBuffer + offset + j * stride);
 
                 memcpy(((uint8_t*)bufferViews) + currBufferViewOffset, user, sizeof(VkBufferView));
+#if defined(__linux__) && !defined(VK_USE_PLATFORM_ANDROID_KHR)
+                // Convert mesa to internal for objects in the user buffer
+                VkBufferView* internalBufferView =
+                    (VkBufferView*)(((uint8_t*)bufferViews) + currBufferViewOffset);
+                VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_buffer_view,
+                               *internalBufferView);
+                *internalBufferView = gfxstream_buffer_view->internal_object;
+#endif
+
                 currBufferViewOffset += sizeof(VkBufferView);
             }
 
@@ -6139,7 +6405,6 @@
         VK_FORMAT_R8G8_SSCALED,   VK_FORMAT_R8G8_SRGB,
     };
 
-
     if (ext_img_properties) {
         if (std::find(std::begin(kExternalImageSupportedFormats),
                       std::end(kExternalImageSupportedFormats),
@@ -6154,7 +6419,7 @@
     VkAndroidHardwareBufferUsageANDROID* output_ahw_usage =
         vk_find_struct<VkAndroidHardwareBufferUsageANDROID>(pImageFormatProperties);
     supportedHandleType |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
-        VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
+                           VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
 #endif
     const VkPhysicalDeviceExternalImageFormatInfo* ext_img_info =
         vk_find_struct<VkPhysicalDeviceExternalImageFormatInfo>(pImageFormatInfo);
@@ -6201,7 +6466,8 @@
     }
 #endif
     if (ext_img_properties) {
-        transformImpl_VkExternalMemoryProperties_fromhost(&ext_img_properties->externalMemoryProperties, 0);
+        transformImpl_VkExternalMemoryProperties_fromhost(
+            &ext_img_properties->externalMemoryProperties, 0);
     }
     return hostRes;
 }
@@ -6236,11 +6502,12 @@
 #endif
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     supportedHandleType |= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
-            VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
+                           VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
 #endif
     if (supportedHandleType) {
         // 0 is a valid handleType so we can't check against 0
-        if (pExternalBufferInfo->handleType != (pExternalBufferInfo->handleType & supportedHandleType)) {
+        if (pExternalBufferInfo->handleType !=
+            (pExternalBufferInfo->handleType & supportedHandleType)) {
             return;
         }
     }
@@ -6252,7 +6519,8 @@
         enc->vkGetPhysicalDeviceExternalBufferProperties(
             physicalDevice, pExternalBufferInfo, pExternalBufferProperties, true /* do lock */);
     }
-    transformImpl_VkExternalMemoryProperties_fromhost(&pExternalBufferProperties->externalMemoryProperties, 0);
+    transformImpl_VkExternalMemoryProperties_fromhost(
+        &pExternalBufferProperties->externalMemoryProperties, 0);
 }
 
 void ResourceTracker::on_vkGetPhysicalDeviceExternalBufferProperties(
@@ -6261,8 +6529,7 @@
     VkExternalBufferProperties* pExternalBufferProperties) {
     return on_vkGetPhysicalDeviceExternalBufferProperties_common(
         false /* not KHR */, context, physicalDevice, pExternalBufferInfo,
-        pExternalBufferProperties
-    );
+        pExternalBufferProperties);
 }
 
 void ResourceTracker::on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
@@ -6270,9 +6537,7 @@
     const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo,
     VkExternalBufferPropertiesKHR* pExternalBufferProperties) {
     return on_vkGetPhysicalDeviceExternalBufferProperties_common(
-        true /* is KHR */, context, physicalDevice, pExternalBufferInfo,
-        pExternalBufferProperties
-    );
+        true /* is KHR */, context, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
 }
 
 void ResourceTracker::on_vkGetPhysicalDeviceExternalSemaphoreProperties(
@@ -6776,8 +7041,10 @@
             vk_find_struct<VkPipelineRenderingCreateInfo>(&graphicsPipelineCreateInfo);
 
         if (pipelineRenderingInfo) {
-            forceDepthStencilState |= pipelineRenderingInfo->depthAttachmentFormat != VK_FORMAT_UNDEFINED;
-            forceDepthStencilState |= pipelineRenderingInfo->stencilAttachmentFormat != VK_FORMAT_UNDEFINED;
+            forceDepthStencilState |=
+                pipelineRenderingInfo->depthAttachmentFormat != VK_FORMAT_UNDEFINED;
+            forceDepthStencilState |=
+                pipelineRenderingInfo->stencilAttachmentFormat != VK_FORMAT_UNDEFINED;
             forceColorBlendState |= pipelineRenderingInfo->colorAttachmentCount != 0;
         }
 
@@ -6998,7 +7265,8 @@
 }
 
 // static
-ALWAYS_INLINE VkEncoder* ResourceTracker::getCommandBufferEncoder(VkCommandBuffer commandBuffer) {
+ALWAYS_INLINE_GFXSTREAM VkEncoder* ResourceTracker::getCommandBufferEncoder(
+    VkCommandBuffer commandBuffer) {
     if (!(ResourceTracker::streamFeatureBits &
           VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT)) {
         auto enc = ResourceTracker::getThreadLocalEncoder();
@@ -7019,7 +7287,7 @@
 }
 
 // static
-ALWAYS_INLINE VkEncoder* ResourceTracker::getQueueEncoder(VkQueue queue) {
+ALWAYS_INLINE_GFXSTREAM VkEncoder* ResourceTracker::getQueueEncoder(VkQueue queue) {
     auto enc = ResourceTracker::getThreadLocalEncoder();
     if (!(ResourceTracker::streamFeatureBits &
           VULKAN_STREAM_FEATURE_QUEUE_SUBMIT_WITH_COMMANDS_BIT)) {
@@ -7029,7 +7297,7 @@
 }
 
 // static
-ALWAYS_INLINE VkEncoder* ResourceTracker::getThreadLocalEncoder() {
+ALWAYS_INLINE_GFXSTREAM VkEncoder* ResourceTracker::getThreadLocalEncoder() {
     auto hostConn = ResourceTracker::threadingCallbacks.hostConnectionGetFunc();
     auto vkEncoder = ResourceTracker::threadingCallbacks.vkEncoderGetFunc(hostConn);
     return vkEncoder;
@@ -7039,13 +7307,13 @@
 void ResourceTracker::setSeqnoPtr(uint32_t* seqnoptr) { sSeqnoPtr = seqnoptr; }
 
 // static
-ALWAYS_INLINE uint32_t ResourceTracker::nextSeqno() {
+ALWAYS_INLINE_GFXSTREAM uint32_t ResourceTracker::nextSeqno() {
     uint32_t res = __atomic_add_fetch(sSeqnoPtr, 1, __ATOMIC_SEQ_CST);
     return res;
 }
 
 // static
-ALWAYS_INLINE uint32_t ResourceTracker::getSeqno() {
+ALWAYS_INLINE_GFXSTREAM uint32_t ResourceTracker::getSeqno() {
     uint32_t res = __atomic_load_n(sSeqnoPtr, __ATOMIC_SEQ_CST);
     return res;
 }
diff --git a/guest/vulkan_enc/ResourceTracker.h b/guest/vulkan_enc/ResourceTracker.h
index af34ab6..07e09cb 100644
--- a/guest/vulkan_enc/ResourceTracker.h
+++ b/guest/vulkan_enc/ResourceTracker.h
@@ -273,6 +273,9 @@
                                               const VkBindImageMemoryInfo* inputBindInfos,
                                               VkBindImageMemoryInfo* outputBindInfos);
 
+    VkResult on_vkGetMemoryFdKHR(void* context, VkResult input_result, VkDevice device,
+                                 const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);
+
 #ifdef VK_USE_PLATFORM_FUCHSIA
     VkResult on_vkGetMemoryZirconHandleFUCHSIA(void* context, VkResult input_result,
                                                VkDevice device,
@@ -541,9 +544,9 @@
     void resetCommandPoolStagingInfo(VkCommandPool commandPool);
 
 #ifdef __GNUC__
-#define ALWAYS_INLINE
+#define ALWAYS_INLINE_GFXSTREAM
 #elif
-#define ALWAYS_INLINE __attribute__((always_inline))
+#define ALWAYS_INLINE_GFXSTREAM __attribute__((always_inline))
 #endif
 
     static VkEncoder* getCommandBufferEncoder(VkCommandBuffer commandBuffer);
@@ -551,8 +554,8 @@
     static VkEncoder* getThreadLocalEncoder();
 
     static void setSeqnoPtr(uint32_t* seqnoptr);
-    static ALWAYS_INLINE uint32_t nextSeqno();
-    static ALWAYS_INLINE uint32_t getSeqno();
+    static ALWAYS_INLINE_GFXSTREAM uint32_t nextSeqno();
+    static ALWAYS_INLINE_GFXSTREAM uint32_t getSeqno();
 
     // Transforms
     void deviceMemoryTransform_tohost(VkDeviceMemory* memory, uint32_t memoryCount,
@@ -614,7 +617,7 @@
 
     void setDeviceMemoryInfo(VkDevice device, VkDeviceMemory memory, VkDeviceSize allocationSize,
                              uint8_t* ptr, uint32_t memoryTypeIndex, AHardwareBuffer* ahw,
-                             bool imported, zx_handle_t vmoHandle);
+                             bool imported, zx_handle_t vmoHandle, VirtGpuBlobPtr blobPtr);
 
     void setImageInfo(VkImage image, VkDevice device, const VkImageCreateInfo* pCreateInfo);
 
@@ -680,11 +683,6 @@
         VkBindImageMemorySwapchainInfoKHR* outputBimsi);
 #endif
 
-    void setMemoryRequirementsForSysmemBackedImage(VkImage image,
-                                               VkMemoryRequirements* pMemoryRequirements);
-
-    void transformImageMemoryRequirementsForGuestLocked(VkImage image, VkMemoryRequirements* reqs);
-
 #if defined(VK_USE_PLATFORM_FUCHSIA)
     VkResult getBufferCollectionImageCreateInfoIndexLocked(
         VkBufferCollectionFUCHSIA collection, fuchsia_sysmem::wire::BufferCollectionInfo2& info,
@@ -722,16 +720,17 @@
         VkPhysicalDeviceMemoryProperties memProps;
         uint32_t apiVersion;
         std::set<std::string> enabledExtensions;
-        std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void*>> deviceMemoryReportCallbacks;
+        std::vector<std::pair<PFN_vkDeviceMemoryReportCallbackEXT, void*>>
+            deviceMemoryReportCallbacks;
     };
 
     struct VkDeviceMemory_Info {
         bool dedicated = false;
         bool imported = false;
 
-    #ifdef VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
         AHardwareBuffer* ahw = nullptr;
-    #endif
+#endif
         zx_handle_t vmoHandle = ZX_HANDLE_INVALID;
         VkDevice device;
 
@@ -743,10 +742,11 @@
         uint64_t coherentMemorySize = 0;
         uint64_t coherentMemoryOffset = 0;
 
-    #if defined(__ANDROID__)
+#if defined(__ANDROID__)
         GoldfishAddressSpaceBlockPtr goldfishBlock = nullptr;
-    #endif  // defined(__ANDROID__)
+#endif  // defined(__ANDROID__)
         CoherentMemoryPtr coherentMemory = nullptr;
+        VirtGpuBlobPtr blobPtr = nullptr;
     };
 
     struct VkCommandBuffer_Info {
@@ -768,14 +768,15 @@
         VkDeviceSize currentBackingSize = 0;
         bool baseRequirementsKnown = false;
         VkMemoryRequirements baseRequirements;
-    #ifdef VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
         bool hasExternalFormat = false;
         unsigned androidFormat = 0;
         std::vector<int> pendingQsriSyncFds;
-    #endif
-    #ifdef VK_USE_PLATFORM_FUCHSIA
+#endif
+#ifdef VK_USE_PLATFORM_FUCHSIA
         bool isSysmemBackedMemory = false;
-    #endif
+#endif
+        bool isWsiImage = false;
     };
 
     struct VkBuffer_Info {
@@ -788,9 +789,9 @@
         VkDeviceSize currentBackingSize = 0;
         bool baseRequirementsKnown = false;
         VkMemoryRequirements baseRequirements;
-    #ifdef VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
         bool isSysmemBackedMemory = false;
-    #endif
+#endif
     };
 
     struct VkSemaphore_Info {
@@ -822,9 +823,9 @@
         VkDevice device;
         bool external = false;
         VkExportFenceCreateInfo exportFenceCreateInfo;
-    #if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
+#if defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(__linux__)
         int syncFd = -1;
-    #endif
+#endif
     };
 
     struct VkDescriptorPool_Info {
@@ -848,26 +849,23 @@
     };
 
     struct VkBufferCollectionFUCHSIA_Info {
-    #ifdef VK_USE_PLATFORM_FUCHSIA
+#ifdef VK_USE_PLATFORM_FUCHSIA
         gfxstream::guest::Optional<fuchsia_sysmem::wire::BufferCollectionConstraints> constraints;
         gfxstream::guest::Optional<VkBufferCollectionPropertiesFUCHSIA> properties;
 
         // the index of corresponding createInfo for each image format
         // constraints in |constraints|.
         std::vector<uint32_t> createInfoIndex;
-    #endif  // VK_USE_PLATFORM_FUCHSIA
+#endif  // VK_USE_PLATFORM_FUCHSIA
     };
 
     VkDescriptorImageInfo filterNonexistentSampler(const VkDescriptorImageInfo& inputInfo);
 
-    void emitDeviceMemoryReport(VkDevice_Info info,
-                                VkDeviceMemoryReportEventTypeEXT type,
-                                uint64_t memoryObjectId,
-                                VkDeviceSize size,
-                                VkObjectType objectType,
-                                uint64_t objectHandle,
-                                uint32_t heapIndex = 0);
+    void emitDeviceMemoryReport(VkDevice_Info info, VkDeviceMemoryReportEventTypeEXT type,
+                                uint64_t memoryObjectId, VkDeviceSize size, VkObjectType objectType,
+                                uint64_t objectHandle, uint32_t heapIndex = 0);
 
+    void transformImageMemoryRequirementsForGuestLocked(VkImage image, VkMemoryRequirements* reqs);
     CoherentMemoryPtr freeCoherentMemoryLocked(VkDeviceMemory memory, VkDeviceMemory_Info& info);
 
     mutable RecursiveLock mLock;
@@ -893,10 +891,9 @@
     fidl::WireSyncClient<fuchsia_sysmem::Allocator> mSysmemAllocator;
 #endif
 
-#define HANDLE_REGISTER_DECLARATION(type)              \
-    std::unordered_map<type, type##_Info> info_##type;
+#define HANDLE_REGISTER_DECLARATION(type) std::unordered_map<type, type##_Info> info_##type;
 
-GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECLARATION)
+    GOLDFISH_VK_LIST_HANDLE_TYPES(HANDLE_REGISTER_DECLARATION)
 
     WorkPool mWorkPool{4};
     std::unordered_map<VkQueue, std::vector<WorkPool::WaitGroupHandle>>
diff --git a/guest/vulkan_enc/Resources.cpp b/guest/vulkan_enc/Resources.cpp
index 00cfd9d..e60e950 100644
--- a/guest/vulkan_enc/Resources.cpp
+++ b/guest/vulkan_enc/Resources.cpp
@@ -19,10 +19,10 @@
 #define GOLDFISH_VK_OBJECT_DEBUG 0
 
 #if GOLDFISH_VK_OBJECT_DEBUG
-#define D(fmt,...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
+#define D(fmt, ...) ALOGD("%s: " fmt, __func__, ##__VA_ARGS__);
 #else
 #ifndef D
-#define D(fmt,...)
+#define D(fmt, ...)
 #endif
 #endif
 
@@ -36,105 +36,103 @@
 #define SET_HWVULKAN_DISPATCH_MAGIC
 #endif
 
-#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL(type) \
-    type new_from_host_##type(type underlying) { \
-        struct goldfish_##type* res = \
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL(type)                   \
+    type new_from_host_##type(type underlying) {                            \
+        struct goldfish_##type* res =                                       \
             static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
-        if (!res) { \
-            ALOGE("FATAL: Failed to alloc " #type " handle"); \
-            abort(); \
-        } \
-        SET_HWVULKAN_DISPATCH_MAGIC \
-        res->underlying = (uint64_t)underlying; \
-        res->lastUsedEncoder = nullptr; \
-        res->sequenceNumber = 0; \
-        res->privateEncoder = 0; \
-        res->privateStream = 0; \
-        res->flags = 0; \
-        res->poolObjects = 0; \
-        res->subObjects = 0; \
-        res->superObjects = 0; \
-        res->userPtr = 0; \
-        return reinterpret_cast<type>(res); \
-    } \
+        if (!res) {                                                         \
+            ALOGE("FATAL: Failed to alloc " #type " handle");               \
+            abort();                                                        \
+        }                                                                   \
+        SET_HWVULKAN_DISPATCH_MAGIC                                         \
+        res->underlying = (uint64_t)underlying;                             \
+        res->lastUsedEncoder = nullptr;                                     \
+        res->sequenceNumber = 0;                                            \
+        res->privateEncoder = 0;                                            \
+        res->privateStream = 0;                                             \
+        res->flags = 0;                                                     \
+        res->poolObjects = 0;                                               \
+        res->subObjects = 0;                                                \
+        res->superObjects = 0;                                              \
+        res->userPtr = 0;                                                   \
+        return reinterpret_cast<type>(res);                                 \
+    }
 
-#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL(type) \
-    type new_from_host_##type(type underlying) { \
-        struct goldfish_##type* res = \
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL(type)       \
+    type new_from_host_##type(type underlying) {                            \
+        struct goldfish_##type* res =                                       \
             static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
-        res->underlying = (uint64_t)underlying; \
-        res->poolObjects = 0; \
-        res->subObjects = 0; \
-        res->superObjects = 0; \
-        res->userPtr = 0; \
-        return reinterpret_cast<type>(res); \
-    } \
+        res->underlying = (uint64_t)underlying;                             \
+        res->poolObjects = 0;                                               \
+        res->subObjects = 0;                                                \
+        res->superObjects = 0;                                              \
+        res->userPtr = 0;                                                   \
+        return reinterpret_cast<type>(res);                                 \
+    }
 
-#define GOLDFISH_VK_AS_GOLDFISH_IMPL(type) \
+#define GOLDFISH_VK_AS_GOLDFISH_IMPL(type)                    \
     struct goldfish_##type* as_goldfish_##type(type toCast) { \
-        return reinterpret_cast<goldfish_##type*>(toCast); \
-    } \
+        return reinterpret_cast<goldfish_##type*>(toCast);    \
+    }
 
-#define GOLDFISH_VK_GET_HOST_IMPL(type) \
-    type get_host_##type(type toUnwrap) { \
-        if (!toUnwrap) return VK_NULL_HANDLE; \
+#define GOLDFISH_VK_GET_HOST_IMPL(type)                  \
+    type get_host_##type(type toUnwrap) {                \
+        if (!toUnwrap) return VK_NULL_HANDLE;            \
         auto as_goldfish = as_goldfish_##type(toUnwrap); \
-        return (type)(as_goldfish->underlying); \
-    } \
+        return (type)(as_goldfish->underlying);          \
+    }
 
-#define GOLDFISH_VK_DELETE_GOLDFISH_IMPL(type) \
+#define GOLDFISH_VK_DELETE_GOLDFISH_IMPL(type)   \
     void delete_goldfish_##type(type toDelete) { \
-        D("guest %p", toDelete); \
-        free(as_goldfish_##type(toDelete)); \
-    } \
+        D("guest %p", toDelete);                 \
+        free(as_goldfish_##type(toDelete));      \
+    }
 
 #define GOLDFISH_VK_IDENTITY_IMPL(type) \
-    type vk_handle_identity_##type(type handle) { \
-        return handle; \
-    } \
+    type vk_handle_identity_##type(type handle) { return handle; }
 
-#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
-    type new_from_host_u64_##type(uint64_t underlying) { \
-        struct goldfish_##type* res = \
+#define GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_U64_IMPL(type)               \
+    type new_from_host_u64_##type(uint64_t underlying) {                    \
+        struct goldfish_##type* res =                                       \
             static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
-        if (!res) { \
-            ALOGE("FATAL: Failed to alloc " #type " handle"); \
-            abort(); \
-        } \
-        SET_HWVULKAN_DISPATCH_MAGIC \
-        res->underlying = underlying; \
-        res->lastUsedEncoder = nullptr; \
-        res->sequenceNumber = 0; \
-        res->privateEncoder = 0; \
-        res->privateStream = 0; \
-        res->flags = 0; \
-        res->poolObjects = 0; \
-        res->subObjects = 0; \
-        res->superObjects = 0; \
-        res->userPtr = 0; \
-        return reinterpret_cast<type>(res); \
-    } \
+        if (!res) {                                                         \
+            ALOGE("FATAL: Failed to alloc " #type " handle");               \
+            abort();                                                        \
+        }                                                                   \
+        SET_HWVULKAN_DISPATCH_MAGIC                                         \
+        res->underlying = underlying;                                       \
+        res->lastUsedEncoder = nullptr;                                     \
+        res->sequenceNumber = 0;                                            \
+        res->privateEncoder = 0;                                            \
+        res->privateStream = 0;                                             \
+        res->flags = 0;                                                     \
+        res->poolObjects = 0;                                               \
+        res->subObjects = 0;                                                \
+        res->superObjects = 0;                                              \
+        res->userPtr = 0;                                                   \
+        return reinterpret_cast<type>(res);                                 \
+    }
 
-#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL(type) \
-    type new_from_host_u64_##type(uint64_t underlying) { \
-        struct goldfish_##type* res = \
-            static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type))); \
-        res->underlying = underlying; \
+#define GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL(type)          \
+    type new_from_host_u64_##type(uint64_t underlying) {                           \
+        struct goldfish_##type* res =                                              \
+            static_cast<goldfish_##type*>(malloc(sizeof(goldfish_##type)));        \
+        res->underlying = underlying;                                              \
         D("guest %p: host u64: 0x%llx", res, (unsigned long long)res->underlying); \
-        res->poolObjects = 0; \
-        res->subObjects = 0; \
-        res->superObjects = 0; \
-        res->userPtr = 0; \
-        return reinterpret_cast<type>(res); \
-    } \
+        res->poolObjects = 0;                                                      \
+        res->subObjects = 0;                                                       \
+        res->superObjects = 0;                                                     \
+        res->userPtr = 0;                                                          \
+        return reinterpret_cast<type>(res);                                        \
+    }
 
-#define GOLDFISH_VK_GET_HOST_U64_IMPL(type) \
-    uint64_t get_host_u64_##type(type toUnwrap) { \
-        if (!toUnwrap) return 0; \
-        auto as_goldfish = as_goldfish_##type(toUnwrap); \
+#define GOLDFISH_VK_GET_HOST_U64_IMPL(type)                                                     \
+    uint64_t get_host_u64_##type(type toUnwrap) {                                               \
+        if (!toUnwrap) return 0;                                                                \
+        auto as_goldfish = as_goldfish_##type(toUnwrap);                                        \
         D("guest %p: host u64: 0x%llx", toUnwrap, (unsigned long long)as_goldfish->underlying); \
-        return as_goldfish->underlying; \
-    } \
+        return as_goldfish->underlying;                                                         \
+    }
 
 GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_DISPATCHABLE_FROM_HOST_IMPL)
 GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_IMPL)
@@ -148,8 +146,10 @@
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_IMPL)
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_IMPL)
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_IMPL)
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL)
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(
+    GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_IMPL)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(
+    GOLDFISH_VK_NEW_TRIVIAL_NON_DISPATCHABLE_FROM_HOST_U64_IMPL)
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DELETE_GOLDFISH_IMPL)
 
 VkDescriptorPool new_from_host_VkDescriptorPool(VkDescriptorPool underlying) {
@@ -177,8 +177,8 @@
 }
 
 VkDescriptorSetLayout new_from_host_VkDescriptorSetLayout(VkDescriptorSetLayout underlying) {
-    struct goldfish_VkDescriptorSetLayout* res =
-        static_cast<goldfish_VkDescriptorSetLayout*>(malloc(sizeof(goldfish_VkDescriptorSetLayout)));
+    struct goldfish_VkDescriptorSetLayout* res = static_cast<goldfish_VkDescriptorSetLayout*>(
+        malloc(sizeof(goldfish_VkDescriptorSetLayout)));
     res->underlying = (uint64_t)underlying;
     res->layoutInfo = nullptr;
     return reinterpret_cast<VkDescriptorSetLayout>(res);
@@ -188,7 +188,7 @@
     return new_from_host_VkDescriptorSetLayout((VkDescriptorSetLayout)underlying);
 }
 
-} // extern "C"
+}  // extern "C"
 
 namespace gfxstream {
 namespace vk {
@@ -199,7 +199,11 @@
     o->next = nullptr;
     o->obj = val;
     D("new ptr: %p", o);
-    if (!*begin) { D("first"); *begin = o; return; }
+    if (!*begin) {
+        D("first");
+        *begin = o;
+        return;
+    }
 
     struct goldfish_vk_object_list* q = *begin;
     struct goldfish_vk_object_list* p = q;
@@ -214,7 +218,7 @@
 }
 
 void eraseObject(struct goldfish_vk_object_list** begin, void* val) {
-        D("for val %p", val);
+    D("for val %p", val);
     if (!*begin) {
         D("val %p notfound", val);
         return;
@@ -241,7 +245,7 @@
         q = n;
     }
 
-        D("val %p notfound after looping", val);
+    D("val %p notfound after looping", val);
 }
 
 void eraseObjects(struct goldfish_vk_object_list** begin) {
diff --git a/guest/vulkan_enc/Resources.h b/guest/vulkan_enc/Resources.h
index 3e48f5c..1166da4 100644
--- a/guest/vulkan_enc/Resources.h
+++ b/guest/vulkan_enc/Resources.h
@@ -18,14 +18,13 @@
 #elif defined(__linux__)
 #include <vulkan/vk_icd.h>
 #endif
+#include <inttypes.h>
 #include <vulkan/vulkan.h>
 
-#include "VulkanHandles.h"
-
-#include <inttypes.h>
-
 #include <functional>
 
+#include "VulkanHandles.h"
+
 namespace gfxstream {
 namespace guest {
 class IOStream;
@@ -41,7 +40,6 @@
 }  // namespace vk
 }  // namespace gfxstream
 
-
 extern "C" {
 
 struct goldfish_vk_object_list {
@@ -58,51 +56,45 @@
 #endif
 
 #define GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT(type) \
-    struct goldfish_##type { \
-        DECLARE_HWVULKAN_DISPATCH \
-        uint64_t underlying; \
-        gfxstream::vk::VkEncoder* lastUsedEncoder; \
-        uint32_t sequenceNumber; \
-        gfxstream::vk::VkEncoder* privateEncoder; \
-        gfxstream::guest::IOStream* privateStream; \
-        uint32_t flags; \
-        struct goldfish_vk_object_list* poolObjects; \
-        struct goldfish_vk_object_list* subObjects; \
-        struct goldfish_vk_object_list* superObjects; \
-        void* userPtr; \
-    }; \
+    struct goldfish_##type {                                \
+        DECLARE_HWVULKAN_DISPATCH                           \
+        uint64_t underlying;                                \
+        gfxstream::vk::VkEncoder* lastUsedEncoder;          \
+        uint32_t sequenceNumber;                            \
+        gfxstream::vk::VkEncoder* privateEncoder;           \
+        gfxstream::guest::IOStream* privateStream;          \
+        uint32_t flags;                                     \
+        struct goldfish_vk_object_list* poolObjects;        \
+        struct goldfish_vk_object_list* subObjects;         \
+        struct goldfish_vk_object_list* superObjects;       \
+        void* userPtr;                                      \
+    };
 
 #define GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT(type) \
-    struct goldfish_##type { \
-        uint64_t underlying; \
-        struct goldfish_vk_object_list* poolObjects; \
-        struct goldfish_vk_object_list* subObjects; \
-        struct goldfish_vk_object_list* superObjects; \
-        void* userPtr; \
-    }; \
+    struct goldfish_##type {                                            \
+        uint64_t underlying;                                            \
+        struct goldfish_vk_object_list* poolObjects;                    \
+        struct goldfish_vk_object_list* subObjects;                     \
+        struct goldfish_vk_object_list* superObjects;                   \
+        void* userPtr;                                                  \
+    };
 
-#define GOLDFISH_VK_NEW_FROM_HOST_DECL(type) \
-    type new_from_host_##type(type);
+#define GOLDFISH_VK_NEW_FROM_HOST_DECL(type) type new_from_host_##type(type);
 
-#define GOLDFISH_VK_AS_GOLDFISH_DECL(type) \
-    struct goldfish_##type* as_goldfish_##type(type);
+#define GOLDFISH_VK_AS_GOLDFISH_DECL(type) struct goldfish_##type* as_goldfish_##type(type);
 
-#define GOLDFISH_VK_GET_HOST_DECL(type) \
-    type get_host_##type(type);
+#define GOLDFISH_VK_GET_HOST_DECL(type) type get_host_##type(type);
 
-#define GOLDFISH_VK_DELETE_GOLDFISH_DECL(type) \
-    void delete_goldfish_##type(type);
+#define GOLDFISH_VK_DELETE_GOLDFISH_DECL(type) void delete_goldfish_##type(type);
 
-#define GOLDFISH_VK_IDENTITY_DECL(type) \
-    type vk_handle_identity_##type(type);
+#define GOLDFISH_VK_IDENTITY_DECL(type) type vk_handle_identity_##type(type);
 
-#define GOLDFISH_VK_NEW_FROM_HOST_U64_DECL(type) \
-    type new_from_host_u64_##type(uint64_t);
+#define GOLDFISH_VK_NEW_FROM_HOST_U64_DECL(type) type new_from_host_u64_##type(uint64_t);
 
-#define GOLDFISH_VK_GET_HOST_U64_DECL(type) \
-    uint64_t get_host_u64_##type(type);
+#define GOLDFISH_VK_GET_HOST_U64_DECL(type) uint64_t get_host_u64_##type(type);
 
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(
+    GOLDFISH_VK_DEFINE_DISPATCHABLE_HANDLE_STRUCT)
 GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_DECL)
 GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_AS_GOLDFISH_DECL)
 GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_DECL)
@@ -118,7 +110,8 @@
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_IDENTITY_DECL)
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_NEW_FROM_HOST_U64_DECL)
 GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_GET_HOST_U64_DECL)
-GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT)
+GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(
+    GOLDFISH_VK_DEFINE_TRIVIAL_NON_DISPATCHABLE_HANDLE_STRUCT)
 
 struct goldfish_VkDescriptorPool {
     uint64_t underlying;
@@ -151,7 +144,7 @@
     VkDevice device;
 };
 
-} // extern "C"
+}  // extern "C"
 
 namespace gfxstream {
 namespace vk {
diff --git a/guest/vulkan_enc/Validation.cpp b/guest/vulkan_enc/Validation.cpp
index 3b75786..00652fc 100644
--- a/guest/vulkan_enc/Validation.cpp
+++ b/guest/vulkan_enc/Validation.cpp
@@ -13,19 +13,15 @@
 // limitations under the License.
 #include "Validation.h"
 
-#include "Resources.h"
 #include "ResourceTracker.h"
+#include "Resources.h"
 
 namespace gfxstream {
 namespace vk {
 
-VkResult Validation::on_vkFlushMappedMemoryRanges(
-    void*,
-    VkResult,
-    VkDevice,
-    uint32_t memoryRangeCount,
-    const VkMappedMemoryRange* pMemoryRanges) {
-
+VkResult Validation::on_vkFlushMappedMemoryRanges(void*, VkResult, VkDevice,
+                                                  uint32_t memoryRangeCount,
+                                                  const VkMappedMemoryRange* pMemoryRanges) {
     auto resources = ResourceTracker::get();
 
     for (uint32_t i = 0; i < memoryRangeCount; ++i) {
@@ -37,13 +33,9 @@
     return VK_SUCCESS;
 }
 
-VkResult Validation::on_vkInvalidateMappedMemoryRanges(
-    void*,
-    VkResult,
-    VkDevice,
-    uint32_t memoryRangeCount,
-    const VkMappedMemoryRange* pMemoryRanges) {
-
+VkResult Validation::on_vkInvalidateMappedMemoryRanges(void*, VkResult, VkDevice,
+                                                       uint32_t memoryRangeCount,
+                                                       const VkMappedMemoryRange* pMemoryRanges) {
     auto resources = ResourceTracker::get();
 
     for (uint32_t i = 0; i < memoryRangeCount; ++i) {
diff --git a/guest/vulkan_enc/Validation.h b/guest/vulkan_enc/Validation.h
index 0dfd2d3..e4ebc5f 100644
--- a/guest/vulkan_enc/Validation.h
+++ b/guest/vulkan_enc/Validation.h
@@ -19,19 +19,13 @@
 namespace vk {
 
 class Validation {
-public:
-    VkResult on_vkFlushMappedMemoryRanges(
-        void* context,
-        VkResult input_result,
-        VkDevice device,
-        uint32_t memoryRangeCount,
-        const VkMappedMemoryRange* pMemoryRanges);
-    VkResult on_vkInvalidateMappedMemoryRanges(
-        void* context,
-        VkResult input_result,
-        VkDevice device,
-        uint32_t memoryRangeCount,
-        const VkMappedMemoryRange* pMemoryRanges);
+   public:
+    VkResult on_vkFlushMappedMemoryRanges(void* context, VkResult input_result, VkDevice device,
+                                          uint32_t memoryRangeCount,
+                                          const VkMappedMemoryRange* pMemoryRanges);
+    VkResult on_vkInvalidateMappedMemoryRanges(void* context, VkResult input_result,
+                                               VkDevice device, uint32_t memoryRangeCount,
+                                               const VkMappedMemoryRange* pMemoryRanges);
 };
 
 }  // namespace vk
diff --git a/guest/vulkan_enc/VkEncoder.cpp b/guest/vulkan_enc/VkEncoder.cpp
index a3b2ddd..c9ef5c4 100644
--- a/guest/vulkan_enc/VkEncoder.cpp
+++ b/guest/vulkan_enc/VkEncoder.cpp
@@ -33178,6 +33178,8 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -39161,6 +39163,8 @@
 #endif
 #ifdef VK_EXT_image_compression_control_swapchain
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/VkEncoder.h b/guest/vulkan_enc/VkEncoder.h
index 794db47..5a40b30 100644
--- a/guest/vulkan_enc/VkEncoder.h
+++ b/guest/vulkan_enc/VkEncoder.h
@@ -919,6 +919,8 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -1133,6 +1135,8 @@
 #endif
 #ifdef VK_EXT_image_compression_control_swapchain
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
    private:
     class Impl;
diff --git a/guest/vulkan_enc/VulkanHandleMapping.cpp b/guest/vulkan_enc/VulkanHandleMapping.cpp
index 068e666..1b5c6a6 100644
--- a/guest/vulkan_enc/VulkanHandleMapping.cpp
+++ b/guest/vulkan_enc/VulkanHandleMapping.cpp
@@ -12,24 +12,29 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-#include <vulkan/vulkan.h>
-
 #include "VulkanHandleMapping.h"
 
+#include <vulkan/vulkan.h>
+
 namespace gfxstream {
 namespace vk {
 
-#define DEFAULT_HANDLE_MAP_DEFINE(type) \
-void DefaultHandleMapping::mapHandles_##type(type*, size_t) { return; } \
-void DefaultHandleMapping::mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) { \
-    for (size_t i = 0; i < count; ++i) { handle_u64s[i] = (uint64_t)(uintptr_t)handles[i]; } \
-} \
-void DefaultHandleMapping::mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) { \
-    for (size_t i = 0; i < count; ++i) { handles[i] = (type)(uintptr_t)handle_u64s[i]; } \
-} \
+#define DEFAULT_HANDLE_MAP_DEFINE(type)                                                            \
+    void DefaultHandleMapping::mapHandles_##type(type*, size_t) { return; }                        \
+    void DefaultHandleMapping::mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, \
+                                                       size_t count) {                             \
+        for (size_t i = 0; i < count; ++i) {                                                       \
+            handle_u64s[i] = (uint64_t)(uintptr_t)handles[i];                                      \
+        }                                                                                          \
+    }                                                                                              \
+    void DefaultHandleMapping::mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles,   \
+                                                     size_t count) {                               \
+        for (size_t i = 0; i < count; ++i) {                                                       \
+            handles[i] = (type)(uintptr_t)handle_u64s[i];                                          \
+        }                                                                                          \
+    }
 
 GOLDFISH_VK_LIST_HANDLE_TYPES(DEFAULT_HANDLE_MAP_DEFINE)
 
 }  // namespace vk
 }  // namespace gfxstream
-
diff --git a/guest/vulkan_enc/VulkanHandleMapping.h b/guest/vulkan_enc/VulkanHandleMapping.h
index 7c7fdbc..08c229e 100644
--- a/guest/vulkan_enc/VulkanHandleMapping.h
+++ b/guest/vulkan_enc/VulkanHandleMapping.h
@@ -22,26 +22,29 @@
 namespace vk {
 
 class VulkanHandleMapping {
-public:
+   public:
     VulkanHandleMapping() = default;
-    virtual ~VulkanHandleMapping() { }
+    virtual ~VulkanHandleMapping() {}
 
-#define DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD(type) \
-    virtual void mapHandles_##type(type* handles, size_t count = 1) = 0; \
-    virtual void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count = 1) = 0; \
-    virtual void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count = 1) = 0; \
+#define DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD(type)                                 \
+    virtual void mapHandles_##type(type* handles, size_t count = 1) = 0;             \
+    virtual void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, \
+                                         size_t count = 1) = 0;                      \
+    virtual void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles,   \
+                                       size_t count = 1) = 0;
 
     GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_PURE_VIRTUAL_METHOD)
 };
 
 class DefaultHandleMapping : public VulkanHandleMapping {
-public:
-    virtual ~DefaultHandleMapping() { }
+   public:
+    virtual ~DefaultHandleMapping() {}
 
-#define DECLARE_HANDLE_MAP_OVERRIDE(type) \
-    void mapHandles_##type(type* handles, size_t count) override; \
-    void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) override; \
-    void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) override; \
+#define DECLARE_HANDLE_MAP_OVERRIDE(type)                                                  \
+    void mapHandles_##type(type* handles, size_t count) override;                          \
+    void mapHandles_##type##_u64(const type* handles, uint64_t* handle_u64s, size_t count) \
+        override;                                                                          \
+    void mapHandles_u64_##type(const uint64_t* handle_u64s, type* handles, size_t count) override;
 
     GOLDFISH_VK_LIST_HANDLE_TYPES(DECLARE_HANDLE_MAP_OVERRIDE)
 };
diff --git a/guest/vulkan_enc/VulkanHandles.h b/guest/vulkan_enc/VulkanHandles.h
index cdec839..1be4d70 100644
--- a/guest/vulkan_enc/VulkanHandles.h
+++ b/guest/vulkan_enc/VulkanHandles.h
@@ -19,77 +19,75 @@
 namespace gfxstream {
 namespace vk {
 
-#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkPhysicalDevice) \
+#define GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) f(VkPhysicalDevice)
 
 #define GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkInstance) \
-    f(VkDevice) \
-    f(VkCommandBuffer) \
-    f(VkQueue) \
+    f(VkInstance)                                     \
+    f(VkDevice)                                       \
+    f(VkCommandBuffer)                                \
+    f(VkQueue)                                        \
     GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
 
 #ifdef VK_NVX_binary_import
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f) \
-    f(VkCuModuleNVX) \
-    f(VkCuFunctionNVX) \
+    f(VkCuModuleNVX)                                                          \
+    f(VkCuFunctionNVX)
 
 #else
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f)
 
-#endif // VK_NVX_binary_import
+#endif  // VK_NVX_binary_import
 
 #ifdef VK_NVX_device_generated_commands
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_DEVICE_GENERATED_COMMANDS(f) \
-    f(VkObjectTableNVX) \
-    f(VkIndirectCommandsLayoutNVX) \
+    f(VkObjectTableNVX)                                                                   \
+    f(VkIndirectCommandsLayoutNVX)
 
 #else
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_DEVICE_GENERATED_COMMANDS(f)
 
-#endif // VK_NVX_device_generated_commands
+#endif  // VK_NVX_device_generated_commands
 
 #ifdef VK_NV_device_generated_commands
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f) \
-    f(VkIndirectCommandsLayoutNV) \
+    f(VkIndirectCommandsLayoutNV)
 
 #else
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f)
 
-#endif // VK_NV_device_generated_commands
+#endif  // VK_NV_device_generated_commands
 
 #ifdef VK_NV_ray_tracing
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f) \
-    f(VkAccelerationStructureNV) \
+    f(VkAccelerationStructureNV)
 
 #else
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f)
 
-#endif // VK_NV_ray_tracing
+#endif  // VK_NV_ray_tracing
 
 #ifdef VK_KHR_acceleration_structure
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f) \
-    f(VkAccelerationStructureKHR) \
+    f(VkAccelerationStructureKHR)
 
 #else
 
 #define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f)
 
-#endif // VK_KHR_acceleration_structure
+#endif  // VK_KHR_acceleration_structure
 
 #ifdef VK_USE_PLATFORM_FUCHSIA
 
-#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
-    f(VkBufferCollectionFUCHSIA)
+#define __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) f(VkBufferCollectionFUCHSIA)
 
 #else
 
@@ -97,77 +95,77 @@
 
 #endif  // VK_USE_PLATFORM_FUCHSIA
 
-#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkBufferView) \
-    f(VkImageView) \
-    f(VkShaderModule) \
-    f(VkPipeline) \
-    f(VkPipelineCache) \
-    f(VkPipelineLayout) \
-    f(VkRenderPass) \
-    f(VkFramebuffer) \
-    f(VkEvent) \
-    f(VkQueryPool) \
-    f(VkSamplerYcbcrConversion) \
-    f(VkSurfaceKHR) \
-    f(VkSwapchainKHR) \
-    f(VkDisplayKHR) \
-    f(VkDisplayModeKHR) \
-    f(VkValidationCacheEXT) \
-    f(VkDebugReportCallbackEXT) \
-    f(VkDebugUtilsMessengerEXT) \
-    f(VkMicromapEXT) \
-    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f) \
+#define GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)                     \
+    f(VkBufferView)                                                                   \
+    f(VkImageView)                                                                    \
+    f(VkShaderModule)                                                                 \
+    f(VkPipeline)                                                                     \
+    f(VkPipelineCache)                                                                \
+    f(VkPipelineLayout)                                                               \
+    f(VkRenderPass)                                                                   \
+    f(VkFramebuffer)                                                                  \
+    f(VkEvent)                                                                        \
+    f(VkQueryPool)                                                                    \
+    f(VkSamplerYcbcrConversion)                                                       \
+    f(VkSurfaceKHR)                                                                   \
+    f(VkSwapchainKHR)                                                                 \
+    f(VkDisplayKHR)                                                                   \
+    f(VkDisplayModeKHR)                                                               \
+    f(VkValidationCacheEXT)                                                           \
+    f(VkDebugReportCallbackEXT)                                                       \
+    f(VkDebugUtilsMessengerEXT)                                                       \
+    f(VkMicromapEXT)                                                                  \
+    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_BINARY_IMPORT(f)             \
     __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NVX_DEVICE_GENERATED_COMMANDS(f) \
-    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f) \
-    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f) \
-    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f) \
+    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_DEVICE_GENERATED_COMMANDS(f)  \
+    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_NV_RAY_TRACING(f)                \
+    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_KHR_ACCELERATION_STRUCTURE(f)
 
-#define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkDeviceMemory) \
-    f(VkBuffer) \
-    f(VkImage) \
-    f(VkSemaphore) \
-    f(VkDescriptorUpdateTemplate) \
-    f(VkFence) \
-    f(VkDescriptorPool) \
-    f(VkDescriptorSet) \
-    f(VkDescriptorSetLayout) \
-    f(VkCommandPool) \
-    f(VkSampler) \
+#define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f)       \
+    f(VkDeviceMemory)                                           \
+    f(VkBuffer)                                                 \
+    f(VkImage)                                                  \
+    f(VkSemaphore)                                              \
+    f(VkDescriptorUpdateTemplate)                               \
+    f(VkFence)                                                  \
+    f(VkDescriptorPool)                                         \
+    f(VkDescriptorSet)                                          \
+    f(VkDescriptorSetLayout)                                    \
+    f(VkCommandPool)                                            \
+    f(VkSampler)                                                \
     __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
-    GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+    GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
 
-#define GOLDFISH_VK_LIST_HANDLE_TYPES(f) \
+#define GOLDFISH_VK_LIST_HANDLE_TYPES(f)          \
     GOLDFISH_VK_LIST_DISPATCHABLE_HANDLE_TYPES(f) \
     GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f)
 
-#define GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(f) \
+#define GOLDFISH_VK_LIST_TRIVIAL_HANDLE_TYPES(f)          \
     GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f) \
     GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
 
 #define GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkInstance) \
-    f(VkDevice) \
-    f(VkQueue) \
+    f(VkInstance)                                                        \
+    f(VkDevice)                                                          \
+    f(VkQueue)                                                           \
     GOLDFISH_VK_LIST_TRIVIAL_DISPATCHABLE_HANDLE_TYPES(f)
 
 #define GOLDFISH_VK_LIST_AUTODEFINED_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkDeviceMemory) \
-    f(VkBuffer) \
-    f(VkImage) \
-    f(VkSemaphore) \
-    f(VkFence) \
-    f(VkDescriptorUpdateTemplate) \
-    f(VkCommandPool) \
-    f(VkSampler) \
-    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f) \
-    GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f) \
+    f(VkDeviceMemory)                                                        \
+    f(VkBuffer)                                                              \
+    f(VkImage)                                                               \
+    f(VkSemaphore)                                                           \
+    f(VkFence)                                                               \
+    f(VkDescriptorUpdateTemplate)                                            \
+    f(VkCommandPool)                                                         \
+    f(VkSampler)                                                             \
+    __GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES_FUCHSIA(f)              \
+    GOLDFISH_VK_LIST_TRIVIAL_NON_DISPATCHABLE_HANDLE_TYPES(f)
 
 #define GOLDFISH_VK_LIST_MANUAL_STRUCT_NON_DISPATCHABLE_HANDLE_TYPES(f) \
-    f(VkDescriptorPool) \
-    f(VkDescriptorSetLayout) \
-    f(VkDescriptorSet) \
+    f(VkDescriptorPool)                                                 \
+    f(VkDescriptorSetLayout)                                            \
+    f(VkDescriptorSet)
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/VulkanStreamGuest.cpp b/guest/vulkan_enc/VulkanStreamGuest.cpp
index 459da45..53d4ad5 100644
--- a/guest/vulkan_enc/VulkanStreamGuest.cpp
+++ b/guest/vulkan_enc/VulkanStreamGuest.cpp
@@ -16,16 +16,14 @@
 namespace gfxstream {
 namespace vk {
 
-VulkanStreamGuest::VulkanStreamGuest(gfxstream::guest::IOStream *stream): mStream(stream) {
+VulkanStreamGuest::VulkanStreamGuest(gfxstream::guest::IOStream* stream) : mStream(stream) {
     unsetHandleMapping();
     mFeatureBits = ResourceTracker::get()->getStreamFeatures();
 }
 
 VulkanStreamGuest::~VulkanStreamGuest() = default;
 
-bool VulkanStreamGuest::valid() {
-    return true;
-}
+bool VulkanStreamGuest::valid() { return true; }
 
 void VulkanStreamGuest::alloc(void** ptrAddr, size_t bytes) {
     if (!bytes) {
@@ -56,7 +54,7 @@
 
     alloc((void**)forOutput, count * sizeof(char*));
 
-    char **stringsForOutput = *forOutput;
+    char** stringsForOutput = *forOutput;
 
     for (size_t i = 0; i < count; i++) {
         loadStringInPlace(stringsForOutput + i);
@@ -79,8 +77,9 @@
     }
 }
 
-void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput, uint8_t** streamPtr) {
- uint32_t count;
+void VulkanStreamGuest::loadStringArrayInPlaceWithStreamPtr(char*** forOutput,
+                                                            uint8_t** streamPtr) {
+    uint32_t count;
     memcpy(&count, *streamPtr, sizeof(uint32_t));
     *streamPtr += sizeof(uint32_t);
     gfxstream::guest::Stream::fromBe32((uint8_t*)&count);
@@ -91,15 +90,14 @@
 
     alloc((void**)forOutput, count * sizeof(char*));
 
-    char **stringsForOutput = *forOutput;
+    char** stringsForOutput = *forOutput;
 
     for (size_t i = 0; i < count; i++) {
         loadStringInPlaceWithStreamPtr(stringsForOutput + i, streamPtr);
     }
 }
 
-
-ssize_t VulkanStreamGuest::read(void *buffer, size_t size) {
+ssize_t VulkanStreamGuest::read(void* buffer, size_t size) {
     if (!mStream->readback(buffer, size)) {
         ALOGE("FATAL: Could not read back %zu bytes", size);
         abort();
@@ -107,7 +105,7 @@
     return size;
 }
 
-ssize_t VulkanStreamGuest::write(const void *buffer, size_t size) {
+ssize_t VulkanStreamGuest::write(const void* buffer, size_t size) {
     uint8_t* streamBuf = (uint8_t*)mStream->alloc(size);
     memcpy(streamBuf, buffer, size);
     return size;
@@ -117,44 +115,30 @@
     mStream->writeFullyAsync(buffer, size);
 }
 
-void VulkanStreamGuest::clearPool() {
-    mPool.freeAll();
-}
+void VulkanStreamGuest::clearPool() { mPool.freeAll(); }
 
 void VulkanStreamGuest::setHandleMapping(VulkanHandleMapping* mapping) {
     mCurrentHandleMapping = mapping;
 }
 
-void VulkanStreamGuest::unsetHandleMapping() {
-    mCurrentHandleMapping = &mDefaultHandleMapping;
-}
+void VulkanStreamGuest::unsetHandleMapping() { mCurrentHandleMapping = &mDefaultHandleMapping; }
 
-VulkanHandleMapping* VulkanStreamGuest::handleMapping() const {
-    return mCurrentHandleMapping;
-}
+VulkanHandleMapping* VulkanStreamGuest::handleMapping() const { return mCurrentHandleMapping; }
 
 void VulkanStreamGuest::flush() {
     AEMU_SCOPED_TRACE("VulkanStreamGuest device write");
     mStream->flush();
 }
 
-uint32_t VulkanStreamGuest::getFeatureBits() const {
-    return mFeatureBits;
-}
+uint32_t VulkanStreamGuest::getFeatureBits() const { return mFeatureBits; }
 
-void VulkanStreamGuest::incStreamRef() {
-    mStream->incRef();
-}
+void VulkanStreamGuest::incStreamRef() { mStream->incRef(); }
 
-bool VulkanStreamGuest::decStreamRef() {
-    return mStream->decRef();
-}
+bool VulkanStreamGuest::decStreamRef() { return mStream->decRef(); }
 
-uint8_t* VulkanStreamGuest::reserve(size_t size) {
-    return (uint8_t*)mStream->alloc(size);
-}
+uint8_t* VulkanStreamGuest::reserve(size_t size) { return (uint8_t*)mStream->alloc(size); }
 
-VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) { }
+VulkanCountingStream::VulkanCountingStream() : VulkanStreamGuest(nullptr) {}
 VulkanCountingStream::~VulkanCountingStream() = default;
 
 ssize_t VulkanCountingStream::read(void*, size_t size) {
diff --git a/guest/vulkan_enc/VulkanStreamGuest.h b/guest/vulkan_enc/VulkanStreamGuest.h
index ae995e1..92052af 100644
--- a/guest/vulkan_enc/VulkanStreamGuest.h
+++ b/guest/vulkan_enc/VulkanStreamGuest.h
@@ -13,30 +13,26 @@
 // limitations under the License.
 #pragma once
 
-#include "aemu/base/files/Stream.h"
-#include "aemu/base/files/StreamSerializing.h"
+#include <inttypes.h>
+#include <log/log.h>
 
-#include "goldfish_vk_private_defs.h"
-
-#include "VulkanHandleMapping.h"
+#include <memory>
+#include <vector>
 
 #include "gfxstream/guest/IOStream.h"
 #include "ResourceTracker.h"
-
+#include "VulkanHandleMapping.h"
 #include "aemu/base/BumpPool.h"
 #include "aemu/base/Tracing.h"
-
-#include <vector>
-#include <memory>
-
-#include <log/log.h>
-#include <inttypes.h>
+#include "aemu/base/files/Stream.h"
+#include "aemu/base/files/StreamSerializing.h"
+#include "goldfish_vk_private_defs.h"
 
 namespace gfxstream {
 namespace vk {
 
 class VulkanStreamGuest : public gfxstream::guest::Stream {
-public:
+   public:
     VulkanStreamGuest(gfxstream::guest::IOStream* stream);
     ~VulkanStreamGuest();
 
@@ -55,8 +51,8 @@
     void loadStringInPlaceWithStreamPtr(char** forOutput, uint8_t** streamPtr);
     void loadStringArrayInPlaceWithStreamPtr(char*** forOutput, uint8_t** streamPtr);
 
-    ssize_t read(void *buffer, size_t size) override;
-    ssize_t write(const void *buffer, size_t size) override;
+    ssize_t read(void* buffer, size_t size) override;
+    ssize_t write(const void* buffer, size_t size) override;
 
     void writeLarge(const void* buffer, size_t size);
 
@@ -75,7 +71,8 @@
     bool decStreamRef();
 
     uint8_t* reserve(size_t size);
-private:
+
+   private:
     gfxstream::guest::BumpPool mPool;
     std::vector<uint8_t> mWriteBuffer;
     gfxstream::guest::IOStream* mStream = nullptr;
@@ -85,18 +82,19 @@
 };
 
 class VulkanCountingStream : public VulkanStreamGuest {
-public:
+   public:
     VulkanCountingStream();
     ~VulkanCountingStream();
 
-    ssize_t read(void *buffer, size_t size) override;
-    ssize_t write(const void *buffer, size_t size) override;
+    ssize_t read(void* buffer, size_t size) override;
+    ssize_t write(const void* buffer, size_t size) override;
 
     size_t bytesWritten() const { return m_written; }
     size_t bytesRead() const { return m_read; }
 
     void rewind();
-private:
+
+   private:
     size_t m_written = 0;
     size_t m_read = 0;
 };
diff --git a/guest/vulkan_enc/func_table.cpp b/guest/vulkan_enc/func_table.cpp
index e05ac1e..c4408c3 100644
--- a/guest/vulkan_enc/func_table.cpp
+++ b/guest/vulkan_enc/func_table.cpp
@@ -30,8 +30,6 @@
 // $CEREAL_OUTPUT_DIR
 //
 
-#include "func_table.h"
-
 #include <log/log.h>
 
 #include <cstring>
@@ -39,6 +37,8 @@
 #include "../OpenglSystemCommon/HostConnection.h"
 #include "ResourceTracker.h"
 #include "VkEncoder.h"
+#include "gfxstream_vk_entrypoints.h"
+#include "gfxstream_vk_private.h"
 #include "goldfish_vk_private_defs.h"
 
 // Stuff we are not going to use but if included,
@@ -49,2119 +49,3668 @@
 #if defined(LINUX_GUEST_BUILD) || defined(__Fuchsia__)
 #undef VK_ANDROID_native_buffer
 #endif
-
-namespace gfxstream {
-namespace vk {
-
-static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature) {
-    ALOGE("invalid call to %s: %s not supported", apiname, neededFeature);
-    abort();
-}
 #ifdef VK_VERSION_1_0
-static VkResult entry_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
-                                       const VkAllocationCallbacks* pAllocator,
-                                       VkInstance* pInstance) {
-    AEMU_SCOPED_TRACE("vkCreateInstance");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateInstance_VkResult_return = (VkResult)0;
-    vkCreateInstance_VkResult_return =
-        vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
-    return vkCreateInstance_VkResult_return;
-}
-static void entry_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
-    AEMU_SCOPED_TRACE("vkDestroyInstance");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyInstance(instance, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkEnumeratePhysicalDevices(VkInstance instance,
-                                                 uint32_t* pPhysicalDeviceCount,
-                                                 VkPhysicalDevice* pPhysicalDevices) {
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(
-        vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
-    return vkEnumeratePhysicalDevices_VkResult_return;
-}
-static void entry_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
-                                              VkPhysicalDeviceFeatures* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
+                                            VkPhysicalDeviceFeatures* pFeatures) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceFeatures(gfxstream_physicalDevice->internal_object, pFeatures,
+                                           true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
-                                                      VkFormat format,
-                                                      VkFormatProperties* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
+                                                    VkFormat format,
+                                                    VkFormatProperties* pFormatProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties,
-                                               true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceFormatProperties(gfxstream_physicalDevice->internal_object,
+                                                   format, pFormatProperties, true /* do lock */);
+    }
 }
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties(
     VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
     VkImageUsageFlags usage, VkImageCreateFlags flags,
     VkImageFormatProperties* pImageFormatProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
-    vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
-        vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage,
-                                                        flags, pImageFormatProperties,
-                                                        true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
+            vkEnc->vkGetPhysicalDeviceImageFormatProperties(
+                gfxstream_physicalDevice->internal_object, format, type, tiling, usage, flags,
+                pImageFormatProperties, true /* do lock */);
+    }
     return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
 }
-static void entry_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
-                                                VkPhysicalDeviceProperties* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
+                                              VkPhysicalDeviceProperties* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceProperties(gfxstream_physicalDevice->internal_object, pProperties,
+                                             true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties* pQueueFamilyProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
-                                                    pQueueFamilyProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(gfxstream_physicalDevice->internal_object,
+                                                        pQueueFamilyPropertyCount,
+                                                        pQueueFamilyProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceMemoryProperties(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties(
     VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties,
-                                               true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceMemoryProperties(gfxstream_physicalDevice->internal_object,
+                                                   pMemoryProperties, true /* do lock */);
+    }
 }
-static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
-    AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
-    vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
-        vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
-    return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
-}
-static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
-    AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
-    vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
-        vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
-    return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
-}
-static VkResult entry_vkCreateDevice(VkPhysicalDevice physicalDevice,
-                                     const VkDeviceCreateInfo* pCreateInfo,
-                                     const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
-    AEMU_SCOPED_TRACE("vkCreateDevice");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateDevice_VkResult_return = (VkResult)0;
-    vkCreateDevice_VkResult_return =
-        vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
-    return vkCreateDevice_VkResult_return;
-}
-static void entry_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
-    AEMU_SCOPED_TRACE("vkDestroyDevice");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyDevice(device, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkEnumerateInstanceExtensionProperties(const char* pLayerName,
-                                                             uint32_t* pPropertyCount,
-                                                             VkExtensionProperties* pProperties) {
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkEnumerateInstanceExtensionProperties_VkResult_return =
-        resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName,
-                                                             pPropertyCount, pProperties);
-    return vkEnumerateInstanceExtensionProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
-                                                           const char* pLayerName,
-                                                           uint32_t* pPropertyCount,
-                                                           VkExtensionProperties* pProperties) {
-    AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkEnumerateDeviceExtensionProperties_VkResult_return =
-        resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice,
-                                                           pLayerName, pPropertyCount, pProperties);
-    return vkEnumerateDeviceExtensionProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
-                                                         VkLayerProperties* pProperties) {
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
-    vkEnumerateInstanceLayerProperties_VkResult_return =
-        vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
-    return vkEnumerateInstanceLayerProperties_VkResult_return;
-}
-static VkResult entry_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
-                                                       uint32_t* pPropertyCount,
-                                                       VkLayerProperties* pProperties) {
+VkResult gfxstream_vk_EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
+                                                     uint32_t* pPropertyCount,
+                                                     VkLayerProperties* pProperties) {
     AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
-    vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
-        physicalDevice, pPropertyCount, pProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
+            gfxstream_physicalDevice->internal_object, pPropertyCount, pProperties,
+            true /* do lock */);
+    }
     return vkEnumerateDeviceLayerProperties_VkResult_return;
 }
-static void entry_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
-                                   VkQueue* pQueue) {
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, true /* do lock */);
-}
-static VkResult entry_vkQueueSubmit(VkQueue queue, uint32_t submitCount,
-                                    const VkSubmitInfo* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
+                                  VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueSubmit");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
     VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkQueueSubmit_VkResult_return =
-        resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
+        std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
+        std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
+        std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
+        for (uint32_t i = 0; i < submitCount; ++i) {
+            internal_pSubmits[i] = pSubmits[i];
+            /* VkSubmitInfo::pWaitSemaphores */
+            internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+                internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
+            internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
+            internal_pSubmits[i].waitSemaphoreCount =
+                internal_VkSubmitInfo_pWaitSemaphores[i].size();
+            /* VkSubmitInfo::pCommandBuffers */
+            internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
+            internal_VkSubmitInfo_pCommandBuffers[i].reserve(
+                internal_pSubmits[i].commandBufferCount);
+            memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
+                   sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
+            for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
+                VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+                               internal_pSubmits[i].pCommandBuffers[j]);
+                internal_VkSubmitInfo_pCommandBuffers[i][j] =
+                    gfxstream_pCommandBuffers->internal_object;
+            }
+            internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
+            /* VkSubmitInfo::pSignalSemaphores */
+            internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
+                internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
+            internal_pSubmits[i].pSignalSemaphores =
+                internal_VkSubmitInfo_pSignalSemaphores[i].data();
+            internal_pSubmits[i].signalSemaphoreCount =
+                internal_VkSubmitInfo_pSignalSemaphores[i].size();
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(
+            vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
+            internal_pSubmits.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
+    }
     return vkQueueSubmit_VkResult_return;
 }
-static VkResult entry_vkQueueWaitIdle(VkQueue queue) {
+VkResult gfxstream_vk_QueueWaitIdle(VkQueue queue) {
     AEMU_SCOPED_TRACE("vkQueueWaitIdle");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
     VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkQueueWaitIdle_VkResult_return =
+            resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, gfxstream_queue->internal_object);
+    }
     return vkQueueWaitIdle_VkResult_return;
 }
-static VkResult entry_vkDeviceWaitIdle(VkDevice device) {
+VkResult gfxstream_vk_DeviceWaitIdle(VkDevice device) {
     AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
-    vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkDeviceWaitIdle_VkResult_return =
+            vkEnc->vkDeviceWaitIdle(gfxstream_device->internal_object, true /* do lock */);
+    }
     return vkDeviceWaitIdle_VkResult_return;
 }
-static VkResult entry_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
-                                       const VkAllocationCallbacks* pAllocator,
-                                       VkDeviceMemory* pMemory) {
-    AEMU_SCOPED_TRACE("vkAllocateMemory");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
-        vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
-    return vkAllocateMemory_VkResult_return;
-}
-static void entry_vkFreeMemory(VkDevice device, VkDeviceMemory memory,
-                               const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_FreeMemory(VkDevice device, VkDeviceMemory memory,
+                             const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkFreeMemory");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
+    if (VK_NULL_HANDLE == memory) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkFreeMemory(
+            vkEnc, gfxstream_device->internal_object,
+            gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator);
+    }
+    vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
 }
-static VkResult entry_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
-                                  VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+VkResult gfxstream_vk_MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
+                                VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
     AEMU_SCOPED_TRACE("vkMapMemory");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkMapMemory_VkResult_return = (VkResult)0;
-    vkMapMemory_VkResult_return =
-        vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkMapMemory_VkResult_return =
+            vkEnc->vkMapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
+                               offset, size, flags, ppData, true /* do lock */);
+    }
     return vkMapMemory_VkResult_return;
 }
-static void entry_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+void gfxstream_vk_UnmapMemory(VkDevice device, VkDeviceMemory memory) {
     AEMU_SCOPED_TRACE("vkUnmapMemory");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUnmapMemory(device, memory, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkUnmapMemory(gfxstream_device->internal_object, gfxstream_memory->internal_object,
+                             true /* do lock */);
+    }
 }
-static VkResult entry_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
-                                                const VkMappedMemoryRange* pMemoryRanges) {
+VkResult gfxstream_vk_FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                              const VkMappedMemoryRange* pMemoryRanges) {
     AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
-    vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(
-        device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
+        for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+            internal_pMemoryRanges[i] = pMemoryRanges[i];
+            /* VkMappedMemoryRange::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                           internal_pMemoryRanges[i].memory);
+            internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
+        }
+        vkFlushMappedMemoryRanges_VkResult_return =
+            vkEnc->vkFlushMappedMemoryRanges(gfxstream_device->internal_object, memoryRangeCount,
+                                             internal_pMemoryRanges.data(), true /* do lock */);
+    }
     return vkFlushMappedMemoryRanges_VkResult_return;
 }
-static VkResult entry_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
-                                                     const VkMappedMemoryRange* pMemoryRanges) {
+VkResult gfxstream_vk_InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
+                                                   const VkMappedMemoryRange* pMemoryRanges) {
     AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
-    vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
-        device, memoryRangeCount, pMemoryRanges, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkMappedMemoryRange> internal_pMemoryRanges(memoryRangeCount);
+        for (uint32_t i = 0; i < memoryRangeCount; ++i) {
+            internal_pMemoryRanges[i] = pMemoryRanges[i];
+            /* VkMappedMemoryRange::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                           internal_pMemoryRanges[i].memory);
+            internal_pMemoryRanges[i].memory = gfxstream_memory->internal_object;
+        }
+        vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
+            gfxstream_device->internal_object, memoryRangeCount, internal_pMemoryRanges.data(),
+            true /* do lock */);
+    }
     return vkInvalidateMappedMemoryRanges_VkResult_return;
 }
-static void entry_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
-                                              VkDeviceSize* pCommittedMemoryInBytes) {
+void gfxstream_vk_GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
+                                            VkDeviceSize* pCommittedMemoryInBytes) {
     AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceMemoryCommitment(gfxstream_device->internal_object,
+                                           gfxstream_memory->internal_object,
+                                           pCommittedMemoryInBytes, true /* do lock */);
+    }
 }
-static VkResult entry_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
-                                         VkDeviceSize memoryOffset) {
+VkResult gfxstream_vk_BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+                                       VkDeviceSize memoryOffset) {
     AEMU_SCOPED_TRACE("vkBindBufferMemory");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBindBufferMemory_VkResult_return =
-        resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_buffer->internal_object,
+            gfxstream_memory->internal_object, memoryOffset);
+    }
     return vkBindBufferMemory_VkResult_return;
 }
-static VkResult entry_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
-                                        VkDeviceSize memoryOffset) {
+VkResult gfxstream_vk_BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
+                                      VkDeviceSize memoryOffset) {
     AEMU_SCOPED_TRACE("vkBindImageMemory");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBindImageMemory_VkResult_return =
-        resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, gfxstream_image->internal_object,
+            gfxstream_memory->internal_object, memoryOffset);
+    }
     return vkBindImageMemory_VkResult_return;
 }
-static void entry_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
-                                                VkMemoryRequirements* pMemoryRequirements) {
+void gfxstream_vk_GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                              VkMemoryRequirements* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetBufferMemoryRequirements(vkEnc, gfxstream_device->internal_object,
+                                                    gfxstream_buffer->internal_object,
+                                                    pMemoryRequirements);
+    }
 }
-static void entry_vkGetImageMemoryRequirements(VkDevice device, VkImage image,
-                                               VkMemoryRequirements* pMemoryRequirements) {
+void gfxstream_vk_GetImageMemoryRequirements(VkDevice device, VkImage image,
+                                             VkMemoryRequirements* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetImageMemoryRequirements(vkEnc, gfxstream_device->internal_object,
+                                                   gfxstream_image->internal_object,
+                                                   pMemoryRequirements);
+    }
 }
-static void entry_vkGetImageSparseMemoryRequirements(
+void gfxstream_vk_GetImageSparseMemoryRequirements(
     VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
-                                              pSparseMemoryRequirements, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetImageSparseMemoryRequirements(
+            gfxstream_device->internal_object, gfxstream_image->internal_object,
+            pSparseMemoryRequirementCount, pSparseMemoryRequirements, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties(
     VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
     VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
     uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples,
-                                                          usage, tiling, pPropertyCount,
-                                                          pProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(
+            gfxstream_physicalDevice->internal_object, format, type, samples, usage, tiling,
+            pPropertyCount, pProperties, true /* do lock */);
+    }
 }
-static VkResult entry_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
-                                        const VkBindSparseInfo* pBindInfo, VkFence fence) {
+VkResult gfxstream_vk_QueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
+                                      const VkBindSparseInfo* pBindInfo, VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueBindSparse");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
     VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
-    vkQueueBindSparse_VkResult_return =
-        vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
+        std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
+        std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
+            internal_VkBindSparseInfo_pBufferBinds;
+        std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
+        std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
+            internal_VkBindSparseInfo_pImageOpaqueBinds;
+        std::vector<std::vector<VkSparseMemoryBind>>
+            internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
+        std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
+        std::vector<std::vector<VkSparseImageMemoryBind>>
+            internal_VkSparseImageMemoryBindInfo_pBinds;
+        std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
+        for (uint32_t i = 0; i < bindInfoCount; ++i) {
+            internal_pBindInfo[i] = pBindInfo[i];
+            /* VkBindSparseInfo::pWaitSemaphores */
+            internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+                internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
+            internal_pBindInfo[i].pWaitSemaphores =
+                internal_VkBindSparseInfo_pWaitSemaphores[i].data();
+            internal_pBindInfo[i].waitSemaphoreCount =
+                internal_VkBindSparseInfo_pWaitSemaphores[i].size();
+            /* VkBindSparseInfo::pBufferBinds */
+            internal_VkBindSparseInfo_pBufferBinds.push_back(
+                std::vector<VkSparseBufferMemoryBindInfo>());
+            internal_VkBindSparseInfo_pBufferBinds[i].reserve(
+                internal_pBindInfo[i].bufferBindCount);
+            memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
+                   sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
+            for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
+                internal_VkBindSparseInfo_pBufferBinds[i][j] =
+                    internal_pBindInfo[i].pBufferBinds[j];
+                /* VkSparseBufferMemoryBindInfo::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
+                internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+                /* VkSparseBufferMemoryBindInfo::pBinds */
+                internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
+                    std::vector<VkSparseMemoryBind>());
+                internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
+                    internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+                memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
+                       sizeof(VkSparseMemoryBind) *
+                           internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+                for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
+                     ++k) {
+                    internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
+                        internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
+                    /* VkSparseMemoryBind::memory */
+                    if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
+                        VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                                       internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
+                        internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
+                            gfxstream_memory->internal_object;
+                    }
+                }
+                internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
+                    internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
+            }
+            internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
+            /* VkBindSparseInfo::pImageOpaqueBinds */
+            internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
+                std::vector<VkSparseImageOpaqueMemoryBindInfo>());
+            internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
+                internal_pBindInfo[i].imageOpaqueBindCount);
+            memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
+                   sizeof(VkSparseImageOpaqueMemoryBindInfo) *
+                       internal_pBindInfo[i].imageOpaqueBindCount);
+            for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
+                    internal_pBindInfo[i].pImageOpaqueBinds[j];
+                /* VkSparseImageOpaqueMemoryBindInfo::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
+                    gfxstream_image->internal_object;
+                /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
+                internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
+                    std::vector<VkSparseMemoryBind>());
+                internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
+                    internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+                memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
+                       sizeof(VkSparseMemoryBind) *
+                           internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+                for (uint32_t l = 0;
+                     l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
+                    internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
+                        internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
+                    /* VkSparseMemoryBind::memory */
+                    if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
+                        VK_FROM_HANDLE(
+                            gfxstream_vk_device_memory, gfxstream_memory,
+                            internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
+                        internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
+                            gfxstream_memory->internal_object;
+                    }
+                }
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
+                    internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
+            }
+            internal_pBindInfo[i].pImageOpaqueBinds =
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
+            /* VkBindSparseInfo::pImageBinds */
+            internal_VkBindSparseInfo_pImageBinds.push_back(
+                std::vector<VkSparseImageMemoryBindInfo>());
+            internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
+            memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
+                   sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
+            for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
+                internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
+                /* VkSparseImageMemoryBindInfo::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkBindSparseInfo_pImageBinds[i][j].image);
+                internal_VkBindSparseInfo_pImageBinds[i][j].image =
+                    gfxstream_image->internal_object;
+                /* VkSparseImageMemoryBindInfo::pBinds */
+                internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
+                    std::vector<VkSparseImageMemoryBind>());
+                internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
+                    internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+                memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
+                       sizeof(VkSparseImageMemoryBind) *
+                           internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+                for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
+                     ++m) {
+                    internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
+                        internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
+                    /* VkSparseImageMemoryBind::memory */
+                    if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
+                        VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                                       internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
+                        internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
+                            gfxstream_memory->internal_object;
+                    }
+                }
+                internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
+                    internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
+            }
+            internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
+            /* VkBindSparseInfo::pSignalSemaphores */
+            internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkBindSparseInfo_pSignalSemaphores[i] =
+                transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
+                                         internal_pBindInfo[i].signalSemaphoreCount);
+            internal_pBindInfo[i].pSignalSemaphores =
+                internal_VkBindSparseInfo_pSignalSemaphores[i].data();
+            internal_pBindInfo[i].signalSemaphoreCount =
+                internal_VkBindSparseInfo_pSignalSemaphores[i].size();
+        }
+        vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(
+            gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+            true /* do lock */);
+    }
     return vkQueueBindSparse_VkResult_return;
 }
-static VkResult entry_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
-                                    const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
+VkResult gfxstream_vk_CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
+                                  const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
     AEMU_SCOPED_TRACE("vkCreateFence");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateFence_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateFence_VkResult_return =
-        resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_fence* gfxstream_pFence = (gfxstream_vk_fence*)vk_object_zalloc(
+        &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_fence), VK_OBJECT_TYPE_FENCE);
+    vkCreateFence_VkResult_return = gfxstream_pFence ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateFence_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateFence_VkResult_return = resources->on_vkCreateFence(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pFence->internal_object);
+    }
+    *pFence = gfxstream_vk_fence_to_handle(gfxstream_pFence);
     return vkCreateFence_VkResult_return;
 }
-static void entry_vkDestroyFence(VkDevice device, VkFence fence,
-                                 const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyFence(VkDevice device, VkFence fence,
+                               const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyFence");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyFence(device, fence, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == fence) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyFence(gfxstream_device->internal_object,
+                              gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+                              pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_fence);
 }
-static VkResult entry_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
+VkResult gfxstream_vk_ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
     AEMU_SCOPED_TRACE("vkResetFences");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkResetFences_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkResetFences_VkResult_return =
-        resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkFence> internal_pFences(fenceCount);
+        for (uint32_t i = 0; i < fenceCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
+            internal_pFences[i] = gfxstream_pFences->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkResetFences_VkResult_return =
+            resources->on_vkResetFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+                                        fenceCount, internal_pFences.data());
+    }
     return vkResetFences_VkResult_return;
 }
-static VkResult entry_vkGetFenceStatus(VkDevice device, VkFence fence) {
+VkResult gfxstream_vk_GetFenceStatus(VkDevice device, VkFence fence) {
     AEMU_SCOPED_TRACE("vkGetFenceStatus");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
-    vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetFenceStatus_VkResult_return =
+            vkEnc->vkGetFenceStatus(gfxstream_device->internal_object,
+                                    gfxstream_fence->internal_object, true /* do lock */);
+    }
     return vkGetFenceStatus_VkResult_return;
 }
-static VkResult entry_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
-                                      VkBool32 waitAll, uint64_t timeout) {
+VkResult gfxstream_vk_WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
+                                    VkBool32 waitAll, uint64_t timeout) {
     AEMU_SCOPED_TRACE("vkWaitForFences");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkWaitForFences_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(
-        vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkFence> internal_pFences(fenceCount);
+        for (uint32_t i = 0; i < fenceCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_pFences, pFences[i]);
+            internal_pFences[i] = gfxstream_pFences->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkWaitForFences_VkResult_return =
+            resources->on_vkWaitForFences(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+                                          fenceCount, internal_pFences.data(), waitAll, timeout);
+    }
     return vkWaitForFences_VkResult_return;
 }
-static VkResult entry_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
-                                        const VkAllocationCallbacks* pAllocator,
-                                        VkSemaphore* pSemaphore) {
+VkResult gfxstream_vk_CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+                                      const VkAllocationCallbacks* pAllocator,
+                                      VkSemaphore* pSemaphore) {
     AEMU_SCOPED_TRACE("vkCreateSemaphore");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
-        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_semaphore* gfxstream_pSemaphore = (gfxstream_vk_semaphore*)vk_object_zalloc(
+        &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_semaphore),
+        VK_OBJECT_TYPE_SEMAPHORE);
+    vkCreateSemaphore_VkResult_return =
+        gfxstream_pSemaphore ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateSemaphore_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pSemaphore->internal_object);
+    }
+    *pSemaphore = gfxstream_vk_semaphore_to_handle(gfxstream_pSemaphore);
     return vkCreateSemaphore_VkResult_return;
 }
-static void entry_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
-                                     const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySemaphore(VkDevice device, VkSemaphore semaphore,
+                                   const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroySemaphore");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
+    if (VK_NULL_HANDLE == semaphore) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroySemaphore(
+            vkEnc, gfxstream_device->internal_object,
+            gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
+            pAllocator);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_semaphore);
 }
-static VkResult entry_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
-                                    const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
+VkResult gfxstream_vk_CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
+                                  const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
     AEMU_SCOPED_TRACE("vkCreateEvent");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateEvent_VkResult_return = (VkResult)0;
-    vkCreateEvent_VkResult_return =
-        vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_event* gfxstream_pEvent = (gfxstream_vk_event*)vk_object_zalloc(
+        &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_event), VK_OBJECT_TYPE_EVENT);
+    vkCreateEvent_VkResult_return = gfxstream_pEvent ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateEvent_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateEvent_VkResult_return =
+            vkEnc->vkCreateEvent(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                                 &gfxstream_pEvent->internal_object, true /* do lock */);
+    }
+    *pEvent = gfxstream_vk_event_to_handle(gfxstream_pEvent);
     return vkCreateEvent_VkResult_return;
 }
-static void entry_vkDestroyEvent(VkDevice device, VkEvent event,
-                                 const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyEvent(VkDevice device, VkEvent event,
+                               const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyEvent");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyEvent(device, event, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == event) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyEvent(gfxstream_device->internal_object,
+                              gfxstream_event ? gfxstream_event->internal_object : VK_NULL_HANDLE,
+                              pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_event);
 }
-static VkResult entry_vkGetEventStatus(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_GetEventStatus(VkDevice device, VkEvent event) {
     AEMU_SCOPED_TRACE("vkGetEventStatus");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
-    vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetEventStatus_VkResult_return =
+            vkEnc->vkGetEventStatus(gfxstream_device->internal_object,
+                                    gfxstream_event->internal_object, true /* do lock */);
+    }
     return vkGetEventStatus_VkResult_return;
 }
-static VkResult entry_vkSetEvent(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_SetEvent(VkDevice device, VkEvent event) {
     AEMU_SCOPED_TRACE("vkSetEvent");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkSetEvent_VkResult_return = (VkResult)0;
-    vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkSetEvent_VkResult_return =
+            vkEnc->vkSetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
+                              true /* do lock */);
+    }
     return vkSetEvent_VkResult_return;
 }
-static VkResult entry_vkResetEvent(VkDevice device, VkEvent event) {
+VkResult gfxstream_vk_ResetEvent(VkDevice device, VkEvent event) {
     AEMU_SCOPED_TRACE("vkResetEvent");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkResetEvent_VkResult_return = (VkResult)0;
-    vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkResetEvent_VkResult_return =
+            vkEnc->vkResetEvent(gfxstream_device->internal_object, gfxstream_event->internal_object,
+                                true /* do lock */);
+    }
     return vkResetEvent_VkResult_return;
 }
-static VkResult entry_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
-                                        const VkAllocationCallbacks* pAllocator,
-                                        VkQueryPool* pQueryPool) {
+VkResult gfxstream_vk_CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+                                      const VkAllocationCallbacks* pAllocator,
+                                      VkQueryPool* pQueryPool) {
     AEMU_SCOPED_TRACE("vkCreateQueryPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_query_pool* gfxstream_pQueryPool =
+        (struct gfxstream_vk_query_pool*)vk_query_pool_create(
+            (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
+            sizeof(struct gfxstream_vk_query_pool));
     vkCreateQueryPool_VkResult_return =
-        vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
+        gfxstream_pQueryPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateQueryPool_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateQueryPool_VkResult_return =
+            vkEnc->vkCreateQueryPool(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                                     &gfxstream_pQueryPool->internal_object, true /* do lock */);
+    }
+    *pQueryPool = gfxstream_vk_query_pool_to_handle(gfxstream_pQueryPool);
     return vkCreateQueryPool_VkResult_return;
 }
-static void entry_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
-                                     const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+                                   const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyQueryPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == queryPool) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyQueryPool(
+            gfxstream_device->internal_object,
+            gfxstream_queryPool ? gfxstream_queryPool->internal_object : VK_NULL_HANDLE, pAllocator,
+            true /* do lock */);
+    }
+    vk_query_pool_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_queryPool->vk);
 }
-static VkResult entry_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
-                                            uint32_t firstQuery, uint32_t queryCount,
-                                            size_t dataSize, void* pData, VkDeviceSize stride,
-                                            VkQueryResultFlags flags) {
+VkResult gfxstream_vk_GetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
+                                          uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
+                                          void* pData, VkDeviceSize stride,
+                                          VkQueryResultFlags flags) {
     AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
-    vkGetQueryPoolResults_VkResult_return =
-        vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData,
-                                     stride, flags, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(
+            gfxstream_device->internal_object, gfxstream_queryPool->internal_object, firstQuery,
+            queryCount, dataSize, pData, stride, flags, true /* do lock */);
+    }
     return vkGetQueryPoolResults_VkResult_return;
 }
-static VkResult entry_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
-                                     const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+VkResult gfxstream_vk_CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+                                   const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
     AEMU_SCOPED_TRACE("vkCreateBuffer");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateBuffer_VkResult_return =
-        resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
+        (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
+    vkCreateBuffer_VkResult_return = gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateBuffer_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pBuffer->internal_object);
+    }
+    *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
     return vkCreateBuffer_VkResult_return;
 }
-static void entry_vkDestroyBuffer(VkDevice device, VkBuffer buffer,
-                                  const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyBuffer(VkDevice device, VkBuffer buffer,
+                                const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyBuffer");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
+    if (VK_NULL_HANDLE == buffer) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroyBuffer(
+            vkEnc, gfxstream_device->internal_object,
+            gfxstream_buffer ? gfxstream_buffer->internal_object : VK_NULL_HANDLE, pAllocator);
+    }
+    vk_buffer_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_buffer->vk);
 }
-static VkResult entry_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
-                                         const VkAllocationCallbacks* pAllocator,
-                                         VkBufferView* pView) {
+VkResult gfxstream_vk_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
+                                       const VkAllocationCallbacks* pAllocator,
+                                       VkBufferView* pView) {
     AEMU_SCOPED_TRACE("vkCreateBufferView");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
-    vkCreateBufferView_VkResult_return =
-        vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_buffer_view* gfxstream_pView =
+        (struct gfxstream_vk_buffer_view*)vk_buffer_view_create(
+            (vk_device*)gfxstream_device, pCreateInfo, pAllocator,
+            sizeof(struct gfxstream_vk_buffer_view));
+    vkCreateBufferView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateBufferView_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferViewCreateInfo> internal_pCreateInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCreateInfo[i] = pCreateInfo[i];
+            /* VkBufferViewCreateInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pCreateInfo[i].buffer);
+            internal_pCreateInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(
+            gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+            &gfxstream_pView->internal_object, true /* do lock */);
+    }
+    *pView = gfxstream_vk_buffer_view_to_handle(gfxstream_pView);
     return vkCreateBufferView_VkResult_return;
 }
-static void entry_vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
-                                      const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyBufferView(VkDevice device, VkBufferView bufferView,
+                                    const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyBufferView");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyBufferView(device, bufferView, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == bufferView) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_bufferView, bufferView);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyBufferView(
+            gfxstream_device->internal_object,
+            gfxstream_bufferView ? gfxstream_bufferView->internal_object : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_buffer_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_bufferView->vk);
 }
-static VkResult entry_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
-                                    const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+VkResult gfxstream_vk_CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+                                  const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
     AEMU_SCOPED_TRACE("vkCreateImage");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateImage_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateImage_VkResult_return =
-        resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
+        (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
+    vkCreateImage_VkResult_return = gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateImage_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateImage_VkResult_return = resources->on_vkCreateImage(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pImage->internal_object);
+    }
+    *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
     return vkCreateImage_VkResult_return;
 }
-static void entry_vkDestroyImage(VkDevice device, VkImage image,
-                                 const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyImage(VkDevice device, VkImage image,
+                               const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyImage");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
+    if (VK_NULL_HANDLE == image) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroyImage(
+            vkEnc, gfxstream_device->internal_object,
+            gfxstream_image ? gfxstream_image->internal_object : VK_NULL_HANDLE, pAllocator);
+    }
+    vk_image_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_image->vk);
 }
-static void entry_vkGetImageSubresourceLayout(VkDevice device, VkImage image,
-                                              const VkImageSubresource* pSubresource,
-                                              VkSubresourceLayout* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout(VkDevice device, VkImage image,
+                                            const VkImageSubresource* pSubresource,
+                                            VkSubresourceLayout* pLayout) {
     AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetImageSubresourceLayout(gfxstream_device->internal_object,
+                                           gfxstream_image->internal_object, pSubresource, pLayout,
+                                           true /* do lock */);
+    }
 }
-static VkResult entry_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
-                                        const VkAllocationCallbacks* pAllocator,
-                                        VkImageView* pView) {
+VkResult gfxstream_vk_CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
+                                      const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
     AEMU_SCOPED_TRACE("vkCreateImageView");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateImageView_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateImageView_VkResult_return =
-        resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_image_view* gfxstream_pView =
+        (struct gfxstream_vk_image_view*)vk_image_view_create(
+            (vk_device*)gfxstream_device, false /* driver_internal */, pCreateInfo, pAllocator,
+            sizeof(struct gfxstream_vk_image_view));
+    vkCreateImageView_VkResult_return = gfxstream_pView ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateImageView_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImageViewCreateInfo> internal_pCreateInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCreateInfo[i] = pCreateInfo[i];
+            /* VkImageViewCreateInfo::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pCreateInfo[i].image);
+            internal_pCreateInfo[i].image = gfxstream_image->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pCreateInfo.data(),
+            pAllocator, &gfxstream_pView->internal_object);
+    }
+    *pView = gfxstream_vk_image_view_to_handle(gfxstream_pView);
     return vkCreateImageView_VkResult_return;
 }
-static void entry_vkDestroyImageView(VkDevice device, VkImageView imageView,
-                                     const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyImageView(VkDevice device, VkImageView imageView,
+                                   const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyImageView");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyImageView(device, imageView, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == imageView) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView, imageView);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyImageView(
+            gfxstream_device->internal_object,
+            gfxstream_imageView ? gfxstream_imageView->internal_object : VK_NULL_HANDLE, pAllocator,
+            true /* do lock */);
+    }
+    vk_image_view_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_imageView->vk);
 }
-static VkResult entry_vkCreateShaderModule(VkDevice device,
-                                           const VkShaderModuleCreateInfo* pCreateInfo,
-                                           const VkAllocationCallbacks* pAllocator,
-                                           VkShaderModule* pShaderModule) {
+VkResult gfxstream_vk_CreateShaderModule(VkDevice device,
+                                         const VkShaderModuleCreateInfo* pCreateInfo,
+                                         const VkAllocationCallbacks* pAllocator,
+                                         VkShaderModule* pShaderModule) {
     AEMU_SCOPED_TRACE("vkCreateShaderModule");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
-    vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
-        device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_shader_module* gfxstream_pShaderModule =
+        (gfxstream_vk_shader_module*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                      sizeof(gfxstream_vk_shader_module),
+                                                      VK_OBJECT_TYPE_SHADER_MODULE);
+    vkCreateShaderModule_VkResult_return =
+        gfxstream_pShaderModule ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateShaderModule_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
+            gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pShaderModule->internal_object, true /* do lock */);
+    }
+    *pShaderModule = gfxstream_vk_shader_module_to_handle(gfxstream_pShaderModule);
     return vkCreateShaderModule_VkResult_return;
 }
-static void entry_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
-                                        const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
+                                      const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyShaderModule");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == shaderModule) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_shaderModule, shaderModule);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyShaderModule(
+            gfxstream_device->internal_object,
+            gfxstream_shaderModule ? gfxstream_shaderModule->internal_object : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_shaderModule);
 }
-static VkResult entry_vkCreatePipelineCache(VkDevice device,
-                                            const VkPipelineCacheCreateInfo* pCreateInfo,
-                                            const VkAllocationCallbacks* pAllocator,
-                                            VkPipelineCache* pPipelineCache) {
+VkResult gfxstream_vk_CreatePipelineCache(VkDevice device,
+                                          const VkPipelineCacheCreateInfo* pCreateInfo,
+                                          const VkAllocationCallbacks* pAllocator,
+                                          VkPipelineCache* pPipelineCache) {
     AEMU_SCOPED_TRACE("vkCreatePipelineCache");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
-    vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
-        device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_pipeline_cache* gfxstream_pPipelineCache =
+        (gfxstream_vk_pipeline_cache*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                       sizeof(gfxstream_vk_pipeline_cache),
+                                                       VK_OBJECT_TYPE_PIPELINE_CACHE);
+    vkCreatePipelineCache_VkResult_return =
+        gfxstream_pPipelineCache ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreatePipelineCache_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
+            gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pPipelineCache->internal_object, true /* do lock */);
+    }
+    *pPipelineCache = gfxstream_vk_pipeline_cache_to_handle(gfxstream_pPipelineCache);
     return vkCreatePipelineCache_VkResult_return;
 }
-static void entry_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
-                                         const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
+                                       const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == pipelineCache) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyPipelineCache(
+            gfxstream_device->internal_object,
+            gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineCache);
 }
-static VkResult entry_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
-                                             size_t* pDataSize, void* pData) {
+VkResult gfxstream_vk_GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
+                                           size_t* pDataSize, void* pData) {
     AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
-    vkGetPipelineCacheData_VkResult_return =
-        vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(
+            gfxstream_device->internal_object, gfxstream_pipelineCache->internal_object, pDataSize,
+            pData, true /* do lock */);
+    }
     return vkGetPipelineCacheData_VkResult_return;
 }
-static VkResult entry_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
-                                            uint32_t srcCacheCount,
-                                            const VkPipelineCache* pSrcCaches) {
+VkResult gfxstream_vk_MergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
+                                          uint32_t srcCacheCount,
+                                          const VkPipelineCache* pSrcCaches) {
     AEMU_SCOPED_TRACE("vkMergePipelineCaches");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
-    vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
-        device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_dstCache, dstCache);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkPipelineCache> internal_pSrcCaches(srcCacheCount);
+        for (uint32_t i = 0; i < srcCacheCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pSrcCaches, pSrcCaches[i]);
+            internal_pSrcCaches[i] = gfxstream_pSrcCaches->internal_object;
+        }
+        vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
+            gfxstream_device->internal_object, gfxstream_dstCache->internal_object, srcCacheCount,
+            internal_pSrcCaches.data(), true /* do lock */);
+    }
     return vkMergePipelineCaches_VkResult_return;
 }
-static VkResult entry_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
-                                                uint32_t createInfoCount,
-                                                const VkGraphicsPipelineCreateInfo* pCreateInfos,
-                                                const VkAllocationCallbacks* pAllocator,
-                                                VkPipeline* pPipelines) {
+VkResult gfxstream_vk_CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
+                                              uint32_t createInfoCount,
+                                              const VkGraphicsPipelineCreateInfo* pCreateInfos,
+                                              const VkAllocationCallbacks* pAllocator,
+                                              VkPipeline* pPipelines) {
     AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
-        vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
-        pPipelines);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_cache, gfxstream_pipelineCache, pipelineCache);
+    struct gfxstream_vk_pipeline* gfxstream_pPipelines = (gfxstream_vk_pipeline*)vk_object_zalloc(
+        &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_pipeline), VK_OBJECT_TYPE_PIPELINE);
+    vkCreateGraphicsPipelines_VkResult_return =
+        gfxstream_pPipelines ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateGraphicsPipelines_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkGraphicsPipelineCreateInfo> internal_pCreateInfos(createInfoCount);
+        std::vector<std::vector<VkPipelineShaderStageCreateInfo>>
+            internal_VkGraphicsPipelineCreateInfo_pStages;
+        for (uint32_t i = 0; i < createInfoCount; ++i) {
+            internal_pCreateInfos[i] = pCreateInfos[i];
+            /* VkGraphicsPipelineCreateInfo::pStages */
+            internal_VkGraphicsPipelineCreateInfo_pStages.push_back(
+                std::vector<VkPipelineShaderStageCreateInfo>());
+            internal_VkGraphicsPipelineCreateInfo_pStages[i].reserve(
+                internal_pCreateInfos[i].stageCount);
+            memset(&internal_VkGraphicsPipelineCreateInfo_pStages[i][0], 0,
+                   sizeof(VkPipelineShaderStageCreateInfo) * internal_pCreateInfos[i].stageCount);
+            for (uint32_t j = 0; j < internal_pCreateInfos[i].stageCount; ++j) {
+                if (internal_pCreateInfos[i].pStages) {
+                    internal_VkGraphicsPipelineCreateInfo_pStages[i][j] =
+                        internal_pCreateInfos[i].pStages[j];
+                    /* VkPipelineShaderStageCreateInfo::module */
+                    if (internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module) {
+                        VK_FROM_HANDLE(gfxstream_vk_shader_module, gfxstream_module,
+                                       internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module);
+                        internal_VkGraphicsPipelineCreateInfo_pStages[i][j].module =
+                            gfxstream_module->internal_object;
+                    }
+                }
+            }
+            internal_pCreateInfos[i].pStages =
+                internal_VkGraphicsPipelineCreateInfo_pStages[i].data();
+            /* VkGraphicsPipelineCreateInfo::layout */
+            if (internal_pCreateInfos[i].layout) {
+                VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout,
+                               internal_pCreateInfos[i].layout);
+                internal_pCreateInfos[i].layout = gfxstream_layout->internal_object;
+            }
+            /* VkGraphicsPipelineCreateInfo::renderPass */
+            if (internal_pCreateInfos[i].renderPass) {
+                VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+                               internal_pCreateInfos[i].renderPass);
+                internal_pCreateInfos[i].renderPass = gfxstream_renderPass->internal_object;
+            }
+            /* VkGraphicsPipelineCreateInfo::basePipelineHandle */
+            if (internal_pCreateInfos[i].basePipelineHandle) {
+                VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_basePipelineHandle,
+                               internal_pCreateInfos[i].basePipelineHandle);
+                internal_pCreateInfos[i].basePipelineHandle =
+                    gfxstream_basePipelineHandle->internal_object;
+            }
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+            gfxstream_pipelineCache ? gfxstream_pipelineCache->internal_object : VK_NULL_HANDLE,
+            createInfoCount, internal_pCreateInfos.data(), pAllocator,
+            &gfxstream_pPipelines->internal_object);
+    }
+    *pPipelines = gfxstream_vk_pipeline_to_handle(gfxstream_pPipelines);
     return vkCreateGraphicsPipelines_VkResult_return;
 }
-static VkResult entry_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
-                                               uint32_t createInfoCount,
-                                               const VkComputePipelineCreateInfo* pCreateInfos,
-                                               const VkAllocationCallbacks* pAllocator,
-                                               VkPipeline* pPipelines) {
-    AEMU_SCOPED_TRACE("vkCreateComputePipelines");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
-    vkCreateComputePipelines_VkResult_return =
-        vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos,
-                                        pAllocator, pPipelines, true /* do lock */);
-    return vkCreateComputePipelines_VkResult_return;
-}
-static void entry_vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
-                                    const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipeline(VkDevice device, VkPipeline pipeline,
+                                  const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyPipeline");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPipeline(device, pipeline, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == pipeline) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyPipeline(
+            gfxstream_device->internal_object,
+            gfxstream_pipeline ? gfxstream_pipeline->internal_object : VK_NULL_HANDLE, pAllocator,
+            true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipeline);
 }
-static VkResult entry_vkCreatePipelineLayout(VkDevice device,
-                                             const VkPipelineLayoutCreateInfo* pCreateInfo,
-                                             const VkAllocationCallbacks* pAllocator,
-                                             VkPipelineLayout* pPipelineLayout) {
+VkResult gfxstream_vk_CreatePipelineLayout(VkDevice device,
+                                           const VkPipelineLayoutCreateInfo* pCreateInfo,
+                                           const VkAllocationCallbacks* pAllocator,
+                                           VkPipelineLayout* pPipelineLayout) {
     AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
-    vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
-        device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_pipeline_layout* gfxstream_pPipelineLayout =
+        (gfxstream_vk_pipeline_layout*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                        sizeof(gfxstream_vk_pipeline_layout),
+                                                        VK_OBJECT_TYPE_PIPELINE_LAYOUT);
+    vkCreatePipelineLayout_VkResult_return =
+        gfxstream_pPipelineLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreatePipelineLayout_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkPipelineLayoutCreateInfo> internal_pCreateInfo(1);
+        std::vector<std::vector<VkDescriptorSetLayout>>
+            internal_VkPipelineLayoutCreateInfo_pSetLayouts;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCreateInfo[i] = pCreateInfo[i];
+            /* VkPipelineLayoutCreateInfo::pSetLayouts */
+            internal_VkPipelineLayoutCreateInfo_pSetLayouts.push_back(
+                std::vector<VkDescriptorSetLayout>());
+            internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].reserve(
+                internal_pCreateInfo[i].setLayoutCount);
+            memset(&internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][0], 0,
+                   sizeof(VkDescriptorSetLayout) * internal_pCreateInfo[i].setLayoutCount);
+            for (uint32_t j = 0; j < internal_pCreateInfo[i].setLayoutCount; ++j) {
+                if (internal_pCreateInfo[i].pSetLayouts) {
+                    VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+                                   internal_pCreateInfo[i].pSetLayouts[j]);
+                    internal_VkPipelineLayoutCreateInfo_pSetLayouts[i][j] =
+                        gfxstream_pSetLayouts->internal_object;
+                }
+            }
+            internal_pCreateInfo[i].pSetLayouts =
+                internal_VkPipelineLayoutCreateInfo_pSetLayouts[i].data();
+        }
+        vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
+            gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+            &gfxstream_pPipelineLayout->internal_object, true /* do lock */);
+    }
+    *pPipelineLayout = gfxstream_vk_pipeline_layout_to_handle(gfxstream_pPipelineLayout);
     return vkCreatePipelineLayout_VkResult_return;
 }
-static void entry_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
-                                          const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
+                                        const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == pipelineLayout) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout, pipelineLayout);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyPipelineLayout(
+            gfxstream_device->internal_object,
+            gfxstream_pipelineLayout ? gfxstream_pipelineLayout->internal_object : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_pipelineLayout);
 }
-static VkResult entry_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
-                                      const VkAllocationCallbacks* pAllocator,
-                                      VkSampler* pSampler) {
+VkResult gfxstream_vk_CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+                                    const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
     AEMU_SCOPED_TRACE("vkCreateSampler");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateSampler_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateSampler_VkResult_return =
-        resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateSampler_VkResult_return =
+            resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+                                          pCreateInfo, pAllocator, pSampler);
+    }
     return vkCreateSampler_VkResult_return;
 }
-static void entry_vkDestroySampler(VkDevice device, VkSampler sampler,
-                                   const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySampler(VkDevice device, VkSampler sampler,
+                                 const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroySampler");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroySampler(device, sampler, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == sampler) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroySampler(gfxstream_device->internal_object, sampler, pAllocator,
+                                true /* do lock */);
+    }
 }
-static VkResult entry_vkCreateDescriptorSetLayout(
-    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+VkResult gfxstream_vk_CreateDescriptorSetLayout(VkDevice device,
+                                                const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                const VkAllocationCallbacks* pAllocator,
+                                                VkDescriptorSetLayout* pSetLayout) {
     AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
-        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_descriptor_set_layout* gfxstream_pSetLayout =
+        (gfxstream_vk_descriptor_set_layout*)vk_object_zalloc(
+            &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_set_layout),
+            VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT);
+    vkCreateDescriptorSetLayout_VkResult_return =
+        gfxstream_pSetLayout ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateDescriptorSetLayout_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pSetLayout->internal_object);
+    }
+    *pSetLayout = gfxstream_vk_descriptor_set_layout_to_handle(gfxstream_pSetLayout);
     return vkCreateDescriptorSetLayout_VkResult_return;
 }
-static void entry_vkDestroyDescriptorSetLayout(VkDevice device,
-                                               VkDescriptorSetLayout descriptorSetLayout,
-                                               const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyDescriptorSetLayout(VkDevice device,
+                                             VkDescriptorSetLayout descriptorSetLayout,
+                                             const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroyDescriptorSetLayout(vkEnc, device, descriptorSetLayout, pAllocator);
+    if (VK_NULL_HANDLE == descriptorSetLayout) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+                   descriptorSetLayout);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroyDescriptorSetLayout(
+            vkEnc, gfxstream_device->internal_object,
+            gfxstream_descriptorSetLayout ? gfxstream_descriptorSetLayout->internal_object
+                                          : VK_NULL_HANDLE,
+            pAllocator);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorSetLayout);
 }
-static VkResult entry_vkCreateDescriptorPool(VkDevice device,
-                                             const VkDescriptorPoolCreateInfo* pCreateInfo,
-                                             const VkAllocationCallbacks* pAllocator,
-                                             VkDescriptorPool* pDescriptorPool) {
+VkResult gfxstream_vk_CreateDescriptorPool(VkDevice device,
+                                           const VkDescriptorPoolCreateInfo* pCreateInfo,
+                                           const VkAllocationCallbacks* pAllocator,
+                                           VkDescriptorPool* pDescriptorPool) {
     AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
-        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_descriptor_pool* gfxstream_pDescriptorPool =
+        (gfxstream_vk_descriptor_pool*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                        sizeof(gfxstream_vk_descriptor_pool),
+                                                        VK_OBJECT_TYPE_DESCRIPTOR_POOL);
+    vkCreateDescriptorPool_VkResult_return =
+        gfxstream_pDescriptorPool ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateDescriptorPool_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pDescriptorPool->internal_object);
+    }
+    *pDescriptorPool = gfxstream_vk_descriptor_pool_to_handle(gfxstream_pDescriptorPool);
     return vkCreateDescriptorPool_VkResult_return;
 }
-static void entry_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                                          const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                        const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
+    if (VK_NULL_HANDLE == descriptorPool) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroyDescriptorPool(
+            vkEnc, gfxstream_device->internal_object,
+            gfxstream_descriptorPool ? gfxstream_descriptorPool->internal_object : VK_NULL_HANDLE,
+            pAllocator);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorPool);
 }
-static VkResult entry_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
-                                            VkDescriptorPoolResetFlags flags) {
+VkResult gfxstream_vk_ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
+                                          VkDescriptorPoolResetFlags flags) {
     AEMU_SCOPED_TRACE("vkResetDescriptorPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkResetDescriptorPool_VkResult_return =
-        resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkResetDescriptorPool_VkResult_return = resources->on_vkResetDescriptorPool(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+            gfxstream_descriptorPool->internal_object, flags);
+    }
     return vkResetDescriptorPool_VkResult_return;
 }
-static VkResult entry_vkAllocateDescriptorSets(VkDevice device,
-                                               const VkDescriptorSetAllocateInfo* pAllocateInfo,
-                                               VkDescriptorSet* pDescriptorSets) {
+VkResult gfxstream_vk_AllocateDescriptorSets(VkDevice device,
+                                             const VkDescriptorSetAllocateInfo* pAllocateInfo,
+                                             VkDescriptorSet* pDescriptorSets) {
     AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
-        vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDescriptorSetAllocateInfo> internal_pAllocateInfo(1);
+        std::vector<std::vector<VkDescriptorSetLayout>>
+            internal_VkDescriptorSetAllocateInfo_pSetLayouts;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pAllocateInfo[i] = pAllocateInfo[i];
+            /* VkDescriptorSetAllocateInfo::descriptorPool */
+            VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool,
+                           internal_pAllocateInfo[i].descriptorPool);
+            internal_pAllocateInfo[i].descriptorPool = gfxstream_descriptorPool->internal_object;
+            /* VkDescriptorSetAllocateInfo::pSetLayouts */
+            internal_VkDescriptorSetAllocateInfo_pSetLayouts.push_back(
+                std::vector<VkDescriptorSetLayout>());
+            internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].reserve(
+                internal_pAllocateInfo[i].descriptorSetCount);
+            memset(&internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][0], 0,
+                   sizeof(VkDescriptorSetLayout) * internal_pAllocateInfo[i].descriptorSetCount);
+            for (uint32_t j = 0; j < internal_pAllocateInfo[i].descriptorSetCount; ++j) {
+                VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+                               internal_pAllocateInfo[i].pSetLayouts[j]);
+                internal_VkDescriptorSetAllocateInfo_pSetLayouts[i][j] =
+                    gfxstream_pSetLayouts->internal_object;
+            }
+            internal_pAllocateInfo[i].pSetLayouts =
+                internal_VkDescriptorSetAllocateInfo_pSetLayouts[i].data();
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pAllocateInfo.data(),
+            pDescriptorSets);
+    }
     return vkAllocateDescriptorSets_VkResult_return;
 }
-static VkResult entry_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
-                                           uint32_t descriptorSetCount,
-                                           const VkDescriptorSet* pDescriptorSets) {
+VkResult gfxstream_vk_FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
+                                         uint32_t descriptorSetCount,
+                                         const VkDescriptorSet* pDescriptorSets) {
     AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
-        vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    if (VK_NULL_HANDLE == pDescriptorSets) {
+        return vkFreeDescriptorSets_VkResult_return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+            gfxstream_descriptorPool->internal_object, descriptorSetCount, pDescriptorSets);
+    }
     return vkFreeDescriptorSets_VkResult_return;
 }
-static void entry_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
-                                         const VkWriteDescriptorSet* pDescriptorWrites,
-                                         uint32_t descriptorCopyCount,
-                                         const VkCopyDescriptorSet* pDescriptorCopies) {
+void gfxstream_vk_UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
+                                       const VkWriteDescriptorSet* pDescriptorWrites,
+                                       uint32_t descriptorCopyCount,
+                                       const VkCopyDescriptorSet* pDescriptorCopies) {
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites,
-                                         descriptorCopyCount, pDescriptorCopies);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkWriteDescriptorSet> internal_pDescriptorWrites(descriptorWriteCount);
+        std::vector<std::vector<VkDescriptorImageInfo>> internal_VkWriteDescriptorSet_pImageInfo;
+        std::vector<std::vector<VkDescriptorBufferInfo>> internal_VkWriteDescriptorSet_pBufferInfo;
+        std::vector<std::vector<VkBufferView>> internal_VkWriteDescriptorSet_pTexelBufferView;
+        for (uint32_t i = 0; i < descriptorWriteCount; ++i) {
+            internal_pDescriptorWrites[i] = pDescriptorWrites[i];
+            /* VkWriteDescriptorSet::pImageInfo */
+            internal_VkWriteDescriptorSet_pImageInfo.push_back(
+                std::vector<VkDescriptorImageInfo>());
+            internal_VkWriteDescriptorSet_pImageInfo[i].reserve(
+                internal_pDescriptorWrites[i].descriptorCount);
+            memset(&internal_VkWriteDescriptorSet_pImageInfo[i][0], 0,
+                   sizeof(VkDescriptorImageInfo) * internal_pDescriptorWrites[i].descriptorCount);
+            for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+                if (internal_pDescriptorWrites[i].pImageInfo) {
+                    internal_VkWriteDescriptorSet_pImageInfo[i][j] =
+                        internal_pDescriptorWrites[i].pImageInfo[j];
+                    /* VkDescriptorImageInfo::imageView */
+                    if (internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView) {
+                        VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                       internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView);
+                        internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView =
+                            gfxstream_imageView->internal_object;
+                    }
+                }
+            }
+            internal_pDescriptorWrites[i].pImageInfo =
+                internal_VkWriteDescriptorSet_pImageInfo[i].data();
+            /* VkWriteDescriptorSet::pBufferInfo */
+            internal_VkWriteDescriptorSet_pBufferInfo.push_back(
+                std::vector<VkDescriptorBufferInfo>());
+            internal_VkWriteDescriptorSet_pBufferInfo[i].reserve(
+                internal_pDescriptorWrites[i].descriptorCount);
+            memset(&internal_VkWriteDescriptorSet_pBufferInfo[i][0], 0,
+                   sizeof(VkDescriptorBufferInfo) * internal_pDescriptorWrites[i].descriptorCount);
+            for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+                if (internal_pDescriptorWrites[i].pBufferInfo) {
+                    internal_VkWriteDescriptorSet_pBufferInfo[i][j] =
+                        internal_pDescriptorWrites[i].pBufferInfo[j];
+                    /* VkDescriptorBufferInfo::buffer */
+                    if (internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer) {
+                        VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                                       internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer);
+                        internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer =
+                            gfxstream_buffer->internal_object;
+                    }
+                }
+            }
+            internal_pDescriptorWrites[i].pBufferInfo =
+                internal_VkWriteDescriptorSet_pBufferInfo[i].data();
+            /* VkWriteDescriptorSet::pTexelBufferView */
+            internal_VkWriteDescriptorSet_pTexelBufferView.push_back(std::vector<VkBufferView>());
+            internal_VkWriteDescriptorSet_pTexelBufferView[i].reserve(
+                internal_pDescriptorWrites[i].descriptorCount);
+            memset(&internal_VkWriteDescriptorSet_pTexelBufferView[i][0], 0,
+                   sizeof(VkBufferView) * internal_pDescriptorWrites[i].descriptorCount);
+            for (uint32_t j = 0; j < internal_pDescriptorWrites[i].descriptorCount; ++j) {
+                if (internal_pDescriptorWrites[i].pTexelBufferView) {
+                    VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pTexelBufferView,
+                                   internal_pDescriptorWrites[i].pTexelBufferView[j]);
+                    internal_VkWriteDescriptorSet_pTexelBufferView[i][j] =
+                        gfxstream_pTexelBufferView->internal_object;
+                }
+            }
+            internal_pDescriptorWrites[i].pTexelBufferView =
+                internal_VkWriteDescriptorSet_pTexelBufferView[i].data();
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkUpdateDescriptorSets(
+            vkEnc, gfxstream_device->internal_object, descriptorWriteCount,
+            internal_pDescriptorWrites.data(), descriptorCopyCount, pDescriptorCopies);
+    }
 }
-static VkResult entry_vkCreateFramebuffer(VkDevice device,
-                                          const VkFramebufferCreateInfo* pCreateInfo,
-                                          const VkAllocationCallbacks* pAllocator,
-                                          VkFramebuffer* pFramebuffer) {
+VkResult gfxstream_vk_CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+                                        const VkAllocationCallbacks* pAllocator,
+                                        VkFramebuffer* pFramebuffer) {
     AEMU_SCOPED_TRACE("vkCreateFramebuffer");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
-    vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
-        device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_framebuffer* gfxstream_pFramebuffer =
+        (gfxstream_vk_framebuffer*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                    sizeof(gfxstream_vk_framebuffer),
+                                                    VK_OBJECT_TYPE_FRAMEBUFFER);
+    vkCreateFramebuffer_VkResult_return =
+        gfxstream_pFramebuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateFramebuffer_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkFramebufferCreateInfo> internal_pCreateInfo(1);
+        std::vector<std::vector<VkImageView>> internal_VkFramebufferCreateInfo_pAttachments;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCreateInfo[i] = pCreateInfo[i];
+            /* VkFramebufferCreateInfo::renderPass */
+            VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+                           internal_pCreateInfo[i].renderPass);
+            internal_pCreateInfo[i].renderPass = gfxstream_renderPass->internal_object;
+            /* VkFramebufferCreateInfo::pAttachments */
+            internal_VkFramebufferCreateInfo_pAttachments.push_back(std::vector<VkImageView>());
+            internal_VkFramebufferCreateInfo_pAttachments[i].reserve(
+                internal_pCreateInfo[i].attachmentCount);
+            memset(&internal_VkFramebufferCreateInfo_pAttachments[i][0], 0,
+                   sizeof(VkImageView) * internal_pCreateInfo[i].attachmentCount);
+            for (uint32_t j = 0; j < internal_pCreateInfo[i].attachmentCount; ++j) {
+                if (internal_pCreateInfo[i].pAttachments) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_pAttachments,
+                                   internal_pCreateInfo[i].pAttachments[j]);
+                    internal_VkFramebufferCreateInfo_pAttachments[i][j] =
+                        gfxstream_pAttachments->internal_object;
+                }
+            }
+            internal_pCreateInfo[i].pAttachments =
+                internal_VkFramebufferCreateInfo_pAttachments[i].data();
+        }
+        vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
+            gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+            &gfxstream_pFramebuffer->internal_object, true /* do lock */);
+    }
+    *pFramebuffer = gfxstream_vk_framebuffer_to_handle(gfxstream_pFramebuffer);
     return vkCreateFramebuffer_VkResult_return;
 }
-static void entry_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
-                                       const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+                                     const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == framebuffer) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer, framebuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyFramebuffer(
+            gfxstream_device->internal_object,
+            gfxstream_framebuffer ? gfxstream_framebuffer->internal_object : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_framebuffer);
 }
-static VkResult entry_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
-                                         const VkAllocationCallbacks* pAllocator,
-                                         VkRenderPass* pRenderPass) {
+VkResult gfxstream_vk_CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+                                       const VkAllocationCallbacks* pAllocator,
+                                       VkRenderPass* pRenderPass) {
     AEMU_SCOPED_TRACE("vkCreateRenderPass");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+        (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                    sizeof(gfxstream_vk_render_pass),
+                                                    VK_OBJECT_TYPE_RENDER_PASS);
     vkCreateRenderPass_VkResult_return =
-        vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+        gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateRenderPass_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateRenderPass_VkResult_return =
+            vkEnc->vkCreateRenderPass(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                                      &gfxstream_pRenderPass->internal_object, true /* do lock */);
+    }
+    *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
     return vkCreateRenderPass_VkResult_return;
 }
-static void entry_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
-                                      const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+                                    const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyRenderPass");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == renderPass) {
+        return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyRenderPass(
+            gfxstream_device->internal_object,
+            gfxstream_renderPass ? gfxstream_renderPass->internal_object : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_renderPass);
 }
-static void entry_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
-                                             VkExtent2D* pGranularity) {
+void gfxstream_vk_GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
+                                           VkExtent2D* pGranularity) {
     AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity, true /* do lock */);
-}
-static VkResult entry_vkCreateCommandPool(VkDevice device,
-                                          const VkCommandPoolCreateInfo* pCreateInfo,
-                                          const VkAllocationCallbacks* pAllocator,
-                                          VkCommandPool* pCommandPool) {
-    AEMU_SCOPED_TRACE("vkCreateCommandPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
-    vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(
-        device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
-    return vkCreateCommandPool_VkResult_return;
-}
-static void entry_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
-                                       const VkAllocationCallbacks* pAllocator) {
-    AEMU_SCOPED_TRACE("vkDestroyCommandPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator, true /* do lock */);
-}
-static VkResult entry_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
-                                         VkCommandPoolResetFlags flags) {
-    AEMU_SCOPED_TRACE("vkResetCommandPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
-    vkResetCommandPool_VkResult_return =
-        vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
-    if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
-        ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass, renderPass);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetRenderAreaGranularity(gfxstream_device->internal_object,
+                                          gfxstream_renderPass->internal_object, pGranularity,
+                                          true /* do lock */);
     }
-    return vkResetCommandPool_VkResult_return;
 }
-static VkResult entry_vkAllocateCommandBuffers(VkDevice device,
-                                               const VkCommandBufferAllocateInfo* pAllocateInfo,
-                                               VkCommandBuffer* pCommandBuffers) {
-    AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(
-        vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
-    if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
-        ResourceTracker::get()->addToCommandPool(
-            pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
-    }
-    return vkAllocateCommandBuffers_VkResult_return;
-}
-static void entry_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
-                                       uint32_t commandBufferCount,
-                                       const VkCommandBuffer* pCommandBuffers) {
-    AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers,
-                                true /* do lock */);
-}
-static VkResult entry_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
-                                           const VkCommandBufferBeginInfo* pBeginInfo) {
+VkResult gfxstream_vk_BeginCommandBuffer(VkCommandBuffer commandBuffer,
+                                         const VkCommandBufferBeginInfo* pBeginInfo) {
     AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
     VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBeginCommandBuffer_VkResult_return =
-        resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
+        std::vector<VkCommandBufferInheritanceInfo>
+            internal_VkCommandBufferBeginInfo_pInheritanceInfo;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pBeginInfo[i] = pBeginInfo[i];
+            /* VkCommandBufferBeginInfo::pInheritanceInfo */
+            if (internal_pBeginInfo[i].pInheritanceInfo) {
+                internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
+                    internal_pBeginInfo[i].pInheritanceInfo[0];
+                /* VkCommandBufferInheritanceInfo::renderPass */
+                if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
+                    VK_FROM_HANDLE(
+                        gfxstream_vk_render_pass, gfxstream_renderPass,
+                        internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
+                    internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
+                        gfxstream_renderPass->internal_object;
+                }
+                /* VkCommandBufferInheritanceInfo::framebuffer */
+                if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
+                    VK_FROM_HANDLE(
+                        gfxstream_vk_framebuffer, gfxstream_framebuffer,
+                        internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
+                    internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
+                        gfxstream_framebuffer->internal_object;
+                }
+                internal_pBeginInfo[i].pInheritanceInfo =
+                    &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
+            }
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(
+            vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object,
+            internal_pBeginInfo.data());
+    }
     return vkBeginCommandBuffer_VkResult_return;
 }
-static VkResult entry_vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+VkResult gfxstream_vk_EndCommandBuffer(VkCommandBuffer commandBuffer) {
     AEMU_SCOPED_TRACE("vkEndCommandBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
     VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkEndCommandBuffer_VkResult_return =
-        resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(
+            vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object);
+    }
     return vkEndCommandBuffer_VkResult_return;
 }
-static VkResult entry_vkResetCommandBuffer(VkCommandBuffer commandBuffer,
-                                           VkCommandBufferResetFlags flags) {
+VkResult gfxstream_vk_ResetCommandBuffer(VkCommandBuffer commandBuffer,
+                                         VkCommandBufferResetFlags flags) {
     AEMU_SCOPED_TRACE("vkResetCommandBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
     VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkResetCommandBuffer_VkResult_return =
-        resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(
+            vkEnc, VK_SUCCESS, gfxstream_commandBuffer->internal_object, flags);
+    }
     return vkResetCommandBuffer_VkResult_return;
 }
-static void entry_vkCmdBindPipeline(VkCommandBuffer commandBuffer,
-                                    VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+void gfxstream_vk_CmdBindPipeline(VkCommandBuffer commandBuffer,
+                                  VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
     AEMU_SCOPED_TRACE("vkCmdBindPipeline");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline, pipeline);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdBindPipeline(gfxstream_commandBuffer->internal_object, pipelineBindPoint,
+                                 gfxstream_pipeline->internal_object, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
-                                   uint32_t viewportCount, const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
+                                 uint32_t viewportCount, const VkViewport* pViewports) {
     AEMU_SCOPED_TRACE("vkCmdSetViewport");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports,
-                            true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetViewport(gfxstream_commandBuffer->internal_object, firstViewport,
+                                viewportCount, pViewports, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
-                                  uint32_t scissorCount, const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
+                                uint32_t scissorCount, const VkRect2D* pScissors) {
     AEMU_SCOPED_TRACE("vkCmdSetScissor");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors,
-                           true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetScissor(gfxstream_commandBuffer->internal_object, firstScissor, scissorCount,
+                               pScissors, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+void gfxstream_vk_CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
     AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetLineWidth(gfxstream_commandBuffer->internal_object, lineWidth,
+                                 true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
-                                    float depthBiasClamp, float depthBiasSlopeFactor) {
+void gfxstream_vk_CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
+                                  float depthBiasClamp, float depthBiasSlopeFactor) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
-                             depthBiasSlopeFactor, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthBias(gfxstream_commandBuffer->internal_object, depthBiasConstantFactor,
+                                 depthBiasClamp, depthBiasSlopeFactor, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
-                                         const float blendConstants[4]) {
+void gfxstream_vk_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
+                                       const float blendConstants[4]) {
     AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetBlendConstants(gfxstream_commandBuffer->internal_object, blendConstants,
+                                      true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
-                                      float maxDepthBounds) {
+void gfxstream_vk_CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
+                                    float maxDepthBounds) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthBounds(gfxstream_commandBuffer->internal_object, minDepthBounds,
+                                   maxDepthBounds, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
-                                             VkStencilFaceFlags faceMask, uint32_t compareMask) {
+void gfxstream_vk_CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
+                                           VkStencilFaceFlags faceMask, uint32_t compareMask) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilCompareMask(gfxstream_commandBuffer->internal_object, faceMask,
+                                          compareMask, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
-                                           VkStencilFaceFlags faceMask, uint32_t writeMask) {
+void gfxstream_vk_CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                         uint32_t writeMask) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilWriteMask(gfxstream_commandBuffer->internal_object, faceMask,
+                                        writeMask, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
-                                           VkStencilFaceFlags faceMask, uint32_t reference) {
+void gfxstream_vk_CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                         uint32_t reference) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilReference(gfxstream_commandBuffer->internal_object, faceMask,
+                                        reference, true /* do lock */);
+    }
 }
-static void entry_vkCmdBindDescriptorSets(
+void gfxstream_vk_CmdBindDescriptorSets(
     VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
     uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
     uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
     AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    auto resources = ResourceTracker::get();
-    resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet,
-                                          descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
-                                          pDynamicOffsets);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkCmdBindDescriptorSets(vkEnc, gfxstream_commandBuffer->internal_object,
+                                              pipelineBindPoint, gfxstream_layout->internal_object,
+                                              firstSet, descriptorSetCount, pDescriptorSets,
+                                              dynamicOffsetCount, pDynamicOffsets);
+    }
 }
-static void entry_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                       VkDeviceSize offset, VkIndexType indexType) {
+void gfxstream_vk_CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                     VkDeviceSize offset, VkIndexType indexType) {
     AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, true /* do lock */);
-}
-static void entry_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
-                                         uint32_t bindingCount, const VkBuffer* pBuffers,
-                                         const VkDeviceSize* pOffsets) {
-    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
-                                  true /* do lock */);
-}
-static void entry_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
-                            uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
-    AEMU_SCOPED_TRACE("vkCmdDraw");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance,
-                     true /* do lock */);
-}
-static void entry_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
-                                   uint32_t instanceCount, uint32_t firstIndex,
-                                   int32_t vertexOffset, uint32_t firstInstance) {
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
-                            firstInstance, true /* do lock */);
-}
-static void entry_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                    VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
-}
-static void entry_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                           VkDeviceSize offset, uint32_t drawCount,
-                                           uint32_t stride) {
-    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride,
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdBindIndexBuffer(gfxstream_commandBuffer->internal_object,
+                                    gfxstream_buffer->internal_object, offset, indexType,
                                     true /* do lock */);
+    }
 }
-static void entry_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
-                                uint32_t groupCountY, uint32_t groupCountZ) {
-    AEMU_SCOPED_TRACE("vkCmdDispatch");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ, true /* do lock */);
+void gfxstream_vk_CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                       uint32_t bindingCount, const VkBuffer* pBuffers,
+                                       const VkDeviceSize* pOffsets) {
+    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBuffer> internal_pBuffers(bindingCount);
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            if (pBuffers) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+                internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+            }
+        }
+        vkEnc->vkCmdBindVertexBuffers(gfxstream_commandBuffer->internal_object, firstBinding,
+                                      bindingCount, internal_pBuffers.data(), pOffsets,
+                                      true /* do lock */);
+    }
 }
-static void entry_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                        VkDeviceSize offset) {
-    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset, true /* do lock */);
+void gfxstream_vk_CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
+                          uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+    AEMU_SCOPED_TRACE("vkCmdDraw");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDraw(gfxstream_commandBuffer->internal_object, vertexCount, instanceCount,
+                         firstVertex, firstInstance, true /* do lock */);
+    }
 }
-static void entry_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
-                                  VkBuffer dstBuffer, uint32_t regionCount,
-                                  const VkBufferCopy* pRegions) {
-    AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions,
-                           true /* do lock */);
+void gfxstream_vk_CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+                                 uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+                                 uint32_t firstInstance) {
+    AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDrawIndexed(gfxstream_commandBuffer->internal_object, indexCount, instanceCount,
+                                firstIndex, vertexOffset, firstInstance, true /* do lock */);
+    }
 }
-static void entry_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                 VkImageLayout srcImageLayout, VkImage dstImage,
-                                 VkImageLayout dstImageLayout, uint32_t regionCount,
-                                 const VkImageCopy* pRegions) {
-    AEMU_SCOPED_TRACE("vkCmdCopyImage");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
-                          regionCount, pRegions, true /* do lock */);
-}
-static void entry_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                 VkImageLayout srcImageLayout, VkImage dstImage,
-                                 VkImageLayout dstImageLayout, uint32_t regionCount,
-                                 const VkImageBlit* pRegions, VkFilter filter) {
-    AEMU_SCOPED_TRACE("vkCmdBlitImage");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
-                          regionCount, pRegions, filter, true /* do lock */);
-}
-static void entry_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
-                                         VkImage dstImage, VkImageLayout dstImageLayout,
-                                         uint32_t regionCount, const VkBufferImageCopy* pRegions) {
-    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
-                                  pRegions, true /* do lock */);
-}
-static void entry_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                         VkImageLayout srcImageLayout, VkBuffer dstBuffer,
-                                         uint32_t regionCount, const VkBufferImageCopy* pRegions) {
-    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
-                                  pRegions, true /* do lock */);
-}
-static void entry_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                                    VkDeviceSize dstOffset, VkDeviceSize dataSize,
-                                    const void* pData) {
-    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData,
-                             true /* do lock */);
-}
-static void entry_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
-                                  VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
-    AEMU_SCOPED_TRACE("vkCmdFillBuffer");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data, true /* do lock */);
-}
-static void entry_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
-                                       VkImageLayout imageLayout, const VkClearColorValue* pColor,
-                                       uint32_t rangeCount,
-                                       const VkImageSubresourceRange* pRanges) {
-    AEMU_SCOPED_TRACE("vkCmdClearColorImage");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges,
-                                true /* do lock */);
-}
-static void entry_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
-                                              VkImageLayout imageLayout,
-                                              const VkClearDepthStencilValue* pDepthStencil,
-                                              uint32_t rangeCount,
-                                              const VkImageSubresourceRange* pRanges) {
-    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
-                                       pRanges, true /* do lock */);
-}
-static void entry_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
-                                        const VkClearAttachment* pAttachments, uint32_t rectCount,
-                                        const VkClearRect* pRects) {
-    AEMU_SCOPED_TRACE("vkCmdClearAttachments");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects,
+void gfxstream_vk_CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                  VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDrawIndirect(gfxstream_commandBuffer->internal_object,
+                                 gfxstream_buffer->internal_object, offset, drawCount, stride,
                                  true /* do lock */);
+    }
 }
-static void entry_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
-                                    VkImageLayout srcImageLayout, VkImage dstImage,
-                                    VkImageLayout dstImageLayout, uint32_t regionCount,
-                                    const VkImageResolve* pRegions) {
+void gfxstream_vk_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                         VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDrawIndexedIndirect(gfxstream_commandBuffer->internal_object,
+                                        gfxstream_buffer->internal_object, offset, drawCount,
+                                        stride, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
+                              uint32_t groupCountY, uint32_t groupCountZ) {
+    AEMU_SCOPED_TRACE("vkCmdDispatch");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDispatch(gfxstream_commandBuffer->internal_object, groupCountX, groupCountY,
+                             groupCountZ, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                      VkDeviceSize offset) {
+    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDispatchIndirect(gfxstream_commandBuffer->internal_object,
+                                     gfxstream_buffer->internal_object, offset, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                                VkBuffer dstBuffer, uint32_t regionCount,
+                                const VkBufferCopy* pRegions) {
+    AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdCopyBuffer(
+            gfxstream_commandBuffer->internal_object, gfxstream_srcBuffer->internal_object,
+            gfxstream_dstBuffer->internal_object, regionCount, pRegions, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                               VkImageLayout srcImageLayout, VkImage dstImage,
+                               VkImageLayout dstImageLayout, uint32_t regionCount,
+                               const VkImageCopy* pRegions) {
+    AEMU_SCOPED_TRACE("vkCmdCopyImage");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdCopyImage(gfxstream_commandBuffer->internal_object,
+                              gfxstream_srcImage->internal_object, srcImageLayout,
+                              gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+                              pRegions, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                               VkImageLayout srcImageLayout, VkImage dstImage,
+                               VkImageLayout dstImageLayout, uint32_t regionCount,
+                               const VkImageBlit* pRegions, VkFilter filter) {
+    AEMU_SCOPED_TRACE("vkCmdBlitImage");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdBlitImage(gfxstream_commandBuffer->internal_object,
+                              gfxstream_srcImage->internal_object, srcImageLayout,
+                              gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+                              pRegions, filter, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
+                                       VkImage dstImage, VkImageLayout dstImageLayout,
+                                       uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer, srcBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdCopyBufferToImage(gfxstream_commandBuffer->internal_object,
+                                      gfxstream_srcBuffer->internal_object,
+                                      gfxstream_dstImage->internal_object, dstImageLayout,
+                                      regionCount, pRegions, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                       VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+                                       uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdCopyImageToBuffer(gfxstream_commandBuffer->internal_object,
+                                      gfxstream_srcImage->internal_object, srcImageLayout,
+                                      gfxstream_dstBuffer->internal_object, regionCount, pRegions,
+                                      true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                                  VkDeviceSize dstOffset, VkDeviceSize dataSize,
+                                  const void* pData) {
+    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdUpdateBuffer(gfxstream_commandBuffer->internal_object,
+                                 gfxstream_dstBuffer->internal_object, dstOffset, dataSize, pData,
+                                 true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
+                                VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+    AEMU_SCOPED_TRACE("vkCmdFillBuffer");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdFillBuffer(gfxstream_commandBuffer->internal_object,
+                               gfxstream_dstBuffer->internal_object, dstOffset, size, data,
+                               true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
+                                     VkImageLayout imageLayout, const VkClearColorValue* pColor,
+                                     uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+    AEMU_SCOPED_TRACE("vkCmdClearColorImage");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdClearColorImage(gfxstream_commandBuffer->internal_object,
+                                    gfxstream_image->internal_object, imageLayout, pColor,
+                                    rangeCount, pRanges, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
+                                            VkImageLayout imageLayout,
+                                            const VkClearDepthStencilValue* pDepthStencil,
+                                            uint32_t rangeCount,
+                                            const VkImageSubresourceRange* pRanges) {
+    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdClearDepthStencilImage(gfxstream_commandBuffer->internal_object,
+                                           gfxstream_image->internal_object, imageLayout,
+                                           pDepthStencil, rangeCount, pRanges, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                      const VkClearAttachment* pAttachments, uint32_t rectCount,
+                                      const VkClearRect* pRects) {
+    AEMU_SCOPED_TRACE("vkCmdClearAttachments");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdClearAttachments(gfxstream_commandBuffer->internal_object, attachmentCount,
+                                     pAttachments, rectCount, pRects, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
+                                  VkImageLayout srcImageLayout, VkImage dstImage,
+                                  VkImageLayout dstImageLayout, uint32_t regionCount,
+                                  const VkImageResolve* pRegions) {
     AEMU_SCOPED_TRACE("vkCmdResolveImage");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
-                             regionCount, pRegions, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage, srcImage);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage, dstImage);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdResolveImage(gfxstream_commandBuffer->internal_object,
+                                 gfxstream_srcImage->internal_object, srcImageLayout,
+                                 gfxstream_dstImage->internal_object, dstImageLayout, regionCount,
+                                 pRegions, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                                VkPipelineStageFlags stageMask) {
+void gfxstream_vk_CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                              VkPipelineStageFlags stageMask) {
     AEMU_SCOPED_TRACE("vkCmdSetEvent");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetEvent(gfxstream_commandBuffer->internal_object,
+                             gfxstream_event->internal_object, stageMask, true /* do lock */);
+    }
 }
-static void entry_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
-                                  VkPipelineStageFlags stageMask) {
+void gfxstream_vk_CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
+                                VkPipelineStageFlags stageMask) {
     AEMU_SCOPED_TRACE("vkCmdResetEvent");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdResetEvent(gfxstream_commandBuffer->internal_object,
+                               gfxstream_event->internal_object, stageMask, true /* do lock */);
+    }
 }
-static void entry_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
-                                  const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
-                                  VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
-                                  const VkMemoryBarrier* pMemoryBarriers,
-                                  uint32_t bufferMemoryBarrierCount,
-                                  const VkBufferMemoryBarrier* pBufferMemoryBarriers,
-                                  uint32_t imageMemoryBarrierCount,
-                                  const VkImageMemoryBarrier* pImageMemoryBarriers) {
+void gfxstream_vk_CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                                const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
+                                VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
+                                const VkMemoryBarrier* pMemoryBarriers,
+                                uint32_t bufferMemoryBarrierCount,
+                                const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                uint32_t imageMemoryBarrierCount,
+                                const VkImageMemoryBarrier* pImageMemoryBarriers) {
     AEMU_SCOPED_TRACE("vkCmdWaitEvents");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
-                           memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
-                           pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers,
-                           true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkEvent> internal_pEvents(eventCount);
+        for (uint32_t i = 0; i < eventCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+            internal_pEvents[i] = gfxstream_pEvents->internal_object;
+        }
+        std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
+            /* VkBufferMemoryBarrier::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                           internal_pBufferMemoryBarriers[i].buffer);
+            internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
+        }
+        std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
+            /* VkImageMemoryBarrier::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                           internal_pImageMemoryBarriers[i].image);
+            internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
+        }
+        vkEnc->vkCmdWaitEvents(gfxstream_commandBuffer->internal_object, eventCount,
+                               internal_pEvents.data(), srcStageMask, dstStageMask,
+                               memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+                               internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
+                               internal_pImageMemoryBarriers.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdPipelineBarrier(
+void gfxstream_vk_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) {
     AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    auto resources = ResourceTracker::get();
-    resources->on_vkCmdPipelineBarrier(vkEnc, commandBuffer, srcStageMask, dstStageMask,
-                                       dependencyFlags, memoryBarrierCount, pMemoryBarriers,
-                                       bufferMemoryBarrierCount, pBufferMemoryBarriers,
-                                       imageMemoryBarrierCount, pImageMemoryBarriers);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBufferMemoryBarrier> internal_pBufferMemoryBarriers(bufferMemoryBarrierCount);
+        for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) {
+            internal_pBufferMemoryBarriers[i] = pBufferMemoryBarriers[i];
+            /* VkBufferMemoryBarrier::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                           internal_pBufferMemoryBarriers[i].buffer);
+            internal_pBufferMemoryBarriers[i].buffer = gfxstream_buffer->internal_object;
+        }
+        std::vector<VkImageMemoryBarrier> internal_pImageMemoryBarriers(imageMemoryBarrierCount);
+        for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
+            internal_pImageMemoryBarriers[i] = pImageMemoryBarriers[i];
+            /* VkImageMemoryBarrier::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                           internal_pImageMemoryBarriers[i].image);
+            internal_pImageMemoryBarriers[i].image = gfxstream_image->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkCmdPipelineBarrier(
+            vkEnc, gfxstream_commandBuffer->internal_object, srcStageMask, dstStageMask,
+            dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
+            internal_pBufferMemoryBarriers.data(), imageMemoryBarrierCount,
+            internal_pImageMemoryBarriers.data());
+    }
 }
-static void entry_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                  uint32_t query, VkQueryControlFlags flags) {
+void gfxstream_vk_CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                uint32_t query, VkQueryControlFlags flags) {
     AEMU_SCOPED_TRACE("vkCmdBeginQuery");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags, true /* do lock */);
-}
-static void entry_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                uint32_t query) {
-    AEMU_SCOPED_TRACE("vkCmdEndQuery");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query, true /* do lock */);
-}
-static void entry_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                      uint32_t firstQuery, uint32_t queryCount) {
-    AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount,
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdBeginQuery(gfxstream_commandBuffer->internal_object,
+                               gfxstream_queryPool->internal_object, query, flags,
                                true /* do lock */);
+    }
 }
-static void entry_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
-                                      VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
-                                      uint32_t query) {
+void gfxstream_vk_CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                              uint32_t query) {
+    AEMU_SCOPED_TRACE("vkCmdEndQuery");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndQuery(gfxstream_commandBuffer->internal_object,
+                             gfxstream_queryPool->internal_object, query, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                    uint32_t firstQuery, uint32_t queryCount) {
+    AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdResetQueryPool(gfxstream_commandBuffer->internal_object,
+                                   gfxstream_queryPool->internal_object, firstQuery, queryCount,
+                                   true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdWriteTimestamp(VkCommandBuffer commandBuffer,
+                                    VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
+                                    uint32_t query) {
     AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdWriteTimestamp(gfxstream_commandBuffer->internal_object, pipelineStage,
+                                   gfxstream_queryPool->internal_object, query, true /* do lock */);
+    }
 }
-static void entry_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                            uint32_t firstQuery, uint32_t queryCount,
-                                            VkBuffer dstBuffer, VkDeviceSize dstOffset,
-                                            VkDeviceSize stride, VkQueryResultFlags flags) {
+void gfxstream_vk_CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                          uint32_t firstQuery, uint32_t queryCount,
+                                          VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                          VkDeviceSize stride, VkQueryResultFlags flags) {
     AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
-                                     dstOffset, stride, flags, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdCopyQueryPoolResults(gfxstream_commandBuffer->internal_object,
+                                         gfxstream_queryPool->internal_object, firstQuery,
+                                         queryCount, gfxstream_dstBuffer->internal_object,
+                                         dstOffset, stride, flags, true /* do lock */);
+    }
 }
-static void entry_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
-                                     VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
-                                     const void* pValues) {
+void gfxstream_vk_CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
+                                   VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
+                                   const void* pValues) {
     AEMU_SCOPED_TRACE("vkCmdPushConstants");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues,
-                              true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_layout, layout);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdPushConstants(gfxstream_commandBuffer->internal_object,
+                                  gfxstream_layout->internal_object, stageFlags, offset, size,
+                                  pValues, true /* do lock */);
+    }
 }
-static void entry_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
-                                       const VkRenderPassBeginInfo* pRenderPassBegin,
-                                       VkSubpassContents contents) {
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents, true /* do lock */);
-}
-static void entry_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+void gfxstream_vk_CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
     AEMU_SCOPED_TRACE("vkCmdNextSubpass");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdNextSubpass(commandBuffer, contents, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdNextSubpass(gfxstream_commandBuffer->internal_object, contents,
+                                true /* do lock */);
+    }
 }
-static void entry_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRenderPass(VkCommandBuffer commandBuffer) {
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRenderPass(commandBuffer, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndRenderPass(gfxstream_commandBuffer->internal_object, true /* do lock */);
+    }
 }
-static void entry_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
-                                       const VkCommandBuffer* pCommandBuffers) {
+void gfxstream_vk_CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
+                                     const VkCommandBuffer* pCommandBuffers) {
     AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    auto resources = ResourceTracker::get();
-    resources->on_vkCmdExecuteCommands(vkEnc, commandBuffer, commandBufferCount, pCommandBuffers);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCommandBuffer> internal_pCommandBuffers(commandBufferCount);
+        for (uint32_t i = 0; i < commandBufferCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+                           pCommandBuffers[i]);
+            internal_pCommandBuffers[i] = gfxstream_pCommandBuffers->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkCmdExecuteCommands(vkEnc, gfxstream_commandBuffer->internal_object,
+                                           commandBufferCount, internal_pCommandBuffers.data());
+    }
 }
 #endif
 #ifdef VK_VERSION_1_1
-static VkResult entry_vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
-    AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
-    vkEnumerateInstanceVersion_VkResult_return =
-        vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
-    return vkEnumerateInstanceVersion_VkResult_return;
-}
-static VkResult entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
-                                          const VkBindBufferMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+                                        const VkBindBufferMemoryInfo* pBindInfos) {
     AEMU_SCOPED_TRACE("vkBindBufferMemory2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBindBufferMemory2_VkResult_return =
-        resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; ++i) {
+            internal_pBindInfos[i] = pBindInfos[i];
+            /* VkBindBufferMemoryInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
+            internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
+            /* VkBindBufferMemoryInfo::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                           internal_pBindInfos[i].memory);
+            internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBindBufferMemory2_VkResult_return =
+            resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+                                              bindInfoCount, internal_pBindInfos.data());
+    }
     return vkBindBufferMemory2_VkResult_return;
 }
-static VkResult dynCheck_entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
-                                                   const VkBindBufferMemoryInfo* pBindInfos) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
-    }
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
-    vkBindBufferMemory2_VkResult_return =
-        resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
-    return vkBindBufferMemory2_VkResult_return;
-}
-static VkResult entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
-                                         const VkBindImageMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+                                       const VkBindImageMemoryInfo* pBindInfos) {
     AEMU_SCOPED_TRACE("vkBindImageMemory2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBindImageMemory2_VkResult_return =
-        resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; ++i) {
+            internal_pBindInfos[i] = pBindInfos[i];
+            /* VkBindImageMemoryInfo::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
+            internal_pBindInfos[i].image = gfxstream_image->internal_object;
+            /* VkBindImageMemoryInfo::memory */
+            if (internal_pBindInfos[i].memory) {
+                VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                               internal_pBindInfos[i].memory);
+                internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+            }
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBindImageMemory2_VkResult_return =
+            resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+                                             bindInfoCount, internal_pBindInfos.data());
+    }
     return vkBindImageMemory2_VkResult_return;
 }
-static VkResult dynCheck_entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
-                                                  const VkBindImageMemoryInfo* pBindInfos) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
-    }
-    AEMU_SCOPED_TRACE("vkBindImageMemory2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
-    vkBindImageMemory2_VkResult_return =
-        resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
-    return vkBindImageMemory2_VkResult_return;
-}
-static void entry_vkGetDeviceGroupPeerMemoryFeatures(
-    VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
-    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
+void gfxstream_vk_GetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex,
+                                                   uint32_t localDeviceIndex,
+                                                   uint32_t remoteDeviceIndex,
+                                                   VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
     AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
-                                              remoteDeviceIndex, pPeerMemoryFeatures,
-                                              true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures(
-    VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
-    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeatures", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceGroupPeerMemoryFeatures(gfxstream_device->internal_object, heapIndex,
+                                                  localDeviceIndex, remoteDeviceIndex,
+                                                  pPeerMemoryFeatures, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
-                                              remoteDeviceIndex, pPeerMemoryFeatures,
-                                              true /* do lock */);
 }
-static void entry_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
+void gfxstream_vk_CmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
     AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDeviceMask(gfxstream_commandBuffer->internal_object, deviceMask,
+                                  true /* do lock */);
+    }
 }
-static void entry_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
-                                    uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
-                                    uint32_t groupCountY, uint32_t groupCountZ) {
+void gfxstream_vk_CmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
+                                  uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
+                                  uint32_t groupCountY, uint32_t groupCountZ) {
     AEMU_SCOPED_TRACE("vkCmdDispatchBase");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
-                             groupCountY, groupCountZ, true /* do lock */);
-}
-static VkResult entry_vkEnumeratePhysicalDeviceGroups(
-    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
-    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
-    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
-    vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(
-        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
-    return vkEnumeratePhysicalDeviceGroups_VkResult_return;
-}
-static void entry_vkGetImageMemoryRequirements2(VkDevice device,
-                                                const VkImageMemoryRequirementsInfo2* pInfo,
-                                                VkMemoryRequirements2* pMemoryRequirements) {
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetImageMemoryRequirements2(
-    VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDispatchBase(gfxstream_commandBuffer->internal_object, baseGroupX, baseGroupY,
+                                 baseGroupZ, groupCountX, groupCountY, groupCountZ,
+                                 true /* do lock */);
     }
+}
+void gfxstream_vk_GetImageMemoryRequirements2(VkDevice device,
+                                              const VkImageMemoryRequirementsInfo2* pInfo,
+                                              VkMemoryRequirements2* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void entry_vkGetBufferMemoryRequirements2(VkDevice device,
-                                                 const VkBufferMemoryRequirementsInfo2* pInfo,
-                                                 VkMemoryRequirements2* pMemoryRequirements) {
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetBufferMemoryRequirements2(
-    VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkImageMemoryRequirementsInfo2::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+            internal_pInfo[i].image = gfxstream_image->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetImageMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
+                                                    internal_pInfo.data(), pMemoryRequirements);
     }
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
 }
-static void entry_vkGetImageSparseMemoryRequirements2(
+void gfxstream_vk_GetBufferMemoryRequirements2(VkDevice device,
+                                               const VkBufferMemoryRequirementsInfo2* pInfo,
+                                               VkMemoryRequirements2* pMemoryRequirements) {
+    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkBufferMemoryRequirementsInfo2::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+            internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetBufferMemoryRequirements2(vkEnc, gfxstream_device->internal_object,
+                                                     internal_pInfo.data(), pMemoryRequirements);
+    }
+}
+void gfxstream_vk_GetImageSparseMemoryRequirements2(
     VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
-                                               pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSparseMemoryRequirements2(
-    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
-    uint32_t* pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkImageSparseMemoryRequirementsInfo2::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+            internal_pInfo[i].image = gfxstream_image->internal_object;
+        }
+        vkEnc->vkGetImageSparseMemoryRequirements2(
+            gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
+            pSparseMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
-                                               pSparseMemoryRequirements, true /* do lock */);
 }
-static void entry_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
-                                               VkPhysicalDeviceFeatures2* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
+                                             VkPhysicalDeviceFeatures2* pFeatures) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceFeatures2(gfxstream_physicalDevice->internal_object, pFeatures,
+                                            true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
-                                                 VkPhysicalDeviceProperties2* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
+                                               VkPhysicalDeviceProperties2* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceProperties2(gfxstream_physicalDevice->internal_object,
+                                              pProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
-                                                       VkFormat format,
-                                                       VkFormatProperties2* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
+                                                     VkFormat format,
+                                                     VkFormatProperties2* pFormatProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties,
-                                                true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceFormatProperties2(gfxstream_physicalDevice->internal_object,
+                                                    format, pFormatProperties, true /* do lock */);
+    }
 }
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
     VkImageFormatProperties2* pImageFormatProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
-        resources->on_vkGetPhysicalDeviceImageFormatProperties2(
-            vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
+            resources->on_vkGetPhysicalDeviceImageFormatProperties2(
+                vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
+                pImageFormatProperties);
+    }
     return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
 }
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2(
     VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties2* pQueueFamilyProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
-                                                     pQueueFamilyProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(
+            gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
+            pQueueFamilyProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceMemoryProperties2(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties2(
     VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties,
-                                                true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceMemoryProperties2(gfxstream_physicalDevice->internal_object,
+                                                    pMemoryProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
     uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
-        physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
-}
-static void entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
-                                    VkCommandPoolTrimFlags flags) {
-    AEMU_SCOPED_TRACE("vkTrimCommandPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
-}
-static void dynCheck_entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
-                                             VkCommandPoolTrimFlags flags) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkTrimCommandPool", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
+            gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
+            true /* do lock */);
     }
+}
+void gfxstream_vk_TrimCommandPool(VkDevice device, VkCommandPool commandPool,
+                                  VkCommandPoolTrimFlags flags) {
     AEMU_SCOPED_TRACE("vkTrimCommandPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
-}
-static void entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
-                                    VkQueue* pQueue) {
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
-                                             VkQueue* pQueue) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceQueue2", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkTrimCommandPool(gfxstream_device->internal_object,
+                                 gfxstream_commandPool->internal_object, flags, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
 }
-static VkResult entry_vkCreateSamplerYcbcrConversion(
+VkResult gfxstream_vk_CreateSamplerYcbcrConversion(
     VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
     const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
     AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
-        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateSamplerYcbcrConversion_VkResult_return =
+            resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS,
+                                                         gfxstream_device->internal_object,
+                                                         pCreateInfo, pAllocator, pYcbcrConversion);
+    }
     return vkCreateSamplerYcbcrConversion_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
-    VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
-    }
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
-    vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
-        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
-    return vkCreateSamplerYcbcrConversion_VkResult_return;
-}
-static void entry_vkDestroySamplerYcbcrConversion(VkDevice device,
-                                                  VkSamplerYcbcrConversion ycbcrConversion,
-                                                  const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySamplerYcbcrConversion(VkDevice device,
+                                                VkSamplerYcbcrConversion ycbcrConversion,
+                                                const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
-}
-static void dynCheck_entry_vkDestroySamplerYcbcrConversion(
-    VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-    const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversion", "VK_VERSION_1_1");
+    if (VK_NULL_HANDLE == ycbcrConversion) {
+        return;
     }
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroySamplerYcbcrConversion(vkEnc, gfxstream_device->internal_object,
+                                                      ycbcrConversion, pAllocator);
+    }
 }
-static VkResult entry_vkCreateDescriptorUpdateTemplate(
+VkResult gfxstream_vk_CreateDescriptorUpdateTemplate(
     VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
     AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
-    vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
-        device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
-    return vkCreateDescriptorUpdateTemplate_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplate(
-    VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
+        (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
+            &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
+            VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
+    vkCreateDescriptorUpdateTemplate_VkResult_return =
+        gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateDescriptorUpdateTemplate_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCreateInfo[i] = pCreateInfo[i];
+            /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
+            if (internal_pCreateInfo[i].descriptorSetLayout) {
+                VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+                               internal_pCreateInfo[i].descriptorSetLayout);
+                internal_pCreateInfo[i].descriptorSetLayout =
+                    gfxstream_descriptorSetLayout->internal_object;
+            }
+            /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
+            if (internal_pCreateInfo[i].pipelineLayout) {
+                VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
+                               internal_pCreateInfo[i].pipelineLayout);
+                internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
+            }
+        }
+        vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
+            gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+            &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
-    vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
-        device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
+    *pDescriptorUpdateTemplate =
+        gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
     return vkCreateDescriptorUpdateTemplate_VkResult_return;
 }
-static void entry_vkDestroyDescriptorUpdateTemplate(
+void gfxstream_vk_DestroyDescriptorUpdateTemplate(
     VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
-                                             true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyDescriptorUpdateTemplate(
-    VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-    const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1");
+    if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
+        return;
     }
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
-                                             true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+                   descriptorUpdateTemplate);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyDescriptorUpdateTemplate(
+            gfxstream_device->internal_object,
+            gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
+                                               : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
 }
-static void entry_vkUpdateDescriptorSetWithTemplate(
+void gfxstream_vk_UpdateDescriptorSetWithTemplate(
     VkDevice device, VkDescriptorSet descriptorSet,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
-                                                    descriptorUpdateTemplate, pData);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplate(
-    VkDevice device, VkDescriptorSet descriptorSet,
-    VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplate", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+                   descriptorUpdateTemplate);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkUpdateDescriptorSetWithTemplate(
+            vkEnc, gfxstream_device->internal_object, descriptorSet,
+            gfxstream_descriptorUpdateTemplate->internal_object, pData);
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
-                                                    descriptorUpdateTemplate, pData);
 }
-static void entry_vkGetPhysicalDeviceExternalBufferProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalBufferProperties(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
     VkExternalBufferProperties* pExternalBufferProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetPhysicalDeviceExternalBufferProperties(
-        vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetPhysicalDeviceExternalBufferProperties(
+            vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
+            pExternalBufferProperties);
+    }
 }
-static void entry_vkGetPhysicalDeviceExternalFenceProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalFenceProperties(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
     VkExternalFenceProperties* pExternalFenceProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetPhysicalDeviceExternalFenceProperties(
-        vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetPhysicalDeviceExternalFenceProperties(
+            vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
+            pExternalFenceProperties);
+    }
 }
-static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
+void gfxstream_vk_GetPhysicalDeviceExternalSemaphoreProperties(
     VkPhysicalDevice physicalDevice,
     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
     VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
-        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
-}
-static void entry_vkGetDescriptorSetLayoutSupport(
-    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    VkDescriptorSetLayoutSupport* pSupport) {
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDescriptorSetLayoutSupport(
-    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    VkDescriptorSetLayoutSupport* pSupport) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupport", "VK_VERSION_1_1");
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
+            gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
+            pExternalSemaphoreProperties, true /* do lock */);
     }
+}
+void gfxstream_vk_GetDescriptorSetLayoutSupport(VkDevice device,
+                                                const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
+                                                VkDescriptorSetLayoutSupport* pSupport) {
     AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDescriptorSetLayoutSupport(gfxstream_device->internal_object, pCreateInfo,
+                                               pSupport, true /* do lock */);
+    }
 }
 #endif
 #ifdef VK_VERSION_1_2
-static void entry_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                         VkDeviceSize offset, VkBuffer countBuffer,
-                                         VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-                                         uint32_t stride) {
+void gfxstream_vk_CmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                       VkDeviceSize offset, VkBuffer countBuffer,
+                                       VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                       uint32_t stride) {
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
-                                  maxDrawCount, stride, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDrawIndirectCount(gfxstream_commandBuffer->internal_object,
+                                      gfxstream_buffer->internal_object, offset,
+                                      gfxstream_countBuffer->internal_object, countBufferOffset,
+                                      maxDrawCount, stride, true /* do lock */);
+    }
 }
-static void entry_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                                VkDeviceSize offset, VkBuffer countBuffer,
-                                                VkDeviceSize countBufferOffset,
-                                                uint32_t maxDrawCount, uint32_t stride) {
+void gfxstream_vk_CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                              VkDeviceSize offset, VkBuffer countBuffer,
+                                              VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                              uint32_t stride) {
     AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer,
-                                         countBufferOffset, maxDrawCount, stride,
-                                         true /* do lock */);
-}
-static VkResult entry_vkCreateRenderPass2(VkDevice device,
-                                          const VkRenderPassCreateInfo2* pCreateInfo,
-                                          const VkAllocationCallbacks* pAllocator,
-                                          VkRenderPass* pRenderPass) {
-    AEMU_SCOPED_TRACE("vkCreateRenderPass2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
-    vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
-        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
-    return vkCreateRenderPass2_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateRenderPass2(VkDevice device,
-                                                   const VkRenderPassCreateInfo2* pCreateInfo,
-                                                   const VkAllocationCallbacks* pAllocator,
-                                                   VkRenderPass* pRenderPass) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2", "VK_VERSION_1_2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_countBuffer, countBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDrawIndexedIndirectCount(
+            gfxstream_commandBuffer->internal_object, gfxstream_buffer->internal_object, offset,
+            gfxstream_countBuffer->internal_object, countBufferOffset, maxDrawCount, stride,
+            true /* do lock */);
     }
+}
+VkResult gfxstream_vk_CreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo,
+                                        const VkAllocationCallbacks* pAllocator,
+                                        VkRenderPass* pRenderPass) {
     AEMU_SCOPED_TRACE("vkCreateRenderPass2");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
-    vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
-        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+        (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                    sizeof(gfxstream_vk_render_pass),
+                                                    VK_OBJECT_TYPE_RENDER_PASS);
+    vkCreateRenderPass2_VkResult_return =
+        gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateRenderPass2_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateRenderPass2_VkResult_return =
+            vkEnc->vkCreateRenderPass2(gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                                       &gfxstream_pRenderPass->internal_object, true /* do lock */);
+    }
+    *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
     return vkCreateRenderPass2_VkResult_return;
 }
-static void entry_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
-                                        const VkRenderPassBeginInfo* pRenderPassBegin,
-                                        const VkSubpassBeginInfo* pSubpassBeginInfo) {
+void gfxstream_vk_CmdBeginRenderPass2(VkCommandBuffer commandBuffer,
+                                      const VkRenderPassBeginInfo* pRenderPassBegin,
+                                      const VkSubpassBeginInfo* pSubpassBeginInfo) {
     AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
-                                 true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkRenderPassBeginInfo> internal_pRenderPassBegin(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pRenderPassBegin[i] = pRenderPassBegin[i];
+            /* VkRenderPassBeginInfo::renderPass */
+            VK_FROM_HANDLE(gfxstream_vk_render_pass, gfxstream_renderPass,
+                           internal_pRenderPassBegin[i].renderPass);
+            internal_pRenderPassBegin[i].renderPass = gfxstream_renderPass->internal_object;
+            /* VkRenderPassBeginInfo::framebuffer */
+            VK_FROM_HANDLE(gfxstream_vk_framebuffer, gfxstream_framebuffer,
+                           internal_pRenderPassBegin[i].framebuffer);
+            internal_pRenderPassBegin[i].framebuffer = gfxstream_framebuffer->internal_object;
+        }
+        vkEnc->vkCmdBeginRenderPass2(gfxstream_commandBuffer->internal_object,
+                                     internal_pRenderPassBegin.data(), pSubpassBeginInfo,
+                                     true /* do lock */);
+    }
 }
-static void entry_vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
-                                    const VkSubpassBeginInfo* pSubpassBeginInfo,
-                                    const VkSubpassEndInfo* pSubpassEndInfo) {
+void gfxstream_vk_CmdNextSubpass2(VkCommandBuffer commandBuffer,
+                                  const VkSubpassBeginInfo* pSubpassBeginInfo,
+                                  const VkSubpassEndInfo* pSubpassEndInfo) {
     AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdNextSubpass2(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
+                                 pSubpassEndInfo, true /* do lock */);
+    }
 }
-static void entry_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
-                                      const VkSubpassEndInfo* pSubpassEndInfo) {
+void gfxstream_vk_CmdEndRenderPass2(VkCommandBuffer commandBuffer,
+                                    const VkSubpassEndInfo* pSubpassEndInfo) {
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
-                                   uint32_t queryCount) {
-    AEMU_SCOPED_TRACE("vkResetQueryPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
-}
-static void dynCheck_entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
-                                            uint32_t firstQuery, uint32_t queryCount) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkResetQueryPool", "VK_VERSION_1_2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndRenderPass2(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
+                                   true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkResetQueryPool");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
 }
-static VkResult entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
-                                                 uint64_t* pValue) {
+void gfxstream_vk_ResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                 uint32_t queryCount) {
+    AEMU_SCOPED_TRACE("vkResetQueryPool");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkResetQueryPool(gfxstream_device->internal_object,
+                                gfxstream_queryPool->internal_object, firstQuery, queryCount,
+                                true /* do lock */);
+    }
+}
+VkResult gfxstream_vk_GetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
+                                               uint64_t* pValue) {
     AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
-    vkGetSemaphoreCounterValue_VkResult_return =
-        vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetSemaphoreCounterValue_VkResult_return = vkEnc->vkGetSemaphoreCounterValue(
+            gfxstream_device->internal_object, gfxstream_semaphore->internal_object, pValue,
+            true /* do lock */);
+    }
     return vkGetSemaphoreCounterValue_VkResult_return;
 }
-static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
-                                                          uint64_t* pValue) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValue", "VK_VERSION_1_2");
-    }
-    AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
-    vkGetSemaphoreCounterValue_VkResult_return =
-        vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
-    return vkGetSemaphoreCounterValue_VkResult_return;
-}
-static VkResult entry_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
-                                       uint64_t timeout) {
+VkResult gfxstream_vk_WaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
+                                     uint64_t timeout) {
     AEMU_SCOPED_TRACE("vkWaitSemaphores");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
-    vkWaitSemaphores_VkResult_return =
-        vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkSemaphoreWaitInfo> internal_pWaitInfo(1);
+        std::vector<std::vector<VkSemaphore>> internal_VkSemaphoreWaitInfo_pSemaphores;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pWaitInfo[i] = pWaitInfo[i];
+            /* VkSemaphoreWaitInfo::pSemaphores */
+            internal_VkSemaphoreWaitInfo_pSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkSemaphoreWaitInfo_pSemaphores[i] = transformVkSemaphoreList(
+                internal_pWaitInfo[i].pSemaphores, internal_pWaitInfo[i].semaphoreCount);
+            internal_pWaitInfo[i].pSemaphores = internal_VkSemaphoreWaitInfo_pSemaphores[i].data();
+            internal_pWaitInfo[i].semaphoreCount =
+                internal_VkSemaphoreWaitInfo_pSemaphores[i].size();
+        }
+        vkWaitSemaphores_VkResult_return =
+            vkEnc->vkWaitSemaphores(gfxstream_device->internal_object, internal_pWaitInfo.data(),
+                                    timeout, true /* do lock */);
+    }
     return vkWaitSemaphores_VkResult_return;
 }
-static VkResult dynCheck_entry_vkWaitSemaphores(VkDevice device,
-                                                const VkSemaphoreWaitInfo* pWaitInfo,
-                                                uint64_t timeout) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkWaitSemaphores", "VK_VERSION_1_2");
-    }
-    AEMU_SCOPED_TRACE("vkWaitSemaphores");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
-    vkWaitSemaphores_VkResult_return =
-        vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
-    return vkWaitSemaphores_VkResult_return;
-}
-static VkResult entry_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
+VkResult gfxstream_vk_SignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
     AEMU_SCOPED_TRACE("vkSignalSemaphore");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
-    vkSignalSemaphore_VkResult_return =
-        vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkSemaphoreSignalInfo> internal_pSignalInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pSignalInfo[i] = pSignalInfo[i];
+            /* VkSemaphoreSignalInfo::semaphore */
+            VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+                           internal_pSignalInfo[i].semaphore);
+            internal_pSignalInfo[i].semaphore = gfxstream_semaphore->internal_object;
+        }
+        vkSignalSemaphore_VkResult_return = vkEnc->vkSignalSemaphore(
+            gfxstream_device->internal_object, internal_pSignalInfo.data(), true /* do lock */);
+    }
     return vkSignalSemaphore_VkResult_return;
 }
-static VkResult dynCheck_entry_vkSignalSemaphore(VkDevice device,
-                                                 const VkSemaphoreSignalInfo* pSignalInfo) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkSignalSemaphore", "VK_VERSION_1_2");
-    }
-    AEMU_SCOPED_TRACE("vkSignalSemaphore");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
-    vkSignalSemaphore_VkResult_return =
-        vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
-    return vkSignalSemaphore_VkResult_return;
-}
-static VkDeviceAddress entry_vkGetBufferDeviceAddress(VkDevice device,
-                                                      const VkBufferDeviceAddressInfo* pInfo) {
+VkDeviceAddress gfxstream_vk_GetBufferDeviceAddress(VkDevice device,
+                                                    const VkBufferDeviceAddressInfo* pInfo) {
     AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
-    vkGetBufferDeviceAddress_VkDeviceAddress_return =
-        vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkBufferDeviceAddressInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+            internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        vkGetBufferDeviceAddress_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddress(
+            gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+    }
     return vkGetBufferDeviceAddress_VkDeviceAddress_return;
 }
-static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddress(
-    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddress", "VK_VERSION_1_2");
-    }
-    AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
-    vkGetBufferDeviceAddress_VkDeviceAddress_return =
-        vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
-    return vkGetBufferDeviceAddress_VkDeviceAddress_return;
-}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddress(VkDevice device,
-                                                      const VkBufferDeviceAddressInfo* pInfo) {
+uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddress(VkDevice device,
+                                                    const VkBufferDeviceAddressInfo* pInfo) {
     AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
-    vkGetBufferOpaqueCaptureAddress_uint64_t_return =
-        vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkBufferDeviceAddressInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+            internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        vkGetBufferOpaqueCaptureAddress_uint64_t_return = vkEnc->vkGetBufferOpaqueCaptureAddress(
+            gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+    }
     return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
 }
-static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddress(
-    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddress", "VK_VERSION_1_2");
-    }
-    AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
-    vkGetBufferOpaqueCaptureAddress_uint64_t_return =
-        vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
-    return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
-}
-static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddress(
+uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddress(
     VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
     AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
-    vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
-        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
-    return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
-}
-static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress(
-    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddress", "VK_VERSION_1_2");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+            internal_pInfo[i].memory = gfxstream_memory->internal_object;
+        }
+        vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
+            vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(gfxstream_device->internal_object,
+                                                         internal_pInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
-    vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
-        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
     return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
 }
 #endif
 #ifdef VK_VERSION_1_3
-static VkResult entry_vkGetPhysicalDeviceToolProperties(
+VkResult gfxstream_vk_GetPhysicalDeviceToolProperties(
     VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
     VkPhysicalDeviceToolProperties* pToolProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolProperties");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
-    vkGetPhysicalDeviceToolProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceToolProperties(
-        physicalDevice, pToolCount, pToolProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetPhysicalDeviceToolProperties_VkResult_return =
+            vkEnc->vkGetPhysicalDeviceToolProperties(gfxstream_physicalDevice->internal_object,
+                                                     pToolCount, pToolProperties,
+                                                     true /* do lock */);
+    }
     return vkGetPhysicalDeviceToolProperties_VkResult_return;
 }
-static VkResult entry_vkCreatePrivateDataSlot(VkDevice device,
-                                              const VkPrivateDataSlotCreateInfo* pCreateInfo,
-                                              const VkAllocationCallbacks* pAllocator,
-                                              VkPrivateDataSlot* pPrivateDataSlot) {
+VkResult gfxstream_vk_CreatePrivateDataSlot(VkDevice device,
+                                            const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                            const VkAllocationCallbacks* pAllocator,
+                                            VkPrivateDataSlot* pPrivateDataSlot) {
     AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
-    vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
-        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreatePrivateDataSlot_VkResult_return =
+            vkEnc->vkCreatePrivateDataSlot(gfxstream_device->internal_object, pCreateInfo,
+                                           pAllocator, pPrivateDataSlot, true /* do lock */);
+    }
     return vkCreatePrivateDataSlot_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCreatePrivateDataSlot(
-    VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlot", "VK_VERSION_1_3");
-    }
-    AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
-    vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
-        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
-    return vkCreatePrivateDataSlot_VkResult_return;
-}
-static void entry_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
-                                           const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
+                                         const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyPrivateDataSlot(VkDevice device,
-                                                    VkPrivateDataSlot privateDataSlot,
-                                                    const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlot", "VK_VERSION_1_3");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyPrivateDataSlot(gfxstream_device->internal_object, privateDataSlot,
+                                        pAllocator, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
 }
-static VkResult entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
-                                       uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
-                                       uint64_t data) {
+VkResult gfxstream_vk_SetPrivateData(VkDevice device, VkObjectType objectType,
+                                     uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+                                     uint64_t data) {
     AEMU_SCOPED_TRACE("vkSetPrivateData");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
-    vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
-        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkSetPrivateData_VkResult_return =
+            vkEnc->vkSetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
+                                    privateDataSlot, data, true /* do lock */);
+    }
     return vkSetPrivateData_VkResult_return;
 }
-static VkResult dynCheck_entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
-                                                uint64_t objectHandle,
-                                                VkPrivateDataSlot privateDataSlot, uint64_t data) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkSetPrivateData", "VK_VERSION_1_3");
-    }
-    AEMU_SCOPED_TRACE("vkSetPrivateData");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
-    vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
-        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
-    return vkSetPrivateData_VkResult_return;
-}
-static void entry_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
-                                   VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
+void gfxstream_vk_GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                 VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
     AEMU_SCOPED_TRACE("vkGetPrivateData");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
-                            true /* do lock */);
-}
-static void dynCheck_entry_vkGetPrivateData(VkDevice device, VkObjectType objectType,
-                                            uint64_t objectHandle,
-                                            VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkGetPrivateData", "VK_VERSION_1_3");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPrivateData(gfxstream_device->internal_object, objectType, objectHandle,
+                                privateDataSlot, pData, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetPrivateData");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
-                            true /* do lock */);
 }
-static void entry_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
-                                 const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+                               const VkDependencyInfo* pDependencyInfo) {
     AEMU_SCOPED_TRACE("vkCmdSetEvent2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetEvent2(commandBuffer, event, pDependencyInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+        std::vector<std::vector<VkBufferMemoryBarrier2>>
+            internal_VkDependencyInfo_pBufferMemoryBarriers;
+        std::vector<std::vector<VkImageMemoryBarrier2>>
+            internal_VkDependencyInfo_pImageMemoryBarriers;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pDependencyInfo[i] = pDependencyInfo[i];
+            /* VkDependencyInfo::pBufferMemoryBarriers */
+            internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+                std::vector<VkBufferMemoryBarrier2>());
+            internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+                   sizeof(VkBufferMemoryBarrier2) *
+                       internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+                /* VkBufferMemoryBarrier2::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+            }
+            internal_pDependencyInfo[i].pBufferMemoryBarriers =
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+            /* VkDependencyInfo::pImageMemoryBarriers */
+            internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+                std::vector<VkImageMemoryBarrier2>());
+            internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+                   sizeof(VkImageMemoryBarrier2) *
+                       internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+                /* VkImageMemoryBarrier2::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+                    gfxstream_image->internal_object;
+            }
+            internal_pDependencyInfo[i].pImageMemoryBarriers =
+                internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+        }
+        vkEnc->vkCmdSetEvent2(gfxstream_commandBuffer->internal_object,
+                              gfxstream_event->internal_object, internal_pDependencyInfo.data(),
+                              true /* do lock */);
+    }
 }
-static void entry_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
-                                   VkPipelineStageFlags2 stageMask) {
+void gfxstream_vk_CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
+                                 VkPipelineStageFlags2 stageMask) {
     AEMU_SCOPED_TRACE("vkCmdResetEvent2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResetEvent2(commandBuffer, event, stageMask, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdResetEvent2(gfxstream_commandBuffer->internal_object,
+                                gfxstream_event->internal_object, stageMask, true /* do lock */);
+    }
 }
-static void entry_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
-                                   const VkEvent* pEvents,
-                                   const VkDependencyInfo* pDependencyInfos) {
+void gfxstream_vk_CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                                 const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {
     AEMU_SCOPED_TRACE("vkCmdWaitEvents2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos,
-                            true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkEvent> internal_pEvents(eventCount);
+        for (uint32_t i = 0; i < eventCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+            internal_pEvents[i] = gfxstream_pEvents->internal_object;
+        }
+        std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
+        std::vector<std::vector<VkBufferMemoryBarrier2>>
+            internal_VkDependencyInfo_pBufferMemoryBarriers;
+        std::vector<std::vector<VkImageMemoryBarrier2>>
+            internal_VkDependencyInfo_pImageMemoryBarriers;
+        for (uint32_t i = 0; i < eventCount; ++i) {
+            internal_pDependencyInfos[i] = pDependencyInfos[i];
+            /* VkDependencyInfo::pBufferMemoryBarriers */
+            internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+                std::vector<VkBufferMemoryBarrier2>());
+            internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+                internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+                   sizeof(VkBufferMemoryBarrier2) *
+                       internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+                    internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
+                /* VkBufferMemoryBarrier2::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+            }
+            internal_pDependencyInfos[i].pBufferMemoryBarriers =
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+            /* VkDependencyInfo::pImageMemoryBarriers */
+            internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+                std::vector<VkImageMemoryBarrier2>());
+            internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+                internal_pDependencyInfos[i].imageMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+                   sizeof(VkImageMemoryBarrier2) *
+                       internal_pDependencyInfos[i].imageMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+                    internal_pDependencyInfos[i].pImageMemoryBarriers[j];
+                /* VkImageMemoryBarrier2::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+                    gfxstream_image->internal_object;
+            }
+            internal_pDependencyInfos[i].pImageMemoryBarriers =
+                internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+        }
+        vkEnc->vkCmdWaitEvents2(gfxstream_commandBuffer->internal_object, eventCount,
+                                internal_pEvents.data(), internal_pDependencyInfos.data(),
+                                true /* do lock */);
+    }
 }
-static void entry_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer,
-                                        const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdPipelineBarrier2(VkCommandBuffer commandBuffer,
+                                      const VkDependencyInfo* pDependencyInfo) {
     AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+        std::vector<std::vector<VkBufferMemoryBarrier2>>
+            internal_VkDependencyInfo_pBufferMemoryBarriers;
+        std::vector<std::vector<VkImageMemoryBarrier2>>
+            internal_VkDependencyInfo_pImageMemoryBarriers;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pDependencyInfo[i] = pDependencyInfo[i];
+            /* VkDependencyInfo::pBufferMemoryBarriers */
+            internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+                std::vector<VkBufferMemoryBarrier2>());
+            internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+                   sizeof(VkBufferMemoryBarrier2) *
+                       internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+                /* VkBufferMemoryBarrier2::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+            }
+            internal_pDependencyInfo[i].pBufferMemoryBarriers =
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+            /* VkDependencyInfo::pImageMemoryBarriers */
+            internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+                std::vector<VkImageMemoryBarrier2>());
+            internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+                   sizeof(VkImageMemoryBarrier2) *
+                       internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+                /* VkImageMemoryBarrier2::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+                    gfxstream_image->internal_object;
+            }
+            internal_pDependencyInfo[i].pImageMemoryBarriers =
+                internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+        }
+        vkEnc->vkCmdPipelineBarrier2(gfxstream_commandBuffer->internal_object,
+                                     internal_pDependencyInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
-                                       VkQueryPool queryPool, uint32_t query) {
+void gfxstream_vk_CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                     VkQueryPool queryPool, uint32_t query) {
     AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdWriteTimestamp2(gfxstream_commandBuffer->internal_object, stage,
+                                    gfxstream_queryPool->internal_object, query,
+                                    true /* do lock */);
+    }
 }
-static VkResult entry_vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
-                                     const VkSubmitInfo2* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit2(VkQueue queue, uint32_t submitCount,
+                                   const VkSubmitInfo2* pSubmits, VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueSubmit2");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
     VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkQueueSubmit2_VkResult_return =
-        resources->on_vkQueueSubmit2(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+        std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+        std::vector<std::vector<VkCommandBufferSubmitInfo>>
+            internal_VkSubmitInfo2_pCommandBufferInfos;
+        std::vector<std::vector<VkSemaphoreSubmitInfo>>
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+        for (uint32_t i = 0; i < submitCount; ++i) {
+            internal_pSubmits[i] = pSubmits[i];
+            /* VkSubmitInfo2::pWaitSemaphoreInfos */
+            internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+                std::vector<VkSemaphoreSubmitInfo>());
+            internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+                transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+                                                   internal_pSubmits[i].waitSemaphoreInfoCount);
+            internal_pSubmits[i].pWaitSemaphoreInfos =
+                internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+            internal_pSubmits[i].waitSemaphoreInfoCount =
+                internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+            /* VkSubmitInfo2::pCommandBufferInfos */
+            internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+                std::vector<VkCommandBufferSubmitInfo>());
+            internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+                internal_pSubmits[i].commandBufferInfoCount);
+            memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+                   sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+            for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+                internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+                    internal_pSubmits[i].pCommandBufferInfos[j];
+                /* VkCommandBufferSubmitInfo::commandBuffer */
+                VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+                               internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+                internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+                    gfxstream_commandBuffer->internal_object;
+            }
+            internal_pSubmits[i].pCommandBufferInfos =
+                internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+            /* VkSubmitInfo2::pSignalSemaphoreInfos */
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+                std::vector<VkSemaphoreSubmitInfo>());
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+                transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+                                                   internal_pSubmits[i].signalSemaphoreInfoCount);
+            internal_pSubmits[i].pSignalSemaphoreInfos =
+                internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+            internal_pSubmits[i].signalSemaphoreInfoCount =
+                internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkQueueSubmit2_VkResult_return = resources->on_vkQueueSubmit2(
+            vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, submitCount,
+            internal_pSubmits.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE);
+    }
     return vkQueueSubmit2_VkResult_return;
 }
-static void entry_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer,
-                                   const VkCopyBufferInfo2* pCopyBufferInfo) {
+void gfxstream_vk_CmdCopyBuffer2(VkCommandBuffer commandBuffer,
+                                 const VkCopyBufferInfo2* pCopyBufferInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyBuffer2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
+            /* VkCopyBufferInfo2::srcBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+                           internal_pCopyBufferInfo[i].srcBuffer);
+            internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+            /* VkCopyBufferInfo2::dstBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+                           internal_pCopyBufferInfo[i].dstBuffer);
+            internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+        }
+        vkEnc->vkCmdCopyBuffer2(gfxstream_commandBuffer->internal_object,
+                                internal_pCopyBufferInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdCopyImage2(VkCommandBuffer commandBuffer,
-                                  const VkCopyImageInfo2* pCopyImageInfo) {
+void gfxstream_vk_CmdCopyImage2(VkCommandBuffer commandBuffer,
+                                const VkCopyImageInfo2* pCopyImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyImage2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImage2(commandBuffer, pCopyImageInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyImageInfo[i] = pCopyImageInfo[i];
+            /* VkCopyImageInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pCopyImageInfo[i].srcImage);
+            internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkCopyImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pCopyImageInfo[i].dstImage);
+            internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdCopyImage2(gfxstream_commandBuffer->internal_object,
+                               internal_pCopyImageInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
-                                          const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+void gfxstream_vk_CmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
+                                        const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
+            /* VkCopyBufferToImageInfo2::srcBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+                           internal_pCopyBufferToImageInfo[i].srcBuffer);
+            internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+            /* VkCopyBufferToImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pCopyBufferToImageInfo[i].dstImage);
+            internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdCopyBufferToImage2(gfxstream_commandBuffer->internal_object,
+                                       internal_pCopyBufferToImageInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
-                                          const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+void gfxstream_vk_CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
+                                        const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
+            /* VkCopyImageToBufferInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pCopyImageToBufferInfo[i].srcImage);
+            internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkCopyImageToBufferInfo2::dstBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+                           internal_pCopyImageToBufferInfo[i].dstBuffer);
+            internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+        }
+        vkEnc->vkCmdCopyImageToBuffer2(gfxstream_commandBuffer->internal_object,
+                                       internal_pCopyImageToBufferInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdBlitImage2(VkCommandBuffer commandBuffer,
-                                  const VkBlitImageInfo2* pBlitImageInfo) {
+void gfxstream_vk_CmdBlitImage2(VkCommandBuffer commandBuffer,
+                                const VkBlitImageInfo2* pBlitImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdBlitImage2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBlitImage2(commandBuffer, pBlitImageInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pBlitImageInfo[i] = pBlitImageInfo[i];
+            /* VkBlitImageInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pBlitImageInfo[i].srcImage);
+            internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkBlitImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pBlitImageInfo[i].dstImage);
+            internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdBlitImage2(gfxstream_commandBuffer->internal_object,
+                               internal_pBlitImageInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdResolveImage2(VkCommandBuffer commandBuffer,
-                                     const VkResolveImageInfo2* pResolveImageInfo) {
+void gfxstream_vk_CmdResolveImage2(VkCommandBuffer commandBuffer,
+                                   const VkResolveImageInfo2* pResolveImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdResolveImage2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResolveImage2(commandBuffer, pResolveImageInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pResolveImageInfo[i] = pResolveImageInfo[i];
+            /* VkResolveImageInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pResolveImageInfo[i].srcImage);
+            internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkResolveImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pResolveImageInfo[i].dstImage);
+            internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdResolveImage2(gfxstream_commandBuffer->internal_object,
+                                  internal_pResolveImageInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdBeginRendering(VkCommandBuffer commandBuffer,
-                                      const VkRenderingInfo* pRenderingInfo) {
+void gfxstream_vk_CmdBeginRendering(VkCommandBuffer commandBuffer,
+                                    const VkRenderingInfo* pRenderingInfo) {
     AEMU_SCOPED_TRACE("vkCmdBeginRendering");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRendering(commandBuffer, pRenderingInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
+        std::vector<std::vector<VkRenderingAttachmentInfo>>
+            internal_VkRenderingInfo_pColorAttachments;
+        std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
+        std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pRenderingInfo[i] = pRenderingInfo[i];
+            /* VkRenderingInfo::pColorAttachments */
+            internal_VkRenderingInfo_pColorAttachments.push_back(
+                std::vector<VkRenderingAttachmentInfo>());
+            internal_VkRenderingInfo_pColorAttachments[i].reserve(
+                internal_pRenderingInfo[i].colorAttachmentCount);
+            memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
+                   sizeof(VkRenderingAttachmentInfo) *
+                       internal_pRenderingInfo[i].colorAttachmentCount);
+            for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
+                internal_VkRenderingInfo_pColorAttachments[i][j] =
+                    internal_pRenderingInfo[i].pColorAttachments[j];
+                /* VkRenderingAttachmentInfo::imageView */
+                if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
+                    internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
+                        gfxstream_imageView->internal_object;
+                }
+                /* VkRenderingAttachmentInfo::resolveImageView */
+                if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
+                    VK_FROM_HANDLE(
+                        gfxstream_vk_image_view, gfxstream_resolveImageView,
+                        internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
+                    internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
+                        gfxstream_resolveImageView->internal_object;
+                }
+            }
+            internal_pRenderingInfo[i].pColorAttachments =
+                internal_VkRenderingInfo_pColorAttachments[i].data();
+            /* VkRenderingInfo::pDepthAttachment */
+            if (internal_pRenderingInfo[i].pDepthAttachment) {
+                internal_VkRenderingInfo_pDepthAttachment[i] =
+                    internal_pRenderingInfo[i].pDepthAttachment[0];
+                /* VkRenderingAttachmentInfo::imageView */
+                if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_VkRenderingInfo_pDepthAttachment[i].imageView);
+                    internal_VkRenderingInfo_pDepthAttachment[i].imageView =
+                        gfxstream_imageView->internal_object;
+                }
+                /* VkRenderingAttachmentInfo::resolveImageView */
+                if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+                                   internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
+                    internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
+                        gfxstream_resolveImageView->internal_object;
+                }
+                internal_pRenderingInfo[i].pDepthAttachment =
+                    &internal_VkRenderingInfo_pDepthAttachment[i];
+            }
+            /* VkRenderingInfo::pStencilAttachment */
+            if (internal_pRenderingInfo[i].pStencilAttachment) {
+                internal_VkRenderingInfo_pStencilAttachment[i] =
+                    internal_pRenderingInfo[i].pStencilAttachment[0];
+                /* VkRenderingAttachmentInfo::imageView */
+                if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_VkRenderingInfo_pStencilAttachment[i].imageView);
+                    internal_VkRenderingInfo_pStencilAttachment[i].imageView =
+                        gfxstream_imageView->internal_object;
+                }
+                /* VkRenderingAttachmentInfo::resolveImageView */
+                if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+                                   internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
+                    internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
+                        gfxstream_resolveImageView->internal_object;
+                }
+                internal_pRenderingInfo[i].pStencilAttachment =
+                    &internal_VkRenderingInfo_pStencilAttachment[i];
+            }
+        }
+        vkEnc->vkCmdBeginRendering(gfxstream_commandBuffer->internal_object,
+                                   internal_pRenderingInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkCmdEndRendering(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRendering(VkCommandBuffer commandBuffer) {
     AEMU_SCOPED_TRACE("vkCmdEndRendering");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRendering(commandBuffer, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndRendering(gfxstream_commandBuffer->internal_object, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+void gfxstream_vk_CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
     AEMU_SCOPED_TRACE("vkCmdSetCullMode");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetCullMode(commandBuffer, cullMode, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetCullMode(gfxstream_commandBuffer->internal_object, cullMode,
+                                true /* do lock */);
+    }
 }
-static void entry_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+void gfxstream_vk_CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
     AEMU_SCOPED_TRACE("vkCmdSetFrontFace");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetFrontFace(commandBuffer, frontFace, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetFrontFace(gfxstream_commandBuffer->internal_object, frontFace,
+                                 true /* do lock */);
+    }
 }
-static void entry_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
-                                            VkPrimitiveTopology primitiveTopology) {
+void gfxstream_vk_CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
+                                          VkPrimitiveTopology primitiveTopology) {
     AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopology");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetPrimitiveTopology(gfxstream_commandBuffer->internal_object,
+                                         primitiveTopology, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
-                                            const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+                                          const VkViewport* pViewports) {
     AEMU_SCOPED_TRACE("vkCmdSetViewportWithCount");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetViewportWithCount(gfxstream_commandBuffer->internal_object, viewportCount,
+                                         pViewports, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
-                                           const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+                                         const VkRect2D* pScissors) {
     AEMU_SCOPED_TRACE("vkCmdSetScissorWithCount");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetScissorWithCount(gfxstream_commandBuffer->internal_object, scissorCount,
+                                        pScissors, true /* do lock */);
+    }
 }
-static void entry_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
-                                          uint32_t bindingCount, const VkBuffer* pBuffers,
-                                          const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
-                                          const VkDeviceSize* pStrides) {
+void gfxstream_vk_CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                        uint32_t bindingCount, const VkBuffer* pBuffers,
+                                        const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+                                        const VkDeviceSize* pStrides) {
     AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
-                                   pSizes, pStrides, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBuffer> internal_pBuffers(bindingCount);
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            if (pBuffers) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+                internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+            }
+        }
+        vkEnc->vkCmdBindVertexBuffers2(gfxstream_commandBuffer->internal_object, firstBinding,
+                                       bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
+                                       pStrides, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
+void gfxstream_vk_CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthTestEnable(gfxstream_commandBuffer->internal_object, depthTestEnable,
+                                       true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer,
-                                           VkBool32 depthWriteEnable) {
+void gfxstream_vk_CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthWriteEnable(gfxstream_commandBuffer->internal_object, depthWriteEnable,
+                                        true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer,
-                                         VkCompareOp depthCompareOp) {
+void gfxstream_vk_CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOp");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthCompareOp(gfxstream_commandBuffer->internal_object, depthCompareOp,
+                                      true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
-                                                VkBool32 depthBoundsTestEnable) {
+void gfxstream_vk_CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
+                                              VkBool32 depthBoundsTestEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthBoundsTestEnable(gfxstream_commandBuffer->internal_object,
+                                             depthBoundsTestEnable, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
-                                            VkBool32 stencilTestEnable) {
+void gfxstream_vk_CmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
+                                          VkBool32 stencilTestEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilTestEnable(gfxstream_commandBuffer->internal_object,
+                                         stencilTestEnable, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
-                                    VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
-                                    VkCompareOp compareOp) {
+void gfxstream_vk_CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                  VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
+                                  VkCompareOp compareOp) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilOp");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
-                             true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilOp(gfxstream_commandBuffer->internal_object, faceMask, failOp, passOp,
+                                 depthFailOp, compareOp, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
-                                                  VkBool32 rasterizerDiscardEnable) {
+void gfxstream_vk_CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
+                                                VkBool32 rasterizerDiscardEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable,
-                                           true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetRasterizerDiscardEnable(gfxstream_commandBuffer->internal_object,
+                                               rasterizerDiscardEnable, true /* do lock */);
+    }
 }
-static void entry_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
+void gfxstream_vk_CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthBiasEnable(gfxstream_commandBuffer->internal_object, depthBiasEnable,
+                                       true /* do lock */);
+    }
 }
-static void entry_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
-                                                 VkBool32 primitiveRestartEnable) {
+void gfxstream_vk_CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
+                                               VkBool32 primitiveRestartEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnable");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable,
-                                          true /* do lock */);
-}
-static void entry_vkGetDeviceBufferMemoryRequirements(VkDevice device,
-                                                      const VkDeviceBufferMemoryRequirements* pInfo,
-                                                      VkMemoryRequirements2* pMemoryRequirements) {
-    AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
-                                               true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceBufferMemoryRequirements(
-    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirements", "VK_VERSION_1_3");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetPrimitiveRestartEnable(gfxstream_commandBuffer->internal_object,
+                                              primitiveRestartEnable, true /* do lock */);
     }
+}
+void gfxstream_vk_GetDeviceBufferMemoryRequirements(VkDevice device,
+                                                    const VkDeviceBufferMemoryRequirements* pInfo,
+                                                    VkMemoryRequirements2* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
-                                               true /* do lock */);
-}
-static void entry_vkGetDeviceImageMemoryRequirements(VkDevice device,
-                                                     const VkDeviceImageMemoryRequirements* pInfo,
-                                                     VkMemoryRequirements2* pMemoryRequirements) {
-    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
-                                              true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageMemoryRequirements(
-    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirements", "VK_VERSION_1_3");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceBufferMemoryRequirements(gfxstream_device->internal_object, pInfo,
+                                                   pMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
-                                              true /* do lock */);
 }
-static void entry_vkGetDeviceImageSparseMemoryRequirements(
+void gfxstream_vk_GetDeviceImageMemoryRequirements(VkDevice device,
+                                                   const VkDeviceImageMemoryRequirements* pInfo,
+                                                   VkMemoryRequirements2* pMemoryRequirements) {
+    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceImageMemoryRequirements(gfxstream_device->internal_object, pInfo,
+                                                  pMemoryRequirements, true /* do lock */);
+    }
+}
+void gfxstream_vk_GetDeviceImageSparseMemoryRequirements(
     VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
-                                                    pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements(
-    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
-    uint32_t* pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirements",
-                                         "VK_VERSION_1_3");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceImageSparseMemoryRequirements(
+            gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
+            pSparseMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
-                                                    pSparseMemoryRequirements, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_surface
@@ -2171,140 +3720,236 @@
 #ifdef VK_KHR_xcb_surface
 #endif
 #ifdef VK_KHR_android_surface
-static VkResult entry_vkCreateAndroidSurfaceKHR(VkInstance instance,
-                                                const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
-                                                const VkAllocationCallbacks* pAllocator,
-                                                VkSurfaceKHR* pSurface) {
+VkResult gfxstream_vk_CreateAndroidSurfaceKHR(VkInstance instance,
+                                              const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+                                              const VkAllocationCallbacks* pAllocator,
+                                              VkSurfaceKHR* pSurface) {
     AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
-    vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(
-        instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_instance, gfxstream_instance, instance);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateAndroidSurfaceKHR_VkResult_return =
+            vkEnc->vkCreateAndroidSurfaceKHR(gfxstream_instance->internal_object, pCreateInfo,
+                                             pAllocator, pSurface, true /* do lock */);
+    }
     return vkCreateAndroidSurfaceKHR_VkResult_return;
 }
 #endif
 #ifdef VK_KHR_win32_surface
 #endif
 #ifdef VK_KHR_dynamic_rendering
-static void entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
-                                         const VkRenderingInfo* pRenderingInfo) {
+void gfxstream_vk_CmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
+                                       const VkRenderingInfo* pRenderingInfo) {
     AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
-                                                  const VkRenderingInfo* pRenderingInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderingKHR", "VK_KHR_dynamic_rendering");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkRenderingInfo> internal_pRenderingInfo(1);
+        std::vector<std::vector<VkRenderingAttachmentInfo>>
+            internal_VkRenderingInfo_pColorAttachments;
+        std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pDepthAttachment;
+        std::vector<VkRenderingAttachmentInfo> internal_VkRenderingInfo_pStencilAttachment;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pRenderingInfo[i] = pRenderingInfo[i];
+            /* VkRenderingInfo::pColorAttachments */
+            internal_VkRenderingInfo_pColorAttachments.push_back(
+                std::vector<VkRenderingAttachmentInfo>());
+            internal_VkRenderingInfo_pColorAttachments[i].reserve(
+                internal_pRenderingInfo[i].colorAttachmentCount);
+            memset(&internal_VkRenderingInfo_pColorAttachments[i][0], 0,
+                   sizeof(VkRenderingAttachmentInfo) *
+                       internal_pRenderingInfo[i].colorAttachmentCount);
+            for (uint32_t j = 0; j < internal_pRenderingInfo[i].colorAttachmentCount; ++j) {
+                internal_VkRenderingInfo_pColorAttachments[i][j] =
+                    internal_pRenderingInfo[i].pColorAttachments[j];
+                /* VkRenderingAttachmentInfo::imageView */
+                if (internal_VkRenderingInfo_pColorAttachments[i][j].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_VkRenderingInfo_pColorAttachments[i][j].imageView);
+                    internal_VkRenderingInfo_pColorAttachments[i][j].imageView =
+                        gfxstream_imageView->internal_object;
+                }
+                /* VkRenderingAttachmentInfo::resolveImageView */
+                if (internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView) {
+                    VK_FROM_HANDLE(
+                        gfxstream_vk_image_view, gfxstream_resolveImageView,
+                        internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView);
+                    internal_VkRenderingInfo_pColorAttachments[i][j].resolveImageView =
+                        gfxstream_resolveImageView->internal_object;
+                }
+            }
+            internal_pRenderingInfo[i].pColorAttachments =
+                internal_VkRenderingInfo_pColorAttachments[i].data();
+            /* VkRenderingInfo::pDepthAttachment */
+            if (internal_pRenderingInfo[i].pDepthAttachment) {
+                internal_VkRenderingInfo_pDepthAttachment[i] =
+                    internal_pRenderingInfo[i].pDepthAttachment[0];
+                /* VkRenderingAttachmentInfo::imageView */
+                if (internal_VkRenderingInfo_pDepthAttachment[i].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_VkRenderingInfo_pDepthAttachment[i].imageView);
+                    internal_VkRenderingInfo_pDepthAttachment[i].imageView =
+                        gfxstream_imageView->internal_object;
+                }
+                /* VkRenderingAttachmentInfo::resolveImageView */
+                if (internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+                                   internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView);
+                    internal_VkRenderingInfo_pDepthAttachment[i].resolveImageView =
+                        gfxstream_resolveImageView->internal_object;
+                }
+                internal_pRenderingInfo[i].pDepthAttachment =
+                    &internal_VkRenderingInfo_pDepthAttachment[i];
+            }
+            /* VkRenderingInfo::pStencilAttachment */
+            if (internal_pRenderingInfo[i].pStencilAttachment) {
+                internal_VkRenderingInfo_pStencilAttachment[i] =
+                    internal_pRenderingInfo[i].pStencilAttachment[0];
+                /* VkRenderingAttachmentInfo::imageView */
+                if (internal_VkRenderingInfo_pStencilAttachment[i].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_VkRenderingInfo_pStencilAttachment[i].imageView);
+                    internal_VkRenderingInfo_pStencilAttachment[i].imageView =
+                        gfxstream_imageView->internal_object;
+                }
+                /* VkRenderingAttachmentInfo::resolveImageView */
+                if (internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_resolveImageView,
+                                   internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView);
+                    internal_VkRenderingInfo_pStencilAttachment[i].resolveImageView =
+                        gfxstream_resolveImageView->internal_object;
+                }
+                internal_pRenderingInfo[i].pStencilAttachment =
+                    &internal_VkRenderingInfo_pStencilAttachment[i];
+            }
+        }
+        vkEnc->vkCmdBeginRenderingKHR(gfxstream_commandBuffer->internal_object,
+                                      internal_pRenderingInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
 }
-static void entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_CmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
     AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderingKHR", "VK_KHR_dynamic_rendering");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndRenderingKHR(gfxstream_commandBuffer->internal_object, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_get_physical_device_properties2
-static void entry_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
-                                                  VkPhysicalDeviceFeatures2* pFeatures) {
+void gfxstream_vk_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
+                                                VkPhysicalDeviceFeatures2* pFeatures) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceFeatures2KHR(gfxstream_physicalDevice->internal_object, pFeatures,
+                                               true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                    VkPhysicalDeviceProperties2* pProperties) {
+void gfxstream_vk_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                  VkPhysicalDeviceProperties2* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceProperties2KHR(gfxstream_physicalDevice->internal_object,
+                                                 pProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                          VkFormat format,
-                                                          VkFormatProperties2* pFormatProperties) {
+void gfxstream_vk_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                        VkFormat format,
+                                                        VkFormatProperties2* pFormatProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties,
-                                                   true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(gfxstream_physicalDevice->internal_object,
+                                                       format, pFormatProperties,
+                                                       true /* do lock */);
+    }
 }
-static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
+VkResult gfxstream_vk_GetPhysicalDeviceImageFormatProperties2KHR(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
     VkImageFormatProperties2* pImageFormatProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
-        resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
-            vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
+            resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
+                vkEnc, VK_SUCCESS, gfxstream_physicalDevice->internal_object, pImageFormatInfo,
+                pImageFormatProperties);
+    }
     return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
 }
-static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceQueueFamilyProperties2KHR(
     VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
     VkQueueFamilyProperties2* pQueueFamilyProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount,
-                                                        pQueueFamilyProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(
+            gfxstream_physicalDevice->internal_object, pQueueFamilyPropertyCount,
+            pQueueFamilyProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceMemoryProperties2KHR(
     VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties,
-                                                   true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(gfxstream_physicalDevice->internal_object,
+                                                       pMemoryProperties, true /* do lock */);
+    }
 }
-static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+void gfxstream_vk_GetPhysicalDeviceSparseImageFormatProperties2KHR(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
     uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
-        physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
+            gfxstream_physicalDevice->internal_object, pFormatInfo, pPropertyCount, pProperties,
+            true /* do lock */);
+    }
 }
 #endif
 #ifdef VK_KHR_maintenance1
-static void entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
-                                       VkCommandPoolTrimFlags flags) {
+void gfxstream_vk_TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
+                                     VkCommandPoolTrimFlags flags) {
     AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
-}
-static void dynCheck_entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
-                                                VkCommandPoolTrimFlags flags) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance1")) {
-        sOnInvalidDynamicallyCheckedCall("vkTrimCommandPoolKHR", "VK_KHR_maintenance1");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_command_pool, gfxstream_commandPool, commandPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkTrimCommandPoolKHR(gfxstream_device->internal_object,
+                                    gfxstream_commandPool->internal_object, flags,
+                                    true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_external_memory_capabilities
-static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalBufferPropertiesKHR(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
     VkExternalBufferProperties* pExternalBufferProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
-        vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
+            vkEnc, gfxstream_physicalDevice->internal_object, pExternalBufferInfo,
+            pExternalBufferProperties);
+    }
 }
 #endif
 #ifdef VK_KHR_external_memory
@@ -2314,14 +3959,18 @@
 #ifdef VK_KHR_external_memory_fd
 #endif
 #ifdef VK_KHR_external_semaphore_capabilities
-static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalSemaphorePropertiesKHR(
     VkPhysicalDevice physicalDevice,
     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
     VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
-        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
+            gfxstream_physicalDevice->internal_object, pExternalSemaphoreInfo,
+            pExternalSemaphoreProperties, true /* do lock */);
+    }
 }
 #endif
 #ifdef VK_KHR_external_semaphore
@@ -2329,51 +3978,47 @@
 #ifdef VK_KHR_external_semaphore_win32
 #endif
 #ifdef VK_KHR_external_semaphore_fd
-static VkResult entry_vkImportSemaphoreFdKHR(
+VkResult gfxstream_vk_ImportSemaphoreFdKHR(
     VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
     AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkImportSemaphoreFdKHR_VkResult_return =
-        resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImportSemaphoreFdInfoKHR> internal_pImportSemaphoreFdInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pImportSemaphoreFdInfo[i] = pImportSemaphoreFdInfo[i];
+            /* VkImportSemaphoreFdInfoKHR::semaphore */
+            VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+                           internal_pImportSemaphoreFdInfo[i].semaphore);
+            internal_pImportSemaphoreFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkImportSemaphoreFdKHR_VkResult_return = resources->on_vkImportSemaphoreFdKHR(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+            internal_pImportSemaphoreFdInfo.data());
+    }
     return vkImportSemaphoreFdKHR_VkResult_return;
 }
-static VkResult dynCheck_entry_vkImportSemaphoreFdKHR(
-    VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
-        sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
-    }
-    AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
-    vkImportSemaphoreFdKHR_VkResult_return =
-        resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
-    return vkImportSemaphoreFdKHR_VkResult_return;
-}
-static VkResult entry_vkGetSemaphoreFdKHR(VkDevice device,
-                                          const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
+VkResult gfxstream_vk_GetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
+                                        int* pFd) {
     AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkGetSemaphoreFdKHR_VkResult_return =
-        resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
-    return vkGetSemaphoreFdKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetSemaphoreFdKHR(VkDevice device,
-                                                   const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
-                                                   int* pFd) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkSemaphoreGetFdInfoKHR> internal_pGetFdInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pGetFdInfo[i] = pGetFdInfo[i];
+            /* VkSemaphoreGetFdInfoKHR::semaphore */
+            VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore,
+                           internal_pGetFdInfo[i].semaphore);
+            internal_pGetFdInfo[i].semaphore = gfxstream_semaphore->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkGetSemaphoreFdKHR_VkResult_return = resources->on_vkGetSemaphoreFdKHR(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
     }
-    AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
-    vkGetSemaphoreFdKHR_VkResult_return =
-        resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
     return vkGetSemaphoreFdKHR_VkResult_return;
 }
 #endif
@@ -2382,228 +4027,189 @@
 #ifdef VK_KHR_incremental_present
 #endif
 #ifdef VK_KHR_descriptor_update_template
-static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
+VkResult gfxstream_vk_CreateDescriptorUpdateTemplateKHR(
     VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
     const VkAllocationCallbacks* pAllocator,
     VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
     AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_descriptor_update_template* gfxstream_pDescriptorUpdateTemplate =
+        (gfxstream_vk_descriptor_update_template*)vk_object_zalloc(
+            &gfxstream_device->vk, pAllocator, sizeof(gfxstream_vk_descriptor_update_template),
+            VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE);
     vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
-        vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
-                                                   pDescriptorUpdateTemplate, true /* do lock */);
-    return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR(
-    VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator,
-    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplateKHR",
-                                         "VK_KHR_descriptor_update_template");
+        gfxstream_pDescriptorUpdateTemplate ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateDescriptorUpdateTemplateKHR_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDescriptorUpdateTemplateCreateInfo> internal_pCreateInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCreateInfo[i] = pCreateInfo[i];
+            /* VkDescriptorUpdateTemplateCreateInfo::descriptorSetLayout */
+            if (internal_pCreateInfo[i].descriptorSetLayout) {
+                VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_descriptorSetLayout,
+                               internal_pCreateInfo[i].descriptorSetLayout);
+                internal_pCreateInfo[i].descriptorSetLayout =
+                    gfxstream_descriptorSetLayout->internal_object;
+            }
+            /* VkDescriptorUpdateTemplateCreateInfo::pipelineLayout */
+            if (internal_pCreateInfo[i].pipelineLayout) {
+                VK_FROM_HANDLE(gfxstream_vk_pipeline_layout, gfxstream_pipelineLayout,
+                               internal_pCreateInfo[i].pipelineLayout);
+                internal_pCreateInfo[i].pipelineLayout = gfxstream_pipelineLayout->internal_object;
+            }
+        }
+        vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
+            vkEnc->vkCreateDescriptorUpdateTemplateKHR(
+                gfxstream_device->internal_object, internal_pCreateInfo.data(), pAllocator,
+                &gfxstream_pDescriptorUpdateTemplate->internal_object, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
-    vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
-        vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
-                                                   pDescriptorUpdateTemplate, true /* do lock */);
+    *pDescriptorUpdateTemplate =
+        gfxstream_vk_descriptor_update_template_to_handle(gfxstream_pDescriptorUpdateTemplate);
     return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
 }
-static void entry_vkDestroyDescriptorUpdateTemplateKHR(
+void gfxstream_vk_DestroyDescriptorUpdateTemplateKHR(
     VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
     const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
-                                                true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR(
-    VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
-    const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
-        sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplateKHR",
-                                         "VK_KHR_descriptor_update_template");
+    if (VK_NULL_HANDLE == descriptorUpdateTemplate) {
+        return;
     }
-    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
-                                                true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+                   descriptorUpdateTemplate);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyDescriptorUpdateTemplateKHR(
+            gfxstream_device->internal_object,
+            gfxstream_descriptorUpdateTemplate ? gfxstream_descriptorUpdateTemplate->internal_object
+                                               : VK_NULL_HANDLE,
+            pAllocator, true /* do lock */);
+    }
+    vk_object_free(&gfxstream_device->vk, pAllocator, (void*)gfxstream_descriptorUpdateTemplate);
 }
-static void entry_vkUpdateDescriptorSetWithTemplateKHR(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateKHR(
     VkDevice device, VkDescriptorSet descriptorSet,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
-                                                pData, true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR(
-    VkDevice device, VkDescriptorSet descriptorSet,
-    VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
-        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateKHR",
-                                         "VK_KHR_descriptor_update_template");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+                   descriptorUpdateTemplate);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkUpdateDescriptorSetWithTemplateKHR(
+            gfxstream_device->internal_object, descriptorSet,
+            gfxstream_descriptorUpdateTemplate->internal_object, pData, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
-                                                pData, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_imageless_framebuffer
 #endif
 #ifdef VK_KHR_create_renderpass2
-static VkResult entry_vkCreateRenderPass2KHR(VkDevice device,
-                                             const VkRenderPassCreateInfo2* pCreateInfo,
-                                             const VkAllocationCallbacks* pAllocator,
-                                             VkRenderPass* pRenderPass) {
+VkResult gfxstream_vk_CreateRenderPass2KHR(VkDevice device,
+                                           const VkRenderPassCreateInfo2* pCreateInfo,
+                                           const VkAllocationCallbacks* pAllocator,
+                                           VkRenderPass* pRenderPass) {
     AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
-    vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
-        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_render_pass* gfxstream_pRenderPass =
+        (gfxstream_vk_render_pass*)vk_object_zalloc(&gfxstream_device->vk, pAllocator,
+                                                    sizeof(gfxstream_vk_render_pass),
+                                                    VK_OBJECT_TYPE_RENDER_PASS);
+    vkCreateRenderPass2KHR_VkResult_return =
+        gfxstream_pRenderPass ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateRenderPass2KHR_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
+            gfxstream_device->internal_object, pCreateInfo, pAllocator,
+            &gfxstream_pRenderPass->internal_object, true /* do lock */);
+    }
+    *pRenderPass = gfxstream_vk_render_pass_to_handle(gfxstream_pRenderPass);
     return vkCreateRenderPass2KHR_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCreateRenderPass2KHR(VkDevice device,
-                                                      const VkRenderPassCreateInfo2* pCreateInfo,
-                                                      const VkAllocationCallbacks* pAllocator,
-                                                      VkRenderPass* pRenderPass) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2KHR", "VK_KHR_create_renderpass2");
+void gfxstream_vk_CmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+                                     const VkSubpassBeginInfo* pSubpassBeginInfo,
+                                     const VkSubpassEndInfo* pSubpassEndInfo) {
+    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdNextSubpass2KHR(gfxstream_commandBuffer->internal_object, pSubpassBeginInfo,
+                                    pSubpassEndInfo, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
-    vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
-        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
-    return vkCreateRenderPass2KHR_VkResult_return;
 }
-static void entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
-                                           const VkRenderPassBeginInfo* pRenderPassBegin,
-                                           const VkSubpassBeginInfo* pSubpassBeginInfo) {
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
-                                    true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
-                                                    const VkRenderPassBeginInfo* pRenderPassBegin,
-                                                    const VkSubpassBeginInfo* pSubpassBeginInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderPass2KHR", "VK_KHR_create_renderpass2");
-    }
-    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
-                                    true /* do lock */);
-}
-static void entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
-                                       const VkSubpassBeginInfo* pSubpassBeginInfo,
+void gfxstream_vk_CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
                                        const VkSubpassEndInfo* pSubpassEndInfo) {
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
-                                true /* do lock */);
-}
-static void dynCheck_entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
-                                                const VkSubpassBeginInfo* pSubpassBeginInfo,
-                                                const VkSubpassEndInfo* pSubpassEndInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdNextSubpass2KHR", "VK_KHR_create_renderpass2");
-    }
-    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
-                                true /* do lock */);
-}
-static void entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
-                                         const VkSubpassEndInfo* pSubpassEndInfo) {
     AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
-                                                  const VkSubpassEndInfo* pSubpassEndInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderPass2KHR", "VK_KHR_create_renderpass2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndRenderPass2KHR(gfxstream_commandBuffer->internal_object, pSubpassEndInfo,
+                                      true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_external_fence_capabilities
-static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+void gfxstream_vk_GetPhysicalDeviceExternalFencePropertiesKHR(
     VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
     VkExternalFenceProperties* pExternalFenceProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
-        vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
+            vkEnc, gfxstream_physicalDevice->internal_object, pExternalFenceInfo,
+            pExternalFenceProperties);
+    }
 }
 #endif
 #ifdef VK_KHR_external_fence
 #endif
 #ifdef VK_KHR_external_fence_fd
-static VkResult entry_vkImportFenceFdKHR(VkDevice device,
-                                         const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
+VkResult gfxstream_vk_ImportFenceFdKHR(VkDevice device,
+                                       const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
     AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkImportFenceFdKHR_VkResult_return =
-        resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImportFenceFdInfoKHR> internal_pImportFenceFdInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pImportFenceFdInfo[i] = pImportFenceFdInfo[i];
+            /* VkImportFenceFdInfoKHR::fence */
+            VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence,
+                           internal_pImportFenceFdInfo[i].fence);
+            internal_pImportFenceFdInfo[i].fence = gfxstream_fence->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkImportFenceFdKHR_VkResult_return =
+            resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, gfxstream_device->internal_object,
+                                             internal_pImportFenceFdInfo.data());
+    }
     return vkImportFenceFdKHR_VkResult_return;
 }
-static VkResult dynCheck_entry_vkImportFenceFdKHR(
-    VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
-        sOnInvalidDynamicallyCheckedCall("vkImportFenceFdKHR", "VK_KHR_external_fence_fd");
-    }
-    AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
-    vkImportFenceFdKHR_VkResult_return =
-        resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
-    return vkImportFenceFdKHR_VkResult_return;
-}
-static VkResult entry_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
-                                      int* pFd) {
+VkResult gfxstream_vk_GetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
+                                    int* pFd) {
     AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkGetFenceFdKHR_VkResult_return =
-        resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
-    return vkGetFenceFdKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetFenceFdKHR(VkDevice device,
-                                               const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetFenceFdKHR", "VK_KHR_external_fence_fd");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkFenceGetFdInfoKHR> internal_pGetFdInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pGetFdInfo[i] = pGetFdInfo[i];
+            /* VkFenceGetFdInfoKHR::fence */
+            VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, internal_pGetFdInfo[i].fence);
+            internal_pGetFdInfo[i].fence = gfxstream_fence->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkGetFenceFdKHR_VkResult_return = resources->on_vkGetFenceFdKHR(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, internal_pGetFdInfo.data(), pFd);
     }
-    AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
-    vkGetFenceFdKHR_VkResult_return =
-        resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
     return vkGetFenceFdKHR_VkResult_return;
 }
 #endif
@@ -2614,189 +4220,165 @@
 #ifdef VK_KHR_storage_buffer_storage_class
 #endif
 #ifdef VK_KHR_get_memory_requirements2
-static void entry_vkGetImageMemoryRequirements2KHR(VkDevice device,
-                                                   const VkImageMemoryRequirementsInfo2* pInfo,
-                                                   VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetImageMemoryRequirements2KHR(VkDevice device,
+                                                 const VkImageMemoryRequirementsInfo2* pInfo,
+                                                 VkMemoryRequirements2* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetImageMemoryRequirements2KHR(
-    VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2KHR",
-                                         "VK_KHR_get_memory_requirements2");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImageMemoryRequirementsInfo2> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkImageMemoryRequirementsInfo2::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+            internal_pInfo[i].image = gfxstream_image->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
+                                                       internal_pInfo.data(), pMemoryRequirements);
     }
-    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
 }
-static void entry_vkGetBufferMemoryRequirements2KHR(VkDevice device,
-                                                    const VkBufferMemoryRequirementsInfo2* pInfo,
-                                                    VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetBufferMemoryRequirements2KHR(VkDevice device,
+                                                  const VkBufferMemoryRequirementsInfo2* pInfo,
+                                                  VkMemoryRequirements2* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
-}
-static void dynCheck_entry_vkGetBufferMemoryRequirements2KHR(
-    VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2KHR",
-                                         "VK_KHR_get_memory_requirements2");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferMemoryRequirementsInfo2> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkBufferMemoryRequirementsInfo2::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+            internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, gfxstream_device->internal_object,
+                                                        internal_pInfo.data(), pMemoryRequirements);
     }
-    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
 }
-static void entry_vkGetImageSparseMemoryRequirements2KHR(
+void gfxstream_vk_GetImageSparseMemoryRequirements2KHR(
     VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
-                                                  pSparseMemoryRequirements, true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR(
-    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
-    uint32_t* pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2KHR",
-                                         "VK_KHR_get_memory_requirements2");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkImageSparseMemoryRequirementsInfo2> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkImageSparseMemoryRequirementsInfo2::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pInfo[i].image);
+            internal_pInfo[i].image = gfxstream_image->internal_object;
+        }
+        vkEnc->vkGetImageSparseMemoryRequirements2KHR(
+            gfxstream_device->internal_object, internal_pInfo.data(), pSparseMemoryRequirementCount,
+            pSparseMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
-                                                  pSparseMemoryRequirements, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_image_format_list
 #endif
 #ifdef VK_KHR_sampler_ycbcr_conversion
-static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
+VkResult gfxstream_vk_CreateSamplerYcbcrConversionKHR(
     VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
     const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
     AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkCreateSamplerYcbcrConversionKHR_VkResult_return =
-        resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
-                                                        pAllocator, pYcbcrConversion);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkCreateSamplerYcbcrConversionKHR_VkResult_return =
+            resources->on_vkCreateSamplerYcbcrConversionKHR(
+                vkEnc, VK_SUCCESS, gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                pYcbcrConversion);
+    }
     return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversionKHR(
-    VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversionKHR",
-                                         "VK_KHR_sampler_ycbcr_conversion");
-    }
-    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
-    vkCreateSamplerYcbcrConversionKHR_VkResult_return =
-        resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
-                                                        pAllocator, pYcbcrConversion);
-    return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
-}
-static void entry_vkDestroySamplerYcbcrConversionKHR(VkDevice device,
-                                                     VkSamplerYcbcrConversion ycbcrConversion,
-                                                     const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroySamplerYcbcrConversionKHR(VkDevice device,
+                                                   VkSamplerYcbcrConversion ycbcrConversion,
+                                                   const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    auto resources = ResourceTracker::get();
-    resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
-}
-static void dynCheck_entry_vkDestroySamplerYcbcrConversionKHR(
-    VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-    const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
-        sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversionKHR",
-                                         "VK_KHR_sampler_ycbcr_conversion");
+    if (VK_NULL_HANDLE == ycbcrConversion) {
+        return;
     }
-    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, gfxstream_device->internal_object,
+                                                         ycbcrConversion, pAllocator);
+    }
 }
 #endif
 #ifdef VK_KHR_bind_memory2
-static VkResult entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                             const VkBindBufferMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                           const VkBindBufferMemoryInfo* pBindInfos) {
     AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBindBufferMemory2KHR_VkResult_return =
-        resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBindBufferMemoryInfo> internal_pBindInfos(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; ++i) {
+            internal_pBindInfos[i] = pBindInfos[i];
+            /* VkBindBufferMemoryInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pBindInfos[i].buffer);
+            internal_pBindInfos[i].buffer = gfxstream_buffer->internal_object;
+            /* VkBindBufferMemoryInfo::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                           internal_pBindInfos[i].memory);
+            internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBindBufferMemory2KHR_VkResult_return = resources->on_vkBindBufferMemory2KHR(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
+            internal_pBindInfos.data());
+    }
     return vkBindBufferMemory2KHR_VkResult_return;
 }
-static VkResult dynCheck_entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                                      const VkBindBufferMemoryInfo* pBindInfos) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
-        sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2KHR", "VK_KHR_bind_memory2");
-    }
-    AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
-    vkBindBufferMemory2KHR_VkResult_return =
-        resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
-    return vkBindBufferMemory2KHR_VkResult_return;
-}
-static VkResult entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                            const VkBindImageMemoryInfo* pBindInfos) {
+VkResult gfxstream_vk_BindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                          const VkBindImageMemoryInfo* pBindInfos) {
     AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkBindImageMemory2KHR_VkResult_return =
-        resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
-    return vkBindImageMemory2KHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                                     const VkBindImageMemoryInfo* pBindInfos) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
-        sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2KHR", "VK_KHR_bind_memory2");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBindImageMemoryInfo> internal_pBindInfos(bindInfoCount);
+        for (uint32_t i = 0; i < bindInfoCount; ++i) {
+            internal_pBindInfos[i] = pBindInfos[i];
+            /* VkBindImageMemoryInfo::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pBindInfos[i].image);
+            internal_pBindInfos[i].image = gfxstream_image->internal_object;
+            /* VkBindImageMemoryInfo::memory */
+            if (internal_pBindInfos[i].memory) {
+                VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                               internal_pBindInfos[i].memory);
+                internal_pBindInfos[i].memory = gfxstream_memory->internal_object;
+            }
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkBindImageMemory2KHR_VkResult_return = resources->on_vkBindImageMemory2KHR(
+            vkEnc, VK_SUCCESS, gfxstream_device->internal_object, bindInfoCount,
+            internal_pBindInfos.data());
     }
-    AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
-    vkBindImageMemory2KHR_VkResult_return =
-        resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
     return vkBindImageMemory2KHR_VkResult_return;
 }
 #endif
 #ifdef VK_KHR_maintenance3
-static void entry_vkGetDescriptorSetLayoutSupportKHR(
+void gfxstream_vk_GetDescriptorSetLayoutSupportKHR(
     VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
     VkDescriptorSetLayoutSupport* pSupport) {
     AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR(
-    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
-    VkDescriptorSetLayoutSupport* pSupport) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance3")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupportKHR",
-                                         "VK_KHR_maintenance3");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDescriptorSetLayoutSupportKHR(gfxstream_device->internal_object, pCreateInfo,
+                                                  pSupport, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_shader_subgroup_extended_types
@@ -2806,160 +4388,135 @@
 #ifdef VK_KHR_shader_terminate_invocation
 #endif
 #ifdef VK_KHR_buffer_device_address
-static VkDeviceAddress entry_vkGetBufferDeviceAddressKHR(VkDevice device,
-                                                         const VkBufferDeviceAddressInfo* pInfo) {
+VkDeviceAddress gfxstream_vk_GetBufferDeviceAddressKHR(VkDevice device,
+                                                       const VkBufferDeviceAddressInfo* pInfo) {
     AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
-    vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
-        vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkBufferDeviceAddressInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+            internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = vkEnc->vkGetBufferDeviceAddressKHR(
+            gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
+    }
     return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
 }
-static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddressKHR(
-    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressKHR",
-                                         "VK_KHR_buffer_device_address");
-    }
-    AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
-    vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
-        vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
-    return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
-}
-static uint64_t entry_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
-                                                         const VkBufferDeviceAddressInfo* pInfo) {
+uint64_t gfxstream_vk_GetBufferOpaqueCaptureAddressKHR(VkDevice device,
+                                                       const VkBufferDeviceAddressInfo* pInfo) {
     AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
-    vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
-        vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkBufferDeviceAddressInfo> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkBufferDeviceAddressInfo::buffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, internal_pInfo[i].buffer);
+            internal_pInfo[i].buffer = gfxstream_buffer->internal_object;
+        }
+        vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
+            vkEnc->vkGetBufferOpaqueCaptureAddressKHR(gfxstream_device->internal_object,
+                                                      internal_pInfo.data(), true /* do lock */);
+    }
     return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
 }
-static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR(
-    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddressKHR",
-                                         "VK_KHR_buffer_device_address");
-    }
-    AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
-    vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
-        vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
-    return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
-}
-static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+uint64_t gfxstream_vk_GetDeviceMemoryOpaqueCaptureAddressKHR(
     VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
     AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
-    vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
-        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
-    return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
-}
-static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
-    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddressKHR",
-                                         "VK_KHR_buffer_device_address");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDeviceMemoryOpaqueCaptureAddressInfo> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkDeviceMemoryOpaqueCaptureAddressInfo::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+            internal_pInfo[i].memory = gfxstream_memory->internal_object;
+        }
+        vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
+            vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(
+                gfxstream_device->internal_object, internal_pInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
-    vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
-        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
     return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
 }
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
-static VkResult entry_vkGetPipelineExecutablePropertiesKHR(
+VkResult gfxstream_vk_GetPipelineExecutablePropertiesKHR(
     VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
     VkPipelineExecutablePropertiesKHR* pProperties) {
     AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
-    vkGetPipelineExecutablePropertiesKHR_VkResult_return =
-        vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
-                                                    pProperties, true /* do lock */);
-    return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutablePropertiesKHR(
-    VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
-    VkPipelineExecutablePropertiesKHR* pProperties) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutablePropertiesKHR",
-                                         "VK_KHR_pipeline_executable_properties");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkPipelineInfoKHR> internal_pPipelineInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pPipelineInfo[i] = pPipelineInfo[i];
+            /* VkPipelineInfoKHR::pipeline */
+            VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+                           internal_pPipelineInfo[i].pipeline);
+            internal_pPipelineInfo[i].pipeline = gfxstream_pipeline->internal_object;
+        }
+        vkGetPipelineExecutablePropertiesKHR_VkResult_return =
+            vkEnc->vkGetPipelineExecutablePropertiesKHR(
+                gfxstream_device->internal_object, internal_pPipelineInfo.data(), pExecutableCount,
+                pProperties, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
-    vkGetPipelineExecutablePropertiesKHR_VkResult_return =
-        vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
-                                                    pProperties, true /* do lock */);
     return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
 }
-static VkResult entry_vkGetPipelineExecutableStatisticsKHR(
+VkResult gfxstream_vk_GetPipelineExecutableStatisticsKHR(
     VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
     VkPipelineExecutableStatisticKHR* pStatistics) {
     AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
-    vkGetPipelineExecutableStatisticsKHR_VkResult_return =
-        vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
-                                                    pStatistics, true /* do lock */);
-    return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutableStatisticsKHR(
-    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
-    VkPipelineExecutableStatisticKHR* pStatistics) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableStatisticsKHR",
-                                         "VK_KHR_pipeline_executable_properties");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pExecutableInfo[i] = pExecutableInfo[i];
+            /* VkPipelineExecutableInfoKHR::pipeline */
+            VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+                           internal_pExecutableInfo[i].pipeline);
+            internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
+        }
+        vkGetPipelineExecutableStatisticsKHR_VkResult_return =
+            vkEnc->vkGetPipelineExecutableStatisticsKHR(
+                gfxstream_device->internal_object, internal_pExecutableInfo.data(), pStatisticCount,
+                pStatistics, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
-    vkGetPipelineExecutableStatisticsKHR_VkResult_return =
-        vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
-                                                    pStatistics, true /* do lock */);
     return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
 }
-static VkResult entry_vkGetPipelineExecutableInternalRepresentationsKHR(
+VkResult gfxstream_vk_GetPipelineExecutableInternalRepresentationsKHR(
     VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
     uint32_t* pInternalRepresentationCount,
     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
     AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
-    vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
-        vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
-            device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
-            true /* do lock */);
-    return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR(
-    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
-    uint32_t* pInternalRepresentationCount,
-    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableInternalRepresentationsKHR",
-                                         "VK_KHR_pipeline_executable_properties");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkPipelineExecutableInfoKHR> internal_pExecutableInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pExecutableInfo[i] = pExecutableInfo[i];
+            /* VkPipelineExecutableInfoKHR::pipeline */
+            VK_FROM_HANDLE(gfxstream_vk_pipeline, gfxstream_pipeline,
+                           internal_pExecutableInfo[i].pipeline);
+            internal_pExecutableInfo[i].pipeline = gfxstream_pipeline->internal_object;
+        }
+        vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
+            vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
+                gfxstream_device->internal_object, internal_pExecutableInfo.data(),
+                pInternalRepresentationCount, pInternalRepresentations, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
-    vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
-        vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
-            device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
-            true /* do lock */);
     return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
 }
 #endif
@@ -2968,652 +4525,726 @@
 #ifdef VK_KHR_shader_non_semantic_info
 #endif
 #ifdef VK_KHR_synchronization2
-static void entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
-                                    const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+                                  const VkDependencyInfo* pDependencyInfo) {
     AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
-                                             const VkDependencyInfo* pDependencyInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetEvent2KHR", "VK_KHR_synchronization2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+        std::vector<std::vector<VkBufferMemoryBarrier2>>
+            internal_VkDependencyInfo_pBufferMemoryBarriers;
+        std::vector<std::vector<VkImageMemoryBarrier2>>
+            internal_VkDependencyInfo_pImageMemoryBarriers;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pDependencyInfo[i] = pDependencyInfo[i];
+            /* VkDependencyInfo::pBufferMemoryBarriers */
+            internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+                std::vector<VkBufferMemoryBarrier2>());
+            internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+                   sizeof(VkBufferMemoryBarrier2) *
+                       internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+                /* VkBufferMemoryBarrier2::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+            }
+            internal_pDependencyInfo[i].pBufferMemoryBarriers =
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+            /* VkDependencyInfo::pImageMemoryBarriers */
+            internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+                std::vector<VkImageMemoryBarrier2>());
+            internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+                   sizeof(VkImageMemoryBarrier2) *
+                       internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+                /* VkImageMemoryBarrier2::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+                    gfxstream_image->internal_object;
+            }
+            internal_pDependencyInfo[i].pImageMemoryBarriers =
+                internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+        }
+        vkEnc->vkCmdSetEvent2KHR(gfxstream_commandBuffer->internal_object,
+                                 gfxstream_event->internal_object, internal_pDependencyInfo.data(),
+                                 true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
 }
-static void entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
-                                      VkPipelineStageFlags2 stageMask) {
+void gfxstream_vk_CmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
+                                    VkPipelineStageFlags2 stageMask) {
     AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
-                                               VkPipelineStageFlags2 stageMask) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdResetEvent2KHR", "VK_KHR_synchronization2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_event, event);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdResetEvent2KHR(gfxstream_commandBuffer->internal_object,
+                                   gfxstream_event->internal_object, stageMask, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
 }
-static void entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
-                                      const VkEvent* pEvents,
-                                      const VkDependencyInfo* pDependencyInfos) {
+void gfxstream_vk_CmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
+                                    const VkEvent* pEvents,
+                                    const VkDependencyInfo* pDependencyInfos) {
     AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
-                               true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
-                                               const VkEvent* pEvents,
-                                               const VkDependencyInfo* pDependencyInfos) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdWaitEvents2KHR", "VK_KHR_synchronization2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkEvent> internal_pEvents(eventCount);
+        for (uint32_t i = 0; i < eventCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_event, gfxstream_pEvents, pEvents[i]);
+            internal_pEvents[i] = gfxstream_pEvents->internal_object;
+        }
+        std::vector<VkDependencyInfo> internal_pDependencyInfos(eventCount);
+        std::vector<std::vector<VkBufferMemoryBarrier2>>
+            internal_VkDependencyInfo_pBufferMemoryBarriers;
+        std::vector<std::vector<VkImageMemoryBarrier2>>
+            internal_VkDependencyInfo_pImageMemoryBarriers;
+        for (uint32_t i = 0; i < eventCount; ++i) {
+            internal_pDependencyInfos[i] = pDependencyInfos[i];
+            /* VkDependencyInfo::pBufferMemoryBarriers */
+            internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+                std::vector<VkBufferMemoryBarrier2>());
+            internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+                internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+                   sizeof(VkBufferMemoryBarrier2) *
+                       internal_pDependencyInfos[i].bufferMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfos[i].bufferMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+                    internal_pDependencyInfos[i].pBufferMemoryBarriers[j];
+                /* VkBufferMemoryBarrier2::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+            }
+            internal_pDependencyInfos[i].pBufferMemoryBarriers =
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+            /* VkDependencyInfo::pImageMemoryBarriers */
+            internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+                std::vector<VkImageMemoryBarrier2>());
+            internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+                internal_pDependencyInfos[i].imageMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+                   sizeof(VkImageMemoryBarrier2) *
+                       internal_pDependencyInfos[i].imageMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfos[i].imageMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+                    internal_pDependencyInfos[i].pImageMemoryBarriers[j];
+                /* VkImageMemoryBarrier2::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+                    gfxstream_image->internal_object;
+            }
+            internal_pDependencyInfos[i].pImageMemoryBarriers =
+                internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+        }
+        vkEnc->vkCmdWaitEvents2KHR(gfxstream_commandBuffer->internal_object, eventCount,
+                                   internal_pEvents.data(), internal_pDependencyInfos.data(),
+                                   true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
-                               true /* do lock */);
 }
-static void entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
-                                           const VkDependencyInfo* pDependencyInfo) {
+void gfxstream_vk_CmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
+                                         const VkDependencyInfo* pDependencyInfo) {
     AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
-                                                    const VkDependencyInfo* pDependencyInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdPipelineBarrier2KHR", "VK_KHR_synchronization2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkDependencyInfo> internal_pDependencyInfo(1);
+        std::vector<std::vector<VkBufferMemoryBarrier2>>
+            internal_VkDependencyInfo_pBufferMemoryBarriers;
+        std::vector<std::vector<VkImageMemoryBarrier2>>
+            internal_VkDependencyInfo_pImageMemoryBarriers;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pDependencyInfo[i] = pDependencyInfo[i];
+            /* VkDependencyInfo::pBufferMemoryBarriers */
+            internal_VkDependencyInfo_pBufferMemoryBarriers.push_back(
+                std::vector<VkBufferMemoryBarrier2>());
+            internal_VkDependencyInfo_pBufferMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pBufferMemoryBarriers[i][0], 0,
+                   sizeof(VkBufferMemoryBarrier2) *
+                       internal_pDependencyInfo[i].bufferMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].bufferMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pBufferMemoryBarriers[j];
+                /* VkBufferMemoryBarrier2::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer);
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+            }
+            internal_pDependencyInfo[i].pBufferMemoryBarriers =
+                internal_VkDependencyInfo_pBufferMemoryBarriers[i].data();
+            /* VkDependencyInfo::pImageMemoryBarriers */
+            internal_VkDependencyInfo_pImageMemoryBarriers.push_back(
+                std::vector<VkImageMemoryBarrier2>());
+            internal_VkDependencyInfo_pImageMemoryBarriers[i].reserve(
+                internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            memset(&internal_VkDependencyInfo_pImageMemoryBarriers[i][0], 0,
+                   sizeof(VkImageMemoryBarrier2) *
+                       internal_pDependencyInfo[i].imageMemoryBarrierCount);
+            for (uint32_t j = 0; j < internal_pDependencyInfo[i].imageMemoryBarrierCount; ++j) {
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j] =
+                    internal_pDependencyInfo[i].pImageMemoryBarriers[j];
+                /* VkImageMemoryBarrier2::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image);
+                internal_VkDependencyInfo_pImageMemoryBarriers[i][j].image =
+                    gfxstream_image->internal_object;
+            }
+            internal_pDependencyInfo[i].pImageMemoryBarriers =
+                internal_VkDependencyInfo_pImageMemoryBarriers[i].data();
+        }
+        vkEnc->vkCmdPipelineBarrier2KHR(gfxstream_commandBuffer->internal_object,
+                                        internal_pDependencyInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
 }
-static void entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
-                                          VkPipelineStageFlags2 stage, VkQueryPool queryPool,
-                                          uint32_t query) {
+void gfxstream_vk_CmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
+                                        VkQueryPool queryPool, uint32_t query) {
     AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
-                                                   VkPipelineStageFlags2 stage,
-                                                   VkQueryPool queryPool, uint32_t query) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdWriteTimestamp2KHR", "VK_KHR_synchronization2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdWriteTimestamp2KHR(gfxstream_commandBuffer->internal_object, stage,
+                                       gfxstream_queryPool->internal_object, query,
+                                       true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
 }
-static VkResult entry_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
-                                        const VkSubmitInfo2* pSubmits, VkFence fence) {
+VkResult gfxstream_vk_QueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
+                                      const VkSubmitInfo2* pSubmits, VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueSubmit2KHR");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
     VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
-    vkQueueSubmit2KHR_VkResult_return =
-        vkEnc->vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+        std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+        std::vector<std::vector<VkCommandBufferSubmitInfo>>
+            internal_VkSubmitInfo2_pCommandBufferInfos;
+        std::vector<std::vector<VkSemaphoreSubmitInfo>>
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+        for (uint32_t i = 0; i < submitCount; ++i) {
+            internal_pSubmits[i] = pSubmits[i];
+            /* VkSubmitInfo2::pWaitSemaphoreInfos */
+            internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+                std::vector<VkSemaphoreSubmitInfo>());
+            internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+                transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+                                                   internal_pSubmits[i].waitSemaphoreInfoCount);
+            internal_pSubmits[i].pWaitSemaphoreInfos =
+                internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+            internal_pSubmits[i].waitSemaphoreInfoCount =
+                internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+            /* VkSubmitInfo2::pCommandBufferInfos */
+            internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+                std::vector<VkCommandBufferSubmitInfo>());
+            internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+                internal_pSubmits[i].commandBufferInfoCount);
+            memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+                   sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+            for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+                internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+                    internal_pSubmits[i].pCommandBufferInfos[j];
+                /* VkCommandBufferSubmitInfo::commandBuffer */
+                VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+                               internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+                internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+                    gfxstream_commandBuffer->internal_object;
+            }
+            internal_pSubmits[i].pCommandBufferInfos =
+                internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+            /* VkSubmitInfo2::pSignalSemaphoreInfos */
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+                std::vector<VkSemaphoreSubmitInfo>());
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+                transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+                                                   internal_pSubmits[i].signalSemaphoreInfoCount);
+            internal_pSubmits[i].pSignalSemaphoreInfos =
+                internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+            internal_pSubmits[i].signalSemaphoreInfoCount =
+                internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+        }
+        vkQueueSubmit2KHR_VkResult_return = vkEnc->vkQueueSubmit2KHR(
+            gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+            true /* do lock */);
+    }
     return vkQueueSubmit2KHR_VkResult_return;
 }
-static void entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
-                                             VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
-                                             VkDeviceSize dstOffset, uint32_t marker) {
+void gfxstream_vk_CmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
+                                           VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
+                                           VkDeviceSize dstOffset, uint32_t marker) {
     AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
-                                      true /* do lock */);
-}
-static void dynCheck_entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
-                                                      VkPipelineStageFlags2 stage,
-                                                      VkBuffer dstBuffer, VkDeviceSize dstOffset,
-                                                      uint32_t marker) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdWriteBufferMarker2AMD", "VK_KHR_synchronization2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer, dstBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdWriteBufferMarker2AMD(gfxstream_commandBuffer->internal_object, stage,
+                                          gfxstream_dstBuffer->internal_object, dstOffset, marker,
+                                          true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
-                                      true /* do lock */);
 }
-static void entry_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
-                                              VkCheckpointData2NV* pCheckpointData) {
+void gfxstream_vk_GetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
+                                            VkCheckpointData2NV* pCheckpointData) {
     AEMU_SCOPED_TRACE("vkGetQueueCheckpointData2NV");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData,
-                                       true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        vkEnc->vkGetQueueCheckpointData2NV(gfxstream_queue->internal_object, pCheckpointDataCount,
+                                           pCheckpointData, true /* do lock */);
+    }
 }
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
 #endif
 #ifdef VK_KHR_copy_commands2
-static void entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
-                                      const VkCopyBufferInfo2* pCopyBufferInfo) {
+void gfxstream_vk_CmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
+                                    const VkCopyBufferInfo2* pCopyBufferInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
-                                               const VkCopyBufferInfo2* pCopyBufferInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdCopyBuffer2KHR", "VK_KHR_copy_commands2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyBufferInfo2> internal_pCopyBufferInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyBufferInfo[i] = pCopyBufferInfo[i];
+            /* VkCopyBufferInfo2::srcBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+                           internal_pCopyBufferInfo[i].srcBuffer);
+            internal_pCopyBufferInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+            /* VkCopyBufferInfo2::dstBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+                           internal_pCopyBufferInfo[i].dstBuffer);
+            internal_pCopyBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+        }
+        vkEnc->vkCmdCopyBuffer2KHR(gfxstream_commandBuffer->internal_object,
+                                   internal_pCopyBufferInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
 }
-static void entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
-                                     const VkCopyImageInfo2* pCopyImageInfo) {
+void gfxstream_vk_CmdCopyImage2KHR(VkCommandBuffer commandBuffer,
+                                   const VkCopyImageInfo2* pCopyImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
-                                              const VkCopyImageInfo2* pCopyImageInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdCopyImage2KHR", "VK_KHR_copy_commands2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyImageInfo2> internal_pCopyImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyImageInfo[i] = pCopyImageInfo[i];
+            /* VkCopyImageInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pCopyImageInfo[i].srcImage);
+            internal_pCopyImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkCopyImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pCopyImageInfo[i].dstImage);
+            internal_pCopyImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdCopyImage2KHR(gfxstream_commandBuffer->internal_object,
+                                  internal_pCopyImageInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
 }
-static void entry_vkCmdCopyBufferToImage2KHR(
-    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+void gfxstream_vk_CmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
+                                           const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyBufferToImage2KHR(
-    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdCopyBufferToImage2KHR", "VK_KHR_copy_commands2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyBufferToImageInfo2> internal_pCopyBufferToImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyBufferToImageInfo[i] = pCopyBufferToImageInfo[i];
+            /* VkCopyBufferToImageInfo2::srcBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_srcBuffer,
+                           internal_pCopyBufferToImageInfo[i].srcBuffer);
+            internal_pCopyBufferToImageInfo[i].srcBuffer = gfxstream_srcBuffer->internal_object;
+            /* VkCopyBufferToImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pCopyBufferToImageInfo[i].dstImage);
+            internal_pCopyBufferToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdCopyBufferToImage2KHR(gfxstream_commandBuffer->internal_object,
+                                          internal_pCopyBufferToImageInfo.data(),
+                                          true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
 }
-static void entry_vkCmdCopyImageToBuffer2KHR(
-    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+void gfxstream_vk_CmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
+                                           const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
     AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdCopyImageToBuffer2KHR(
-    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdCopyImageToBuffer2KHR", "VK_KHR_copy_commands2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCopyImageToBufferInfo2> internal_pCopyImageToBufferInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyImageToBufferInfo[i] = pCopyImageToBufferInfo[i];
+            /* VkCopyImageToBufferInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pCopyImageToBufferInfo[i].srcImage);
+            internal_pCopyImageToBufferInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkCopyImageToBufferInfo2::dstBuffer */
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_dstBuffer,
+                           internal_pCopyImageToBufferInfo[i].dstBuffer);
+            internal_pCopyImageToBufferInfo[i].dstBuffer = gfxstream_dstBuffer->internal_object;
+        }
+        vkEnc->vkCmdCopyImageToBuffer2KHR(gfxstream_commandBuffer->internal_object,
+                                          internal_pCopyImageToBufferInfo.data(),
+                                          true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
 }
-static void entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
-                                     const VkBlitImageInfo2* pBlitImageInfo) {
+void gfxstream_vk_CmdBlitImage2KHR(VkCommandBuffer commandBuffer,
+                                   const VkBlitImageInfo2* pBlitImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
-                                              const VkBlitImageInfo2* pBlitImageInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBlitImage2KHR", "VK_KHR_copy_commands2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBlitImageInfo2> internal_pBlitImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pBlitImageInfo[i] = pBlitImageInfo[i];
+            /* VkBlitImageInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pBlitImageInfo[i].srcImage);
+            internal_pBlitImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkBlitImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pBlitImageInfo[i].dstImage);
+            internal_pBlitImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdBlitImage2KHR(gfxstream_commandBuffer->internal_object,
+                                  internal_pBlitImageInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
 }
-static void entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
-                                        const VkResolveImageInfo2* pResolveImageInfo) {
+void gfxstream_vk_CmdResolveImage2KHR(VkCommandBuffer commandBuffer,
+                                      const VkResolveImageInfo2* pResolveImageInfo) {
     AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
-                                                 const VkResolveImageInfo2* pResolveImageInfo) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdResolveImage2KHR", "VK_KHR_copy_commands2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkResolveImageInfo2> internal_pResolveImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pResolveImageInfo[i] = pResolveImageInfo[i];
+            /* VkResolveImageInfo2::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pResolveImageInfo[i].srcImage);
+            internal_pResolveImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkResolveImageInfo2::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pResolveImageInfo[i].dstImage);
+            internal_pResolveImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkEnc->vkCmdResolveImage2KHR(gfxstream_commandBuffer->internal_object,
+                                     internal_pResolveImageInfo.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
 #ifdef VK_KHR_maintenance4
-static void entry_vkGetDeviceBufferMemoryRequirementsKHR(
+void gfxstream_vk_GetDeviceBufferMemoryRequirementsKHR(
     VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
     VkMemoryRequirements2* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
-                                                  true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR(
-    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirementsKHR",
-                                         "VK_KHR_maintenance4");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
+                                                      pMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
-                                                  true /* do lock */);
 }
-static void entry_vkGetDeviceImageMemoryRequirementsKHR(
-    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
+void gfxstream_vk_GetDeviceImageMemoryRequirementsKHR(VkDevice device,
+                                                      const VkDeviceImageMemoryRequirements* pInfo,
+                                                      VkMemoryRequirements2* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
-                                                 true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR(
-    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
-    VkMemoryRequirements2* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirementsKHR",
-                                         "VK_KHR_maintenance4");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceImageMemoryRequirementsKHR(gfxstream_device->internal_object, pInfo,
+                                                     pMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
-                                                 true /* do lock */);
 }
-static void entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
+void gfxstream_vk_GetDeviceImageSparseMemoryRequirementsKHR(
     VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
-                                                       pSparseMemoryRequirements,
-                                                       true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
-    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
-    uint32_t* pSparseMemoryRequirementCount,
-    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirementsKHR",
-                                         "VK_KHR_maintenance4");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(
+            gfxstream_device->internal_object, pInfo, pSparseMemoryRequirementCount,
+            pSparseMemoryRequirements, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
-                                                       pSparseMemoryRequirements,
-                                                       true /* do lock */);
 }
 #endif
 #ifdef VK_KHR_maintenance5
-static void entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                           VkDeviceSize offset, VkDeviceSize size,
-                                           VkIndexType indexType) {
+void gfxstream_vk_CmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                         VkDeviceSize offset, VkDeviceSize size,
+                                         VkIndexType indexType) {
     AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
-                                    true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
-                                                    VkDeviceSize offset, VkDeviceSize size,
-                                                    VkIndexType indexType) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBindIndexBuffer2KHR", "VK_KHR_maintenance5");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer, buffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdBindIndexBuffer2KHR(gfxstream_commandBuffer->internal_object,
+                                        gfxstream_buffer->internal_object, offset, size, indexType,
+                                        true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
-                                    true /* do lock */);
 }
-static void entry_vkGetRenderingAreaGranularityKHR(VkDevice device,
-                                                   const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
-                                                   VkExtent2D* pGranularity) {
+void gfxstream_vk_GetRenderingAreaGranularityKHR(VkDevice device,
+                                                 const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
+                                                 VkExtent2D* pGranularity) {
     AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
-                                            true /* do lock */);
-}
-static void dynCheck_entry_vkGetRenderingAreaGranularityKHR(
-    VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetRenderingAreaGranularityKHR", "VK_KHR_maintenance5");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetRenderingAreaGranularityKHR(gfxstream_device->internal_object,
+                                                pRenderingAreaInfo, pGranularity,
+                                                true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
-                                            true /* do lock */);
 }
-static void entry_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
-                                                       const VkDeviceImageSubresourceInfoKHR* pInfo,
-                                                       VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetDeviceImageSubresourceLayoutKHR(VkDevice device,
+                                                     const VkDeviceImageSubresourceInfoKHR* pInfo,
+                                                     VkSubresourceLayout2KHR* pLayout) {
     AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
-}
-static void dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR(
-    VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo,
-    VkSubresourceLayout2KHR* pLayout) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSubresourceLayoutKHR",
-                                         "VK_KHR_maintenance5");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetDeviceImageSubresourceLayoutKHR(gfxstream_device->internal_object, pInfo,
+                                                    pLayout, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
 }
-static void entry_vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
-                                                  const VkImageSubresource2KHR* pSubresource,
-                                                  VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
+                                                const VkImageSubresource2KHR* pSubresource,
+                                                VkSubresourceLayout2KHR* pLayout) {
     AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
-                                           true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSubresourceLayout2KHR(
-    VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
-    VkSubresourceLayout2KHR* pLayout) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2KHR", "VK_KHR_maintenance5");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetImageSubresourceLayout2KHR(gfxstream_device->internal_object,
+                                               gfxstream_image->internal_object, pSubresource,
+                                               pLayout, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
-                                           true /* do lock */);
 }
 #endif
 #ifdef VK_ANDROID_native_buffer
-static VkResult entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
-                                                        VkImageUsageFlags imageUsage,
-                                                        int* grallocUsage) {
+VkResult gfxstream_vk_GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
+                                                      VkImageUsageFlags imageUsage,
+                                                      int* grallocUsage) {
     AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
-    vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
-        device, format, imageUsage, grallocUsage, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetSwapchainGrallocUsageANDROID_VkResult_return =
+            vkEnc->vkGetSwapchainGrallocUsageANDROID(gfxstream_device->internal_object, format,
+                                                     imageUsage, grallocUsage, true /* do lock */);
+    }
     return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
 }
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
-                                                                 VkImageUsageFlags imageUsage,
-                                                                 int* grallocUsage) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsageANDROID",
-                                         "VK_ANDROID_native_buffer");
-    }
-    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
-    vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
-        device, format, imageUsage, grallocUsage, true /* do lock */);
-    return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
-}
-static VkResult entry_vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
-                                            VkSemaphore semaphore, VkFence fence) {
+VkResult gfxstream_vk_AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
+                                          VkSemaphore semaphore, VkFence fence) {
     AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
-    vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
-        device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, semaphore);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
+            gfxstream_device->internal_object, gfxstream_image->internal_object, nativeFenceFd,
+            gfxstream_semaphore ? gfxstream_semaphore->internal_object : VK_NULL_HANDLE,
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+            true /* do lock */);
+    }
     return vkAcquireImageANDROID_VkResult_return;
 }
-static VkResult dynCheck_entry_vkAcquireImageANDROID(VkDevice device, VkImage image,
-                                                     int nativeFenceFd, VkSemaphore semaphore,
-                                                     VkFence fence) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
-        sOnInvalidDynamicallyCheckedCall("vkAcquireImageANDROID", "VK_ANDROID_native_buffer");
-    }
-    AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
-    vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
-        device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
-    return vkAcquireImageANDROID_VkResult_return;
-}
-static VkResult entry_vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
-                                                       const VkSemaphore* pWaitSemaphores,
-                                                       VkImage image, int* pNativeFenceFd) {
+VkResult gfxstream_vk_QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
+                                                     const VkSemaphore* pWaitSemaphores,
+                                                     VkImage image, int* pNativeFenceFd) {
     AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
     VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkQueueSignalReleaseImageANDROID_VkResult_return =
-        resources->on_vkQueueSignalReleaseImageANDROID(vkEnc, VK_SUCCESS, queue, waitSemaphoreCount,
-                                                       pWaitSemaphores, image, pNativeFenceFd);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            if (pWaitSemaphores) {
+                VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
+                               pWaitSemaphores[i]);
+                internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
+            }
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkQueueSignalReleaseImageANDROID_VkResult_return =
+            resources->on_vkQueueSignalReleaseImageANDROID(
+                vkEnc, VK_SUCCESS, gfxstream_queue->internal_object, waitSemaphoreCount,
+                internal_pWaitSemaphores.data(), gfxstream_image->internal_object, pNativeFenceFd);
+    }
     return vkQueueSignalReleaseImageANDROID_VkResult_return;
 }
-static VkResult entry_vkGetSwapchainGrallocUsage2ANDROID(
+VkResult gfxstream_vk_GetSwapchainGrallocUsage2ANDROID(
     VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
     VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
     uint64_t* grallocProducerUsage) {
     AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
-    vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
-        device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
-        true /* do lock */);
-    return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID(
-    VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
-    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
-    uint64_t* grallocProducerUsage) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsage2ANDROID",
-                                         "VK_ANDROID_native_buffer");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetSwapchainGrallocUsage2ANDROID_VkResult_return =
+            vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
+                gfxstream_device->internal_object, format, imageUsage, swapchainImageUsage,
+                grallocConsumerUsage, grallocProducerUsage, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
-    vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
-        device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
-        true /* do lock */);
     return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
 }
 #endif
 #ifdef VK_EXT_transform_feedback
-static void entry_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
-                                                       uint32_t firstBinding, uint32_t bindingCount,
-                                                       const VkBuffer* pBuffers,
-                                                       const VkDeviceSize* pOffsets,
-                                                       const VkDeviceSize* pSizes) {
+void gfxstream_vk_CmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
+                                                     uint32_t firstBinding, uint32_t bindingCount,
+                                                     const VkBuffer* pBuffers,
+                                                     const VkDeviceSize* pOffsets,
+                                                     const VkDeviceSize* pSizes) {
     AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
-                                                pOffsets, pSizes, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT(
-    VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
-    const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBindTransformFeedbackBuffersEXT",
-                                         "VK_EXT_transform_feedback");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBuffer> internal_pBuffers(bindingCount);
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+            internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+        }
+        vkEnc->vkCmdBindTransformFeedbackBuffersEXT(
+            gfxstream_commandBuffer->internal_object, firstBinding, bindingCount,
+            internal_pBuffers.data(), pOffsets, pSizes, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
-                                                pOffsets, pSizes, true /* do lock */);
 }
-static void entry_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
-                                                 uint32_t firstCounterBuffer,
-                                                 uint32_t counterBufferCount,
-                                                 const VkBuffer* pCounterBuffers,
-                                                 const VkDeviceSize* pCounterBufferOffsets) {
-    AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
-                                          pCounterBuffers, pCounterBufferOffsets,
-                                          true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginTransformFeedbackEXT(
-    VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
-    const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBeginTransformFeedbackEXT",
-                                         "VK_EXT_transform_feedback");
-    }
-    AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
-                                          pCounterBuffers, pCounterBufferOffsets,
-                                          true /* do lock */);
-}
-static void entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+void gfxstream_vk_CmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
                                                uint32_t firstCounterBuffer,
                                                uint32_t counterBufferCount,
                                                const VkBuffer* pCounterBuffers,
                                                const VkDeviceSize* pCounterBufferOffsets) {
+    AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
+        for (uint32_t i = 0; i < counterBufferCount; ++i) {
+            if (pCounterBuffers) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
+                internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
+            }
+        }
+        vkEnc->vkCmdBeginTransformFeedbackEXT(
+            gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
+            internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
+                                             uint32_t firstCounterBuffer,
+                                             uint32_t counterBufferCount,
+                                             const VkBuffer* pCounterBuffers,
+                                             const VkDeviceSize* pCounterBufferOffsets) {
     AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
-                                        pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
-                                                        uint32_t firstCounterBuffer,
-                                                        uint32_t counterBufferCount,
-                                                        const VkBuffer* pCounterBuffers,
-                                                        const VkDeviceSize* pCounterBufferOffsets) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdEndTransformFeedbackEXT",
-                                         "VK_EXT_transform_feedback");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBuffer> internal_pCounterBuffers(counterBufferCount);
+        for (uint32_t i = 0; i < counterBufferCount; ++i) {
+            if (pCounterBuffers) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pCounterBuffers, pCounterBuffers[i]);
+                internal_pCounterBuffers[i] = gfxstream_pCounterBuffers->internal_object;
+            }
+        }
+        vkEnc->vkCmdEndTransformFeedbackEXT(
+            gfxstream_commandBuffer->internal_object, firstCounterBuffer, counterBufferCount,
+            internal_pCounterBuffers.data(), pCounterBufferOffsets, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
-                                        pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
 }
-static void entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                            uint32_t query, VkQueryControlFlags flags,
-                                            uint32_t index) {
+void gfxstream_vk_CmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                          uint32_t query, VkQueryControlFlags flags,
+                                          uint32_t index) {
     AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
-                                     true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,
-                                                     VkQueryPool queryPool, uint32_t query,
-                                                     VkQueryControlFlags flags, uint32_t index) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBeginQueryIndexedEXT", "VK_EXT_transform_feedback");
-    }
-    AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
-                                     true /* do lock */);
-}
-static void entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
-                                          uint32_t query, uint32_t index) {
-    AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
-                                                   VkQueryPool queryPool, uint32_t query,
-                                                   uint32_t index) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdEndQueryIndexedEXT", "VK_EXT_transform_feedback");
-    }
-    AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
-}
-static void entry_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
-                                                uint32_t instanceCount, uint32_t firstInstance,
-                                                VkBuffer counterBuffer,
-                                                VkDeviceSize counterBufferOffset,
-                                                uint32_t counterOffset, uint32_t vertexStride) {
-    AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
-                                         counterBufferOffset, counterOffset, vertexStride,
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdBeginQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
+                                         gfxstream_queryPool->internal_object, query, flags, index,
                                          true /* do lock */);
-}
-static void dynCheck_entry_vkCmdDrawIndirectByteCountEXT(
-    VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance,
-    VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset,
-    uint32_t vertexStride) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectByteCountEXT",
-                                         "VK_EXT_transform_feedback");
     }
+}
+void gfxstream_vk_CmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                        uint32_t query, uint32_t index) {
+    AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_query_pool, gfxstream_queryPool, queryPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdEndQueryIndexedEXT(gfxstream_commandBuffer->internal_object,
+                                       gfxstream_queryPool->internal_object, query, index,
+                                       true /* do lock */);
+    }
+}
+void gfxstream_vk_CmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount,
+                                              uint32_t firstInstance, VkBuffer counterBuffer,
+                                              VkDeviceSize counterBufferOffset,
+                                              uint32_t counterOffset, uint32_t vertexStride) {
     AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
-                                         counterBufferOffset, counterOffset, vertexStride,
-                                         true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_counterBuffer, counterBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdDrawIndirectByteCountEXT(
+            gfxstream_commandBuffer->internal_object, instanceCount, firstInstance,
+            gfxstream_counterBuffer->internal_object, counterBufferOffset, counterOffset,
+            vertexStride, true /* do lock */);
+    }
 }
 #endif
 #ifdef VK_AMD_gpu_shader_half_float
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -3621,62 +5252,42 @@
 #ifdef VK_EXT_debug_utils
 #endif
 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
-static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
+VkResult gfxstream_vk_GetAndroidHardwareBufferPropertiesANDROID(
     VkDevice device, const AHardwareBuffer* buffer,
     VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
     AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
-        resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
-                                                                  pProperties);
-    return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID(
-    VkDevice device, const AHardwareBuffer* buffer,
-    VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device,
-                                       "VK_ANDROID_external_memory_android_hardware_buffer")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetAndroidHardwareBufferPropertiesANDROID",
-                                         "VK_ANDROID_external_memory_android_hardware_buffer");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
+            resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(
+                vkEnc, VK_SUCCESS, gfxstream_device->internal_object, buffer, pProperties);
     }
-    AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
-    vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
-        resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
-                                                                  pProperties);
     return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
 }
-static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
+VkResult gfxstream_vk_GetMemoryAndroidHardwareBufferANDROID(
     VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
     AHardwareBuffer** pBuffer) {
     AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
-    auto resources = ResourceTracker::get();
-    vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
-        resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
-                                                              pBuffer);
-    return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID(
-    VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
-    AHardwareBuffer** pBuffer) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device,
-                                       "VK_ANDROID_external_memory_android_hardware_buffer")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetMemoryAndroidHardwareBufferANDROID",
-                                         "VK_ANDROID_external_memory_android_hardware_buffer");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkMemoryGetAndroidHardwareBufferInfoANDROID> internal_pInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pInfo[i] = pInfo[i];
+            /* VkMemoryGetAndroidHardwareBufferInfoANDROID::memory */
+            VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, internal_pInfo[i].memory);
+            internal_pInfo[i].memory = gfxstream_memory->internal_object;
+        }
+        auto resources = gfxstream::vk::ResourceTracker::get();
+        vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
+            resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS,
+                                                                  gfxstream_device->internal_object,
+                                                                  internal_pInfo.data(), pBuffer);
     }
-    AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
-    vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
-        resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
-                                                              pBuffer);
     return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
 }
 #endif
@@ -3697,402 +5308,283 @@
 #ifdef VK_EXT_subgroup_size_control
 #endif
 #ifdef VK_EXT_tooling_info
-static VkResult entry_vkGetPhysicalDeviceToolPropertiesEXT(
+VkResult gfxstream_vk_GetPhysicalDeviceToolPropertiesEXT(
     VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
     VkPhysicalDeviceToolProperties* pToolProperties) {
     AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolPropertiesEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
-    vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
-        vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties,
-                                                    true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_physical_device, gfxstream_physicalDevice, physicalDevice);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
+            vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(gfxstream_physicalDevice->internal_object,
+                                                        pToolCount, pToolProperties,
+                                                        true /* do lock */);
+    }
     return vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return;
 }
 #endif
 #ifdef VK_EXT_provoking_vertex
 #endif
 #ifdef VK_EXT_line_rasterization
-static void entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
-                                         uint16_t lineStipplePattern) {
+void gfxstream_vk_CmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                       uint16_t lineStipplePattern) {
     AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
-                                  true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,
-                                                  uint32_t lineStippleFactor,
-                                                  uint16_t lineStipplePattern) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_line_rasterization")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetLineStippleEXT", "VK_EXT_line_rasterization");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetLineStippleEXT(gfxstream_commandBuffer->internal_object, lineStippleFactor,
+                                      lineStipplePattern, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
-                                  true /* do lock */);
 }
 #endif
 #ifdef VK_EXT_index_type_uint8
 #endif
 #ifdef VK_EXT_extended_dynamic_state
-static void entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+void gfxstream_vk_CmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
     AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,
-                                               VkCullModeFlags cullMode) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetCullModeEXT", "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetCullModeEXT(gfxstream_commandBuffer->internal_object, cullMode,
+                                   true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
 }
-static void entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+void gfxstream_vk_CmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
     AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,
-                                                VkFrontFace frontFace) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetFrontFaceEXT", "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetFrontFaceEXT(gfxstream_commandBuffer->internal_object, frontFace,
+                                    true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
 }
-static void entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
-                                               VkPrimitiveTopology primitiveTopology) {
+void gfxstream_vk_CmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
+                                             VkPrimitiveTopology primitiveTopology) {
     AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
-                                                        VkPrimitiveTopology primitiveTopology) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveTopologyEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetPrimitiveTopologyEXT(gfxstream_commandBuffer->internal_object,
+                                            primitiveTopology, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
 }
-static void entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
-                                               uint32_t viewportCount,
-                                               const VkViewport* pViewports) {
+void gfxstream_vk_CmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount,
+                                             const VkViewport* pViewports) {
     AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
-                                        true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
-                                                        uint32_t viewportCount,
-                                                        const VkViewport* pViewports) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWithCountEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetViewportWithCountEXT(gfxstream_commandBuffer->internal_object, viewportCount,
+                                            pViewports, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
-                                        true /* do lock */);
 }
-static void entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
-                                              const VkRect2D* pScissors) {
+void gfxstream_vk_CmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
+                                            const VkRect2D* pScissors) {
     AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,
-                                                       uint32_t scissorCount,
-                                                       const VkRect2D* pScissors) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetScissorWithCountEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetScissorWithCountEXT(gfxstream_commandBuffer->internal_object, scissorCount,
+                                           pScissors, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
 }
-static void entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
-                                             uint32_t bindingCount, const VkBuffer* pBuffers,
-                                             const VkDeviceSize* pOffsets,
-                                             const VkDeviceSize* pSizes,
-                                             const VkDeviceSize* pStrides) {
+void gfxstream_vk_CmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                           uint32_t bindingCount, const VkBuffer* pBuffers,
+                                           const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+                                           const VkDeviceSize* pStrides) {
     AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
-                                      pSizes, pStrides, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
-                                                      uint32_t firstBinding, uint32_t bindingCount,
-                                                      const VkBuffer* pBuffers,
-                                                      const VkDeviceSize* pOffsets,
-                                                      const VkDeviceSize* pSizes,
-                                                      const VkDeviceSize* pStrides) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdBindVertexBuffers2EXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkBuffer> internal_pBuffers(bindingCount);
+        for (uint32_t i = 0; i < bindingCount; ++i) {
+            if (pBuffers) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_pBuffers, pBuffers[i]);
+                internal_pBuffers[i] = gfxstream_pBuffers->internal_object;
+            }
+        }
+        vkEnc->vkCmdBindVertexBuffers2EXT(gfxstream_commandBuffer->internal_object, firstBinding,
+                                          bindingCount, internal_pBuffers.data(), pOffsets, pSizes,
+                                          pStrides, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
-                                      pSizes, pStrides, true /* do lock */);
 }
-static void entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
-                                             VkBool32 depthTestEnable) {
+void gfxstream_vk_CmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
+                                           VkBool32 depthTestEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
-                                                      VkBool32 depthTestEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthTestEnableEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthTestEnableEXT(gfxstream_commandBuffer->internal_object, depthTestEnable,
+                                          true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
 }
-static void entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
-                                              VkBool32 depthWriteEnable) {
+void gfxstream_vk_CmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
+                                            VkBool32 depthWriteEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
-                                                       VkBool32 depthWriteEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthWriteEnableEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthWriteEnableEXT(gfxstream_commandBuffer->internal_object,
+                                           depthWriteEnable, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
 }
-static void entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
-                                            VkCompareOp depthCompareOp) {
+void gfxstream_vk_CmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
+                                          VkCompareOp depthCompareOp) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
-                                                     VkCompareOp depthCompareOp) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthCompareOpEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthCompareOpEXT(gfxstream_commandBuffer->internal_object, depthCompareOp,
+                                         true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
 }
-static void entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
-                                                   VkBool32 depthBoundsTestEnable) {
+void gfxstream_vk_CmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
+                                                 VkBool32 depthBoundsTestEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
-                                            true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
-                                                            VkBool32 depthBoundsTestEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBoundsTestEnableEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthBoundsTestEnableEXT(gfxstream_commandBuffer->internal_object,
+                                                depthBoundsTestEnable, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
-                                            true /* do lock */);
 }
-static void entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
-                                               VkBool32 stencilTestEnable) {
+void gfxstream_vk_CmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
+                                             VkBool32 stencilTestEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
-                                                        VkBool32 stencilTestEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilTestEnableEXT",
-                                         "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilTestEnableEXT(gfxstream_commandBuffer->internal_object,
+                                            stencilTestEnable, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
 }
-static void entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
-                                       VkStencilOp failOp, VkStencilOp passOp,
-                                       VkStencilOp depthFailOp, VkCompareOp compareOp) {
+void gfxstream_vk_CmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
+                                     VkStencilOp failOp, VkStencilOp passOp,
+                                     VkStencilOp depthFailOp, VkCompareOp compareOp) {
     AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
-                                true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
-                                                VkStencilFaceFlags faceMask, VkStencilOp failOp,
-                                                VkStencilOp passOp, VkStencilOp depthFailOp,
-                                                VkCompareOp compareOp) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilOpEXT", "VK_EXT_extended_dynamic_state");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetStencilOpEXT(gfxstream_commandBuffer->internal_object, faceMask, failOp,
+                                    passOp, depthFailOp, compareOp, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
-                                true /* do lock */);
 }
 #endif
 #ifdef VK_EXT_host_image_copy
-static VkResult entry_vkCopyMemoryToImageEXT(
+VkResult gfxstream_vk_CopyMemoryToImageEXT(
     VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
     AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
-    vkCopyMemoryToImageEXT_VkResult_return =
-        vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkCopyMemoryToImageInfoEXT> internal_pCopyMemoryToImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyMemoryToImageInfo[i] = pCopyMemoryToImageInfo[i];
+            /* VkCopyMemoryToImageInfoEXT::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pCopyMemoryToImageInfo[i].dstImage);
+            internal_pCopyMemoryToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkCopyMemoryToImageEXT_VkResult_return = vkEnc->vkCopyMemoryToImageEXT(
+            gfxstream_device->internal_object, internal_pCopyMemoryToImageInfo.data(),
+            true /* do lock */);
+    }
     return vkCopyMemoryToImageEXT_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCopyMemoryToImageEXT(
-    VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
-        sOnInvalidDynamicallyCheckedCall("vkCopyMemoryToImageEXT", "VK_EXT_host_image_copy");
-    }
-    AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
-    vkCopyMemoryToImageEXT_VkResult_return =
-        vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
-    return vkCopyMemoryToImageEXT_VkResult_return;
-}
-static VkResult entry_vkCopyImageToMemoryEXT(
+VkResult gfxstream_vk_CopyImageToMemoryEXT(
     VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
     AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
-    vkCopyImageToMemoryEXT_VkResult_return =
-        vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkCopyImageToMemoryInfoEXT> internal_pCopyImageToMemoryInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyImageToMemoryInfo[i] = pCopyImageToMemoryInfo[i];
+            /* VkCopyImageToMemoryInfoEXT::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pCopyImageToMemoryInfo[i].srcImage);
+            internal_pCopyImageToMemoryInfo[i].srcImage = gfxstream_srcImage->internal_object;
+        }
+        vkCopyImageToMemoryEXT_VkResult_return = vkEnc->vkCopyImageToMemoryEXT(
+            gfxstream_device->internal_object, internal_pCopyImageToMemoryInfo.data(),
+            true /* do lock */);
+    }
     return vkCopyImageToMemoryEXT_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCopyImageToMemoryEXT(
-    VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
-        sOnInvalidDynamicallyCheckedCall("vkCopyImageToMemoryEXT", "VK_EXT_host_image_copy");
-    }
-    AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
-    vkCopyImageToMemoryEXT_VkResult_return =
-        vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
-    return vkCopyImageToMemoryEXT_VkResult_return;
-}
-static VkResult entry_vkCopyImageToImageEXT(
-    VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
+VkResult gfxstream_vk_CopyImageToImageEXT(VkDevice device,
+                                          const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
     AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
-    vkCopyImageToImageEXT_VkResult_return =
-        vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkCopyImageToImageInfoEXT> internal_pCopyImageToImageInfo(1);
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pCopyImageToImageInfo[i] = pCopyImageToImageInfo[i];
+            /* VkCopyImageToImageInfoEXT::srcImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_srcImage,
+                           internal_pCopyImageToImageInfo[i].srcImage);
+            internal_pCopyImageToImageInfo[i].srcImage = gfxstream_srcImage->internal_object;
+            /* VkCopyImageToImageInfoEXT::dstImage */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_dstImage,
+                           internal_pCopyImageToImageInfo[i].dstImage);
+            internal_pCopyImageToImageInfo[i].dstImage = gfxstream_dstImage->internal_object;
+        }
+        vkCopyImageToImageEXT_VkResult_return =
+            vkEnc->vkCopyImageToImageEXT(gfxstream_device->internal_object,
+                                         internal_pCopyImageToImageInfo.data(), true /* do lock */);
+    }
     return vkCopyImageToImageEXT_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCopyImageToImageEXT(
-    VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
-        sOnInvalidDynamicallyCheckedCall("vkCopyImageToImageEXT", "VK_EXT_host_image_copy");
-    }
-    AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
-    vkCopyImageToImageEXT_VkResult_return =
-        vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
-    return vkCopyImageToImageEXT_VkResult_return;
-}
-static VkResult entry_vkTransitionImageLayoutEXT(
+VkResult gfxstream_vk_TransitionImageLayoutEXT(
     VkDevice device, uint32_t transitionCount,
     const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
     AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
-    vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
-        device, transitionCount, pTransitions, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkHostImageLayoutTransitionInfoEXT> internal_pTransitions(transitionCount);
+        for (uint32_t i = 0; i < transitionCount; ++i) {
+            internal_pTransitions[i] = pTransitions[i];
+            /* VkHostImageLayoutTransitionInfoEXT::image */
+            VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, internal_pTransitions[i].image);
+            internal_pTransitions[i].image = gfxstream_image->internal_object;
+        }
+        vkTransitionImageLayoutEXT_VkResult_return =
+            vkEnc->vkTransitionImageLayoutEXT(gfxstream_device->internal_object, transitionCount,
+                                              internal_pTransitions.data(), true /* do lock */);
+    }
     return vkTransitionImageLayoutEXT_VkResult_return;
 }
-static VkResult dynCheck_entry_vkTransitionImageLayoutEXT(
-    VkDevice device, uint32_t transitionCount,
-    const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
-        sOnInvalidDynamicallyCheckedCall("vkTransitionImageLayoutEXT", "VK_EXT_host_image_copy");
-    }
-    AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
-    vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
-        device, transitionCount, pTransitions, true /* do lock */);
-    return vkTransitionImageLayoutEXT_VkResult_return;
-}
-static void entry_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
-                                                  const VkImageSubresource2KHR* pSubresource,
-                                                  VkSubresourceLayout2KHR* pLayout) {
+void gfxstream_vk_GetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
+                                                const VkImageSubresource2KHR* pSubresource,
+                                                VkSubresourceLayout2KHR* pLayout) {
     AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
-                                           true /* do lock */);
-}
-static void dynCheck_entry_vkGetImageSubresourceLayout2EXT(
-    VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
-    VkSubresourceLayout2KHR* pLayout) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2EXT",
-                                         "VK_EXT_host_image_copy");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetImageSubresourceLayout2EXT(gfxstream_device->internal_object,
+                                               gfxstream_image->internal_object, pSubresource,
+                                               pLayout, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
-                                           true /* do lock */);
 }
 #endif
 #ifdef VK_EXT_swapchain_maintenance1
@@ -4106,92 +5598,54 @@
 #ifdef VK_EXT_custom_border_color
 #endif
 #ifdef VK_EXT_private_data
-static VkResult entry_vkCreatePrivateDataSlotEXT(VkDevice device,
-                                                 const VkPrivateDataSlotCreateInfo* pCreateInfo,
-                                                 const VkAllocationCallbacks* pAllocator,
-                                                 VkPrivateDataSlot* pPrivateDataSlot) {
+VkResult gfxstream_vk_CreatePrivateDataSlotEXT(VkDevice device,
+                                               const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                               const VkAllocationCallbacks* pAllocator,
+                                               VkPrivateDataSlot* pPrivateDataSlot) {
     AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
-    vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
-        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreatePrivateDataSlotEXT_VkResult_return =
+            vkEnc->vkCreatePrivateDataSlotEXT(gfxstream_device->internal_object, pCreateInfo,
+                                              pAllocator, pPrivateDataSlot, true /* do lock */);
+    }
     return vkCreatePrivateDataSlotEXT_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCreatePrivateDataSlotEXT(
-    VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
-        sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlotEXT", "VK_EXT_private_data");
-    }
-    AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
-    vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
-        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
-    return vkCreatePrivateDataSlotEXT_VkResult_return;
-}
-static void entry_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
-                                              const VkAllocationCallbacks* pAllocator) {
+void gfxstream_vk_DestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
+                                            const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
-}
-static void dynCheck_entry_vkDestroyPrivateDataSlotEXT(VkDevice device,
-                                                       VkPrivateDataSlot privateDataSlot,
-                                                       const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
-        sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlotEXT", "VK_EXT_private_data");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkDestroyPrivateDataSlotEXT(gfxstream_device->internal_object, privateDataSlot,
+                                           pAllocator, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
 }
-static VkResult entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
-                                          uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
-                                          uint64_t data) {
+VkResult gfxstream_vk_SetPrivateDataEXT(VkDevice device, VkObjectType objectType,
+                                        uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+                                        uint64_t data) {
     AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
-    vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
-        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkSetPrivateDataEXT_VkResult_return =
+            vkEnc->vkSetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
+                                       privateDataSlot, data, true /* do lock */);
+    }
     return vkSetPrivateDataEXT_VkResult_return;
 }
-static VkResult dynCheck_entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
-                                                   uint64_t objectHandle,
-                                                   VkPrivateDataSlot privateDataSlot,
-                                                   uint64_t data) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
-        sOnInvalidDynamicallyCheckedCall("vkSetPrivateDataEXT", "VK_EXT_private_data");
-    }
-    AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
-    vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
-        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
-    return vkSetPrivateDataEXT_VkResult_return;
-}
-static void entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
-                                      uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
-                                      uint64_t* pData) {
+void gfxstream_vk_GetPrivateDataEXT(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
+                                    VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
     AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
-                               true /* do lock */);
-}
-static void dynCheck_entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
-                                               uint64_t objectHandle,
-                                               VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetPrivateDataEXT", "VK_EXT_private_data");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetPrivateDataEXT(gfxstream_device->internal_object, objectType, objectHandle,
+                                   privateDataSlot, pData, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
-                               true /* do lock */);
 }
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
@@ -4209,129 +5663,78 @@
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_EXT_extended_dynamic_state2
-static void entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
-                                                uint32_t patchControlPoints) {
+void gfxstream_vk_CmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
+                                              uint32_t patchControlPoints) {
     AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
-                                                         uint32_t patchControlPoints) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetPatchControlPointsEXT",
-                                         "VK_EXT_extended_dynamic_state2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetPatchControlPointsEXT(gfxstream_commandBuffer->internal_object,
+                                             patchControlPoints, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
 }
-static void entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
-                                                     VkBool32 rasterizerDiscardEnable) {
+void gfxstream_vk_CmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
+                                                   VkBool32 rasterizerDiscardEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
-                                              true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
-                                                              VkBool32 rasterizerDiscardEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetRasterizerDiscardEnableEXT",
-                                         "VK_EXT_extended_dynamic_state2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetRasterizerDiscardEnableEXT(gfxstream_commandBuffer->internal_object,
+                                                  rasterizerDiscardEnable, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
-                                              true /* do lock */);
 }
-static void entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
-                                             VkBool32 depthBiasEnable) {
+void gfxstream_vk_CmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
+                                           VkBool32 depthBiasEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
-                                                      VkBool32 depthBiasEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBiasEnableEXT",
-                                         "VK_EXT_extended_dynamic_state2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetDepthBiasEnableEXT(gfxstream_commandBuffer->internal_object, depthBiasEnable,
+                                          true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
 }
-static void entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
+void gfxstream_vk_CmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
     AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetLogicOpEXT", "VK_EXT_extended_dynamic_state2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetLogicOpEXT(gfxstream_commandBuffer->internal_object, logicOp,
+                                  true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
 }
-static void entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
-                                                    VkBool32 primitiveRestartEnable) {
+void gfxstream_vk_CmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
+                                                  VkBool32 primitiveRestartEnable) {
     AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
-                                             true /* do lock */);
-}
-static void dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
-                                                             VkBool32 primitiveRestartEnable) {
-    auto resources = ResourceTracker::get();
-    VkDevice device = resources->getDevice(commandBuffer);
-    ;
-    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
-        sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveRestartEnableEXT",
-                                         "VK_EXT_extended_dynamic_state2");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCmdSetPrimitiveRestartEnableEXT(gfxstream_commandBuffer->internal_object,
+                                                 primitiveRestartEnable, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
-                                             true /* do lock */);
 }
 #endif
 #ifdef VK_GOOGLE_gfxstream
-static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
-                                                        uint64_t* pAddress) {
+VkResult gfxstream_vk_MapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
+                                                      uint64_t* pAddress) {
     AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
-    vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
-        vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
-    return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
-                                                                 VkDeviceMemory memory,
-                                                                 uint64_t* pAddress) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE",
-                                         "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
+            vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(gfxstream_device->internal_object,
+                                                     gfxstream_memory->internal_object, pAddress,
+                                                     true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
-    vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
-        vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
     return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
 }
-static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateSizedGOOGLE(
     VkDevice device, VkDescriptorSet descriptorSet,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
     uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
@@ -4339,228 +5742,468 @@
     const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
     const VkBufferView* pBufferViews) {
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
-        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
-        bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
-        pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
-    VkDevice device, VkDescriptorSet descriptorSet,
-    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
-    uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
-    const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
-    const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
-    const VkBufferView* pBufferViews) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE",
-                                         "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+                   descriptorUpdateTemplate);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
+        for (uint32_t i = 0; i < imageInfoCount; ++i) {
+            if (pImageInfos) {
+                internal_pImageInfos[i] = pImageInfos[i];
+                /* VkDescriptorImageInfo::imageView */
+                if (internal_pImageInfos[i].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_pImageInfos[i].imageView);
+                    internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
+                }
+            }
+        }
+        std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
+        for (uint32_t i = 0; i < bufferInfoCount; ++i) {
+            if (pBufferInfos) {
+                internal_pBufferInfos[i] = pBufferInfos[i];
+                /* VkDescriptorBufferInfo::buffer */
+                if (internal_pBufferInfos[i].buffer) {
+                    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                                   internal_pBufferInfos[i].buffer);
+                    internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
+                }
+            }
+        }
+        std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
+        for (uint32_t i = 0; i < bufferViewCount; ++i) {
+            if (pBufferViews) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
+                internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
+            }
+        }
+        vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
+            gfxstream_device->internal_object, descriptorSet,
+            gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
+            bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
+            pBufferViewEntryIndices, internal_pImageInfos.data(), internal_pBufferInfos.data(),
+            internal_pBufferViews.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
-        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
-        bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
-        pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
 }
-static void entry_vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
-                                                  const VkCommandBufferBeginInfo* pBeginInfo) {
+void gfxstream_vk_BeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+                                                const VkCommandBufferBeginInfo* pBeginInfo) {
     AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        std::vector<VkCommandBufferBeginInfo> internal_pBeginInfo(1);
+        std::vector<VkCommandBufferInheritanceInfo>
+            internal_VkCommandBufferBeginInfo_pInheritanceInfo;
+        for (uint32_t i = 0; i < 1; ++i) {
+            internal_pBeginInfo[i] = pBeginInfo[i];
+            /* VkCommandBufferBeginInfo::pInheritanceInfo */
+            if (internal_pBeginInfo[i].pInheritanceInfo) {
+                internal_VkCommandBufferBeginInfo_pInheritanceInfo[i] =
+                    internal_pBeginInfo[i].pInheritanceInfo[0];
+                /* VkCommandBufferInheritanceInfo::renderPass */
+                if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass) {
+                    VK_FROM_HANDLE(
+                        gfxstream_vk_render_pass, gfxstream_renderPass,
+                        internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass);
+                    internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].renderPass =
+                        gfxstream_renderPass->internal_object;
+                }
+                /* VkCommandBufferInheritanceInfo::framebuffer */
+                if (internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer) {
+                    VK_FROM_HANDLE(
+                        gfxstream_vk_framebuffer, gfxstream_framebuffer,
+                        internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer);
+                    internal_VkCommandBufferBeginInfo_pInheritanceInfo[i].framebuffer =
+                        gfxstream_framebuffer->internal_object;
+                }
+                internal_pBeginInfo[i].pInheritanceInfo =
+                    &internal_VkCommandBufferBeginInfo_pInheritanceInfo[i];
+            }
+        }
+        vkEnc->vkBeginCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
+                                               internal_pBeginInfo.data(), true /* do lock */);
+    }
 }
-static void entry_vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
+void gfxstream_vk_EndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
     AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkEndCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object,
+                                             true /* do lock */);
+    }
 }
-static void entry_vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
-                                                  VkCommandBufferResetFlags flags) {
+void gfxstream_vk_ResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
+                                                VkCommandBufferResetFlags flags) {
     AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkResetCommandBufferAsyncGOOGLE(gfxstream_commandBuffer->internal_object, flags,
+                                               true /* do lock */);
+    }
 }
-static void entry_vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer,
-                                                uint32_t needHostSync, uint32_t sequenceNumber) {
+void gfxstream_vk_CommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer, uint32_t needHostSync,
+                                              uint32_t sequenceNumber) {
     AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
-    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
-    vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber,
-                                         true /* do lock */);
-}
-static VkResult entry_vkCreateImageWithRequirementsGOOGLE(
-    VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
-    VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
-    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
-    vkCreateImageWithRequirementsGOOGLE_VkResult_return =
-        vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
-                                                   pMemoryRequirements, true /* do lock */);
-    return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkCreateImageWithRequirementsGOOGLE(
-    VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
-    VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE",
-                                         "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(
+            gfxstream_commandBuffer->internal_object);
+        vkEnc->vkCommandBufferHostSyncGOOGLE(gfxstream_commandBuffer->internal_object, needHostSync,
+                                             sequenceNumber, true /* do lock */);
     }
+}
+VkResult gfxstream_vk_CreateImageWithRequirementsGOOGLE(VkDevice device,
+                                                        const VkImageCreateInfo* pCreateInfo,
+                                                        const VkAllocationCallbacks* pAllocator,
+                                                        VkImage* pImage,
+                                                        VkMemoryRequirements* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_image* gfxstream_pImage = (struct gfxstream_vk_image*)vk_image_create(
+        (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_image));
     vkCreateImageWithRequirementsGOOGLE_VkResult_return =
-        vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
-                                                   pMemoryRequirements, true /* do lock */);
+        gfxstream_pImage ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateImageWithRequirementsGOOGLE_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateImageWithRequirementsGOOGLE_VkResult_return =
+            vkEnc->vkCreateImageWithRequirementsGOOGLE(
+                gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                &gfxstream_pImage->internal_object, pMemoryRequirements, true /* do lock */);
+    }
+    *pImage = gfxstream_vk_image_to_handle(gfxstream_pImage);
     return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
 }
-static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
+VkResult gfxstream_vk_CreateBufferWithRequirementsGOOGLE(
     VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
     VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
     AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    struct gfxstream_vk_buffer* gfxstream_pBuffer = (struct gfxstream_vk_buffer*)vk_buffer_create(
+        (vk_device*)gfxstream_device, pCreateInfo, pAllocator, sizeof(struct gfxstream_vk_buffer));
     vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
-        vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
-                                                    pMemoryRequirements, true /* do lock */);
+        gfxstream_pBuffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
+    if (VK_SUCCESS == vkCreateBufferWithRequirementsGOOGLE_VkResult_return) {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
+            vkEnc->vkCreateBufferWithRequirementsGOOGLE(
+                gfxstream_device->internal_object, pCreateInfo, pAllocator,
+                &gfxstream_pBuffer->internal_object, pMemoryRequirements, true /* do lock */);
+    }
+    *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_pBuffer);
     return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
 }
-static VkResult dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE(
-    VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
-    VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE",
-                                         "VK_GOOGLE_gfxstream");
-    }
-    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
-    vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
-        vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
-                                                    pMemoryRequirements, true /* do lock */);
-    return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
-}
-static VkResult entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
-                                                       uint64_t* pAddress, uint64_t* pSize,
-                                                       uint64_t* pHostmemId) {
+VkResult gfxstream_vk_GetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
+                                                     uint64_t* pAddress, uint64_t* pSize,
+                                                     uint64_t* pHostmemId) {
     AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
-    vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
-        device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
+            gfxstream_device->internal_object, gfxstream_memory->internal_object, pAddress, pSize,
+            pHostmemId, true /* do lock */);
+    }
     return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
 }
-static VkResult dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device,
-                                                                VkDeviceMemory memory,
-                                                                uint64_t* pAddress, uint64_t* pSize,
-                                                                uint64_t* pHostmemId) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostAddressInfoGOOGLE", "VK_GOOGLE_gfxstream");
-    }
-    AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
-    vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
-        device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
-    return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
-}
-static VkResult entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
-                                             const VkAllocationCallbacks* pAllocator) {
+VkResult gfxstream_vk_FreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
+                                           const VkAllocationCallbacks* pAllocator) {
     AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
-    vkFreeMemorySyncGOOGLE_VkResult_return =
-        vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
+    if (VK_NULL_HANDLE == memory) {
+        return vkFreeMemorySyncGOOGLE_VkResult_return;
+    }
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkFreeMemorySyncGOOGLE_VkResult_return = vkEnc->vkFreeMemorySyncGOOGLE(
+            gfxstream_device->internal_object,
+            gfxstream_memory ? gfxstream_memory->internal_object : VK_NULL_HANDLE, pAllocator,
+            true /* do lock */);
+    }
+    vk_device_memory_destroy(&gfxstream_device->vk, pAllocator, &gfxstream_memory->vk);
     return vkFreeMemorySyncGOOGLE_VkResult_return;
 }
-static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
-                                                      const VkAllocationCallbacks* pAllocator) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkFreeMemorySyncGOOGLE", "VK_GOOGLE_gfxstream");
-    }
-    AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
-    vkFreeMemorySyncGOOGLE_VkResult_return =
-        vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
-    return vkFreeMemorySyncGOOGLE_VkResult_return;
-}
-static void entry_vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
-                                        uint32_t sequenceNumber) {
+void gfxstream_vk_QueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
+                                      uint32_t sequenceNumber) {
     AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueHostSyncGOOGLE(queue, needHostSync, sequenceNumber, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        vkEnc->vkQueueHostSyncGOOGLE(gfxstream_queue->internal_object, needHostSync, sequenceNumber,
+                                     true /* do lock */);
+    }
 }
-static void entry_vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
-                                           const VkSubmitInfo* pSubmits, VkFence fence) {
+void gfxstream_vk_QueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
+                                         const VkSubmitInfo* pSubmits, VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSubmitInfo> internal_pSubmits(submitCount);
+        std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pWaitSemaphores;
+        std::vector<std::vector<VkCommandBuffer>> internal_VkSubmitInfo_pCommandBuffers;
+        std::vector<std::vector<VkSemaphore>> internal_VkSubmitInfo_pSignalSemaphores;
+        for (uint32_t i = 0; i < submitCount; ++i) {
+            internal_pSubmits[i] = pSubmits[i];
+            /* VkSubmitInfo::pWaitSemaphores */
+            internal_VkSubmitInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkSubmitInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+                internal_pSubmits[i].pWaitSemaphores, internal_pSubmits[i].waitSemaphoreCount);
+            internal_pSubmits[i].pWaitSemaphores = internal_VkSubmitInfo_pWaitSemaphores[i].data();
+            internal_pSubmits[i].waitSemaphoreCount =
+                internal_VkSubmitInfo_pWaitSemaphores[i].size();
+            /* VkSubmitInfo::pCommandBuffers */
+            internal_VkSubmitInfo_pCommandBuffers.push_back(std::vector<VkCommandBuffer>());
+            internal_VkSubmitInfo_pCommandBuffers[i].reserve(
+                internal_pSubmits[i].commandBufferCount);
+            memset(&internal_VkSubmitInfo_pCommandBuffers[i][0], 0,
+                   sizeof(VkCommandBuffer) * internal_pSubmits[i].commandBufferCount);
+            for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferCount; ++j) {
+                VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_pCommandBuffers,
+                               internal_pSubmits[i].pCommandBuffers[j]);
+                internal_VkSubmitInfo_pCommandBuffers[i][j] =
+                    gfxstream_pCommandBuffers->internal_object;
+            }
+            internal_pSubmits[i].pCommandBuffers = internal_VkSubmitInfo_pCommandBuffers[i].data();
+            /* VkSubmitInfo::pSignalSemaphores */
+            internal_VkSubmitInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkSubmitInfo_pSignalSemaphores[i] = transformVkSemaphoreList(
+                internal_pSubmits[i].pSignalSemaphores, internal_pSubmits[i].signalSemaphoreCount);
+            internal_pSubmits[i].pSignalSemaphores =
+                internal_VkSubmitInfo_pSignalSemaphores[i].data();
+            internal_pSubmits[i].signalSemaphoreCount =
+                internal_VkSubmitInfo_pSignalSemaphores[i].size();
+        }
+        vkEnc->vkQueueSubmitAsyncGOOGLE(
+            gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+            true /* do lock */);
+    }
 }
-static void entry_vkQueueWaitIdleAsyncGOOGLE(VkQueue queue) {
+void gfxstream_vk_QueueWaitIdleAsyncGOOGLE(VkQueue queue) {
     AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueWaitIdleAsyncGOOGLE(queue, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        vkEnc->vkQueueWaitIdleAsyncGOOGLE(gfxstream_queue->internal_object, true /* do lock */);
+    }
 }
-static void entry_vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
-                                               const VkBindSparseInfo* pBindInfo, VkFence fence) {
+void gfxstream_vk_QueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
+                                             const VkBindSparseInfo* pBindInfo, VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
-}
-static void entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
-                                               VkDeviceSize* pOffset,
-                                               VkDeviceSize* pRowPitchAlignment) {
-    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
-                                        true /* do lock */);
-}
-static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
-                                                        VkDeviceSize* pOffset,
-                                                        VkDeviceSize* pRowPitchAlignment) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayoutGOOGLE", "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkBindSparseInfo> internal_pBindInfo(bindInfoCount);
+        std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pWaitSemaphores;
+        std::vector<std::vector<VkSparseBufferMemoryBindInfo>>
+            internal_VkBindSparseInfo_pBufferBinds;
+        std::vector<std::vector<VkSparseMemoryBind>> internal_VkSparseBufferMemoryBindInfo_pBinds;
+        std::vector<std::vector<VkSparseImageOpaqueMemoryBindInfo>>
+            internal_VkBindSparseInfo_pImageOpaqueBinds;
+        std::vector<std::vector<VkSparseMemoryBind>>
+            internal_VkSparseImageOpaqueMemoryBindInfo_pBinds;
+        std::vector<std::vector<VkSparseImageMemoryBindInfo>> internal_VkBindSparseInfo_pImageBinds;
+        std::vector<std::vector<VkSparseImageMemoryBind>>
+            internal_VkSparseImageMemoryBindInfo_pBinds;
+        std::vector<std::vector<VkSemaphore>> internal_VkBindSparseInfo_pSignalSemaphores;
+        for (uint32_t i = 0; i < bindInfoCount; ++i) {
+            internal_pBindInfo[i] = pBindInfo[i];
+            /* VkBindSparseInfo::pWaitSemaphores */
+            internal_VkBindSparseInfo_pWaitSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkBindSparseInfo_pWaitSemaphores[i] = transformVkSemaphoreList(
+                internal_pBindInfo[i].pWaitSemaphores, internal_pBindInfo[i].waitSemaphoreCount);
+            internal_pBindInfo[i].pWaitSemaphores =
+                internal_VkBindSparseInfo_pWaitSemaphores[i].data();
+            internal_pBindInfo[i].waitSemaphoreCount =
+                internal_VkBindSparseInfo_pWaitSemaphores[i].size();
+            /* VkBindSparseInfo::pBufferBinds */
+            internal_VkBindSparseInfo_pBufferBinds.push_back(
+                std::vector<VkSparseBufferMemoryBindInfo>());
+            internal_VkBindSparseInfo_pBufferBinds[i].reserve(
+                internal_pBindInfo[i].bufferBindCount);
+            memset(&internal_VkBindSparseInfo_pBufferBinds[i][0], 0,
+                   sizeof(VkSparseBufferMemoryBindInfo) * internal_pBindInfo[i].bufferBindCount);
+            for (uint32_t j = 0; j < internal_pBindInfo[i].bufferBindCount; ++j) {
+                internal_VkBindSparseInfo_pBufferBinds[i][j] =
+                    internal_pBindInfo[i].pBufferBinds[j];
+                /* VkSparseBufferMemoryBindInfo::buffer */
+                VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                               internal_VkBindSparseInfo_pBufferBinds[i][j].buffer);
+                internal_VkBindSparseInfo_pBufferBinds[i][j].buffer =
+                    gfxstream_buffer->internal_object;
+                /* VkSparseBufferMemoryBindInfo::pBinds */
+                internal_VkSparseBufferMemoryBindInfo_pBinds.push_back(
+                    std::vector<VkSparseMemoryBind>());
+                internal_VkSparseBufferMemoryBindInfo_pBinds[j].reserve(
+                    internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+                memset(&internal_VkSparseBufferMemoryBindInfo_pBinds[j][0], 0,
+                       sizeof(VkSparseMemoryBind) *
+                           internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount);
+                for (uint32_t k = 0; k < internal_VkBindSparseInfo_pBufferBinds[i][j].bindCount;
+                     ++k) {
+                    internal_VkSparseBufferMemoryBindInfo_pBinds[j][k] =
+                        internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds[k];
+                    /* VkSparseMemoryBind::memory */
+                    if (internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory) {
+                        VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                                       internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory);
+                        internal_VkSparseBufferMemoryBindInfo_pBinds[j][k].memory =
+                            gfxstream_memory->internal_object;
+                    }
+                }
+                internal_VkBindSparseInfo_pBufferBinds[i][j].pBinds =
+                    internal_VkSparseBufferMemoryBindInfo_pBinds[j].data();
+            }
+            internal_pBindInfo[i].pBufferBinds = internal_VkBindSparseInfo_pBufferBinds[i].data();
+            /* VkBindSparseInfo::pImageOpaqueBinds */
+            internal_VkBindSparseInfo_pImageOpaqueBinds.push_back(
+                std::vector<VkSparseImageOpaqueMemoryBindInfo>());
+            internal_VkBindSparseInfo_pImageOpaqueBinds[i].reserve(
+                internal_pBindInfo[i].imageOpaqueBindCount);
+            memset(&internal_VkBindSparseInfo_pImageOpaqueBinds[i][0], 0,
+                   sizeof(VkSparseImageOpaqueMemoryBindInfo) *
+                       internal_pBindInfo[i].imageOpaqueBindCount);
+            for (uint32_t j = 0; j < internal_pBindInfo[i].imageOpaqueBindCount; ++j) {
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i][j] =
+                    internal_pBindInfo[i].pImageOpaqueBinds[j];
+                /* VkSparseImageOpaqueMemoryBindInfo::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image);
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].image =
+                    gfxstream_image->internal_object;
+                /* VkSparseImageOpaqueMemoryBindInfo::pBinds */
+                internal_VkSparseImageOpaqueMemoryBindInfo_pBinds.push_back(
+                    std::vector<VkSparseMemoryBind>());
+                internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].reserve(
+                    internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+                memset(&internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][0], 0,
+                       sizeof(VkSparseMemoryBind) *
+                           internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount);
+                for (uint32_t l = 0;
+                     l < internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].bindCount; ++l) {
+                    internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l] =
+                        internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds[l];
+                    /* VkSparseMemoryBind::memory */
+                    if (internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory) {
+                        VK_FROM_HANDLE(
+                            gfxstream_vk_device_memory, gfxstream_memory,
+                            internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory);
+                        internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j][l].memory =
+                            gfxstream_memory->internal_object;
+                    }
+                }
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i][j].pBinds =
+                    internal_VkSparseImageOpaqueMemoryBindInfo_pBinds[j].data();
+            }
+            internal_pBindInfo[i].pImageOpaqueBinds =
+                internal_VkBindSparseInfo_pImageOpaqueBinds[i].data();
+            /* VkBindSparseInfo::pImageBinds */
+            internal_VkBindSparseInfo_pImageBinds.push_back(
+                std::vector<VkSparseImageMemoryBindInfo>());
+            internal_VkBindSparseInfo_pImageBinds[i].reserve(internal_pBindInfo[i].imageBindCount);
+            memset(&internal_VkBindSparseInfo_pImageBinds[i][0], 0,
+                   sizeof(VkSparseImageMemoryBindInfo) * internal_pBindInfo[i].imageBindCount);
+            for (uint32_t j = 0; j < internal_pBindInfo[i].imageBindCount; ++j) {
+                internal_VkBindSparseInfo_pImageBinds[i][j] = internal_pBindInfo[i].pImageBinds[j];
+                /* VkSparseImageMemoryBindInfo::image */
+                VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image,
+                               internal_VkBindSparseInfo_pImageBinds[i][j].image);
+                internal_VkBindSparseInfo_pImageBinds[i][j].image =
+                    gfxstream_image->internal_object;
+                /* VkSparseImageMemoryBindInfo::pBinds */
+                internal_VkSparseImageMemoryBindInfo_pBinds.push_back(
+                    std::vector<VkSparseImageMemoryBind>());
+                internal_VkSparseImageMemoryBindInfo_pBinds[j].reserve(
+                    internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+                memset(&internal_VkSparseImageMemoryBindInfo_pBinds[j][0], 0,
+                       sizeof(VkSparseImageMemoryBind) *
+                           internal_VkBindSparseInfo_pImageBinds[i][j].bindCount);
+                for (uint32_t m = 0; m < internal_VkBindSparseInfo_pImageBinds[i][j].bindCount;
+                     ++m) {
+                    internal_VkSparseImageMemoryBindInfo_pBinds[j][m] =
+                        internal_VkBindSparseInfo_pImageBinds[i][j].pBinds[m];
+                    /* VkSparseImageMemoryBind::memory */
+                    if (internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory) {
+                        VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory,
+                                       internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory);
+                        internal_VkSparseImageMemoryBindInfo_pBinds[j][m].memory =
+                            gfxstream_memory->internal_object;
+                    }
+                }
+                internal_VkBindSparseInfo_pImageBinds[i][j].pBinds =
+                    internal_VkSparseImageMemoryBindInfo_pBinds[j].data();
+            }
+            internal_pBindInfo[i].pImageBinds = internal_VkBindSparseInfo_pImageBinds[i].data();
+            /* VkBindSparseInfo::pSignalSemaphores */
+            internal_VkBindSparseInfo_pSignalSemaphores.push_back(std::vector<VkSemaphore>());
+            internal_VkBindSparseInfo_pSignalSemaphores[i] =
+                transformVkSemaphoreList(internal_pBindInfo[i].pSignalSemaphores,
+                                         internal_pBindInfo[i].signalSemaphoreCount);
+            internal_pBindInfo[i].pSignalSemaphores =
+                internal_VkBindSparseInfo_pSignalSemaphores[i].data();
+            internal_pBindInfo[i].signalSemaphoreCount =
+                internal_VkBindSparseInfo_pSignalSemaphores[i].size();
+        }
+        vkEnc->vkQueueBindSparseAsyncGOOGLE(
+            gfxstream_queue->internal_object, bindInfoCount, internal_pBindInfo.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+            true /* do lock */);
     }
+}
+void gfxstream_vk_GetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
+                                             VkDeviceSize* pOffset,
+                                             VkDeviceSize* pRowPitchAlignment) {
     AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
-                                        true /* do lock */);
-}
-static void entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
-                                                const VkImageCreateInfo* pCreateInfo,
-                                                VkDeviceSize* pOffset,
-                                                VkDeviceSize* pRowPitchAlignment) {
-    AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
-                                         true /* do lock */);
-}
-static void dynCheck_entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
-                                                         const VkImageCreateInfo* pCreateInfo,
-                                                         VkDeviceSize* pOffset,
-                                                         VkDeviceSize* pRowPitchAlignment) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayout2GOOGLE", "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetLinearImageLayoutGOOGLE(gfxstream_device->internal_object, format, pOffset,
+                                            pRowPitchAlignment, true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
-                                         true /* do lock */);
 }
-static void entry_vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
-                                             VkDeviceSize dataSize, const void* pData) {
+void gfxstream_vk_GetLinearImageLayout2GOOGLE(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+                                              VkDeviceSize* pOffset,
+                                              VkDeviceSize* pRowPitchAlignment) {
+    AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkGetLinearImageLayout2GOOGLE(gfxstream_device->internal_object, pCreateInfo,
+                                             pOffset, pRowPitchAlignment, true /* do lock */);
+    }
+}
+void gfxstream_vk_QueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
+                                           VkDeviceSize dataSize, const void* pData) {
     AEMU_SCOPED_TRACE("vkQueueFlushCommandsGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueFlushCommandsGOOGLE(queue, commandBuffer, dataSize, pData, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        vkEnc->vkQueueFlushCommandsGOOGLE(gfxstream_queue->internal_object,
+                                          gfxstream_commandBuffer->internal_object, dataSize, pData,
+                                          true /* do lock */);
+    }
 }
-static void entry_vkQueueCommitDescriptorSetUpdatesGOOGLE(
+void gfxstream_vk_QueueCommitDescriptorSetUpdatesGOOGLE(
     VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
     uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
     const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
@@ -4568,71 +6211,166 @@
     const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
     const VkWriteDescriptorSet* pPendingDescriptorWrites) {
     AEMU_SCOPED_TRACE("vkQueueCommitDescriptorSetUpdatesGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
-        queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts,
-        pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
-        pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites,
-        true /* do lock */);
-}
-static void entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
-                                                   uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
-    AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
-                                            true /* do lock */);
-}
-static void dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device,
-                                                            VkDescriptorPool descriptorPool,
-                                                            uint32_t* pPoolIdCount,
-                                                            uint64_t* pPoolIds) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkCollectDescriptorPoolIdsGOOGLE", "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkDescriptorPool> internal_pDescriptorPools(descriptorPoolCount);
+        for (uint32_t i = 0; i < descriptorPoolCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_pDescriptorPools,
+                           pDescriptorPools[i]);
+            internal_pDescriptorPools[i] = gfxstream_pDescriptorPools->internal_object;
+        }
+        std::vector<VkDescriptorSetLayout> internal_pSetLayouts(descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
+            VK_FROM_HANDLE(gfxstream_vk_descriptor_set_layout, gfxstream_pSetLayouts,
+                           pSetLayouts[i]);
+            internal_pSetLayouts[i] = gfxstream_pSetLayouts->internal_object;
+        }
+        std::vector<VkWriteDescriptorSet> internal_pPendingDescriptorWrites(
+            pendingDescriptorWriteCount);
+        std::vector<std::vector<VkDescriptorImageInfo>> internal_VkWriteDescriptorSet_pImageInfo;
+        std::vector<std::vector<VkDescriptorBufferInfo>> internal_VkWriteDescriptorSet_pBufferInfo;
+        std::vector<std::vector<VkBufferView>> internal_VkWriteDescriptorSet_pTexelBufferView;
+        for (uint32_t i = 0; i < pendingDescriptorWriteCount; ++i) {
+            internal_pPendingDescriptorWrites[i] = pPendingDescriptorWrites[i];
+            /* VkWriteDescriptorSet::pImageInfo */
+            internal_VkWriteDescriptorSet_pImageInfo.push_back(
+                std::vector<VkDescriptorImageInfo>());
+            internal_VkWriteDescriptorSet_pImageInfo[i].reserve(
+                internal_pPendingDescriptorWrites[i].descriptorCount);
+            memset(&internal_VkWriteDescriptorSet_pImageInfo[i][0], 0,
+                   sizeof(VkDescriptorImageInfo) *
+                       internal_pPendingDescriptorWrites[i].descriptorCount);
+            for (uint32_t j = 0; j < internal_pPendingDescriptorWrites[i].descriptorCount; ++j) {
+                if (internal_pPendingDescriptorWrites[i].pImageInfo) {
+                    internal_VkWriteDescriptorSet_pImageInfo[i][j] =
+                        internal_pPendingDescriptorWrites[i].pImageInfo[j];
+                    /* VkDescriptorImageInfo::imageView */
+                    if (internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView) {
+                        VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                       internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView);
+                        internal_VkWriteDescriptorSet_pImageInfo[i][j].imageView =
+                            gfxstream_imageView->internal_object;
+                    }
+                }
+            }
+            internal_pPendingDescriptorWrites[i].pImageInfo =
+                internal_VkWriteDescriptorSet_pImageInfo[i].data();
+            /* VkWriteDescriptorSet::pBufferInfo */
+            internal_VkWriteDescriptorSet_pBufferInfo.push_back(
+                std::vector<VkDescriptorBufferInfo>());
+            internal_VkWriteDescriptorSet_pBufferInfo[i].reserve(
+                internal_pPendingDescriptorWrites[i].descriptorCount);
+            memset(&internal_VkWriteDescriptorSet_pBufferInfo[i][0], 0,
+                   sizeof(VkDescriptorBufferInfo) *
+                       internal_pPendingDescriptorWrites[i].descriptorCount);
+            for (uint32_t j = 0; j < internal_pPendingDescriptorWrites[i].descriptorCount; ++j) {
+                if (internal_pPendingDescriptorWrites[i].pBufferInfo) {
+                    internal_VkWriteDescriptorSet_pBufferInfo[i][j] =
+                        internal_pPendingDescriptorWrites[i].pBufferInfo[j];
+                    /* VkDescriptorBufferInfo::buffer */
+                    if (internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer) {
+                        VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                                       internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer);
+                        internal_VkWriteDescriptorSet_pBufferInfo[i][j].buffer =
+                            gfxstream_buffer->internal_object;
+                    }
+                }
+            }
+            internal_pPendingDescriptorWrites[i].pBufferInfo =
+                internal_VkWriteDescriptorSet_pBufferInfo[i].data();
+            /* VkWriteDescriptorSet::pTexelBufferView */
+            internal_VkWriteDescriptorSet_pTexelBufferView.push_back(std::vector<VkBufferView>());
+            internal_VkWriteDescriptorSet_pTexelBufferView[i].reserve(
+                internal_pPendingDescriptorWrites[i].descriptorCount);
+            memset(&internal_VkWriteDescriptorSet_pTexelBufferView[i][0], 0,
+                   sizeof(VkBufferView) * internal_pPendingDescriptorWrites[i].descriptorCount);
+            for (uint32_t j = 0; j < internal_pPendingDescriptorWrites[i].descriptorCount; ++j) {
+                if (internal_pPendingDescriptorWrites[i].pTexelBufferView) {
+                    VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pTexelBufferView,
+                                   internal_pPendingDescriptorWrites[i].pTexelBufferView[j]);
+                    internal_VkWriteDescriptorSet_pTexelBufferView[i][j] =
+                        gfxstream_pTexelBufferView->internal_object;
+                }
+            }
+            internal_pPendingDescriptorWrites[i].pTexelBufferView =
+                internal_VkWriteDescriptorSet_pTexelBufferView[i].data();
+        }
+        vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
+            gfxstream_queue->internal_object, descriptorPoolCount, internal_pDescriptorPools.data(),
+            descriptorSetCount, internal_pSetLayouts.data(), pDescriptorSetPoolIds,
+            pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
+            pDescriptorWriteStartingIndices, pendingDescriptorWriteCount,
+            internal_pPendingDescriptorWrites.data(), true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
-                                            true /* do lock */);
 }
-static void entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
-                                                              uint32_t waitSemaphoreCount,
-                                                              const VkSemaphore* pWaitSemaphores,
-                                                              VkImage image) {
+void gfxstream_vk_CollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
+                                                 uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
+    AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_pool, gfxstream_descriptorPool, descriptorPool);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkEnc->vkCollectDescriptorPoolIdsGOOGLE(gfxstream_device->internal_object,
+                                                gfxstream_descriptorPool->internal_object,
+                                                pPoolIdCount, pPoolIds, true /* do lock */);
+    }
+}
+void gfxstream_vk_QueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
+                                                            uint32_t waitSemaphoreCount,
+                                                            const VkSemaphore* pWaitSemaphores,
+                                                            VkImage image) {
     AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores,
-                                                       image, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_image, gfxstream_image, image);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSemaphore> internal_pWaitSemaphores(waitSemaphoreCount);
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
+            if (pWaitSemaphores) {
+                VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_pWaitSemaphores,
+                               pWaitSemaphores[i]);
+                internal_pWaitSemaphores[i] = gfxstream_pWaitSemaphores->internal_object;
+            }
+        }
+        vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(
+            gfxstream_queue->internal_object, waitSemaphoreCount, internal_pWaitSemaphores.data(),
+            gfxstream_image->internal_object, true /* do lock */);
+    }
 }
-static void entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
-                                                          VkCommandBuffer commandBuffer,
-                                                          VkDeviceMemory deviceMemory,
-                                                          VkDeviceSize dataOffset,
-                                                          VkDeviceSize dataSize) {
+void gfxstream_vk_QueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
+                                                        VkCommandBuffer commandBuffer,
+                                                        VkDeviceMemory deviceMemory,
+                                                        VkDeviceSize dataOffset,
+                                                        VkDeviceSize dataSize) {
     AEMU_SCOPED_TRACE("vkQueueFlushCommandsFromAuxMemoryGOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(queue, commandBuffer, deviceMemory, dataOffset,
-                                                   dataSize, true /* do lock */);
-}
-static VkResult entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
-    AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
-    vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
-    return vkGetBlobGOOGLE_VkResult_return;
-}
-static VkResult dynCheck_entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkGetBlobGOOGLE", "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer, commandBuffer);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_deviceMemory, deviceMemory);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(
+            gfxstream_queue->internal_object, gfxstream_commandBuffer->internal_object,
+            gfxstream_deviceMemory->internal_object, dataOffset, dataSize, true /* do lock */);
     }
+}
+VkResult gfxstream_vk_GetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
     AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
     VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
-    vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_device_memory, gfxstream_memory, memory);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        vkGetBlobGOOGLE_VkResult_return =
+            vkEnc->vkGetBlobGOOGLE(gfxstream_device->internal_object,
+                                   gfxstream_memory->internal_object, true /* do lock */);
+    }
     return vkGetBlobGOOGLE_VkResult_return;
 }
-static void entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+void gfxstream_vk_UpdateDescriptorSetWithTemplateSized2GOOGLE(
     VkDevice device, VkDescriptorSet descriptorSet,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
     uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
@@ -4641,3600 +6379,116 @@
     const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
     const uint8_t* pInlineUniformBlockData) {
     AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
-        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
-        bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
-        pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
-        true /* do lock */);
-}
-static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
-    VkDevice device, VkDescriptorSet descriptorSet,
-    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
-    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
-    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
-    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
-    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
-    const uint8_t* pInlineUniformBlockData) {
-    auto resources = ResourceTracker::get();
-    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
-        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSized2GOOGLE",
-                                         "VK_GOOGLE_gfxstream");
+    VK_FROM_HANDLE(gfxstream_vk_device, gfxstream_device, device);
+    VK_FROM_HANDLE(gfxstream_vk_descriptor_update_template, gfxstream_descriptorUpdateTemplate,
+                   descriptorUpdateTemplate);
+    {
+        auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder();
+        std::vector<VkDescriptorImageInfo> internal_pImageInfos(imageInfoCount);
+        for (uint32_t i = 0; i < imageInfoCount; ++i) {
+            if (pImageInfos) {
+                internal_pImageInfos[i] = pImageInfos[i];
+                /* VkDescriptorImageInfo::imageView */
+                if (internal_pImageInfos[i].imageView) {
+                    VK_FROM_HANDLE(gfxstream_vk_image_view, gfxstream_imageView,
+                                   internal_pImageInfos[i].imageView);
+                    internal_pImageInfos[i].imageView = gfxstream_imageView->internal_object;
+                }
+            }
+        }
+        std::vector<VkDescriptorBufferInfo> internal_pBufferInfos(bufferInfoCount);
+        for (uint32_t i = 0; i < bufferInfoCount; ++i) {
+            if (pBufferInfos) {
+                internal_pBufferInfos[i] = pBufferInfos[i];
+                /* VkDescriptorBufferInfo::buffer */
+                if (internal_pBufferInfos[i].buffer) {
+                    VK_FROM_HANDLE(gfxstream_vk_buffer, gfxstream_buffer,
+                                   internal_pBufferInfos[i].buffer);
+                    internal_pBufferInfos[i].buffer = gfxstream_buffer->internal_object;
+                }
+            }
+        }
+        std::vector<VkBufferView> internal_pBufferViews(bufferViewCount);
+        for (uint32_t i = 0; i < bufferViewCount; ++i) {
+            if (pBufferViews) {
+                VK_FROM_HANDLE(gfxstream_vk_buffer_view, gfxstream_pBufferViews, pBufferViews[i]);
+                internal_pBufferViews[i] = gfxstream_pBufferViews->internal_object;
+            }
+        }
+        vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+            gfxstream_device->internal_object, descriptorSet,
+            gfxstream_descriptorUpdateTemplate->internal_object, imageInfoCount, bufferInfoCount,
+            bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices,
+            pBufferInfoEntryIndices, pBufferViewEntryIndices, internal_pImageInfos.data(),
+            internal_pBufferInfos.data(), internal_pBufferViews.data(), pInlineUniformBlockData,
+            true /* do lock */);
     }
-    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
-    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
-    vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
-        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
-        bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
-        pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
-        true /* do lock */);
 }
-static void entry_vkQueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
-                                            const VkSubmitInfo2* pSubmits, VkFence fence) {
+void gfxstream_vk_QueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
+                                          const VkSubmitInfo2* pSubmits, VkFence fence) {
     AEMU_SCOPED_TRACE("vkQueueSubmitAsync2GOOGLE");
-    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
-    vkEnc->vkQueueSubmitAsync2GOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
+    VK_FROM_HANDLE(gfxstream_vk_queue, gfxstream_queue, queue);
+    VK_FROM_HANDLE(gfxstream_vk_fence, gfxstream_fence, fence);
+    {
+        auto vkEnc =
+            gfxstream::vk::ResourceTracker::getQueueEncoder(gfxstream_queue->internal_object);
+        std::vector<VkSubmitInfo2> internal_pSubmits(submitCount);
+        std::vector<std::vector<VkSemaphoreSubmitInfo>> internal_VkSubmitInfo2_pWaitSemaphoreInfos;
+        std::vector<std::vector<VkCommandBufferSubmitInfo>>
+            internal_VkSubmitInfo2_pCommandBufferInfos;
+        std::vector<std::vector<VkSemaphoreSubmitInfo>>
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos;
+        for (uint32_t i = 0; i < submitCount; ++i) {
+            internal_pSubmits[i] = pSubmits[i];
+            /* VkSubmitInfo2::pWaitSemaphoreInfos */
+            internal_VkSubmitInfo2_pWaitSemaphoreInfos.push_back(
+                std::vector<VkSemaphoreSubmitInfo>());
+            internal_VkSubmitInfo2_pWaitSemaphoreInfos[i] =
+                transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pWaitSemaphoreInfos,
+                                                   internal_pSubmits[i].waitSemaphoreInfoCount);
+            internal_pSubmits[i].pWaitSemaphoreInfos =
+                internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].data();
+            internal_pSubmits[i].waitSemaphoreInfoCount =
+                internal_VkSubmitInfo2_pWaitSemaphoreInfos[i].size();
+            /* VkSubmitInfo2::pCommandBufferInfos */
+            internal_VkSubmitInfo2_pCommandBufferInfos.push_back(
+                std::vector<VkCommandBufferSubmitInfo>());
+            internal_VkSubmitInfo2_pCommandBufferInfos[i].reserve(
+                internal_pSubmits[i].commandBufferInfoCount);
+            memset(&internal_VkSubmitInfo2_pCommandBufferInfos[i][0], 0,
+                   sizeof(VkCommandBufferSubmitInfo) * internal_pSubmits[i].commandBufferInfoCount);
+            for (uint32_t j = 0; j < internal_pSubmits[i].commandBufferInfoCount; ++j) {
+                internal_VkSubmitInfo2_pCommandBufferInfos[i][j] =
+                    internal_pSubmits[i].pCommandBufferInfos[j];
+                /* VkCommandBufferSubmitInfo::commandBuffer */
+                VK_FROM_HANDLE(gfxstream_vk_command_buffer, gfxstream_commandBuffer,
+                               internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer);
+                internal_VkSubmitInfo2_pCommandBufferInfos[i][j].commandBuffer =
+                    gfxstream_commandBuffer->internal_object;
+            }
+            internal_pSubmits[i].pCommandBufferInfos =
+                internal_VkSubmitInfo2_pCommandBufferInfos[i].data();
+            /* VkSubmitInfo2::pSignalSemaphoreInfos */
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos.push_back(
+                std::vector<VkSemaphoreSubmitInfo>());
+            internal_VkSubmitInfo2_pSignalSemaphoreInfos[i] =
+                transformVkSemaphoreSubmitInfoList(internal_pSubmits[i].pSignalSemaphoreInfos,
+                                                   internal_pSubmits[i].signalSemaphoreInfoCount);
+            internal_pSubmits[i].pSignalSemaphoreInfos =
+                internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].data();
+            internal_pSubmits[i].signalSemaphoreInfoCount =
+                internal_VkSubmitInfo2_pSignalSemaphoreInfos[i].size();
+        }
+        vkEnc->vkQueueSubmitAsync2GOOGLE(
+            gfxstream_queue->internal_object, submitCount, internal_pSubmits.data(),
+            gfxstream_fence ? gfxstream_fence->internal_object : VK_NULL_HANDLE,
+            true /* do lock */);
+    }
 }
 #endif
 #ifdef VK_EXT_load_store_op_none
 #endif
 #ifdef VK_EXT_image_compression_control_swapchain
 #endif
-void* goldfish_vulkan_get_proc_address(const char* name) {
-#ifdef VK_VERSION_1_0
-    if (!strcmp(name, "vkCreateInstance")) {
-        return (void*)entry_vkCreateInstance;
-    }
-    if (!strcmp(name, "vkDestroyInstance")) {
-        return (void*)entry_vkDestroyInstance;
-    }
-    if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
-        return (void*)entry_vkEnumeratePhysicalDevices;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
-        return (void*)entry_vkGetPhysicalDeviceFeatures;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
-    }
-    if (!strcmp(name, "vkGetInstanceProcAddr")) {
-        return (void*)entry_vkGetInstanceProcAddr;
-    }
-    if (!strcmp(name, "vkGetDeviceProcAddr")) {
-        return (void*)entry_vkGetDeviceProcAddr;
-    }
-    if (!strcmp(name, "vkCreateDevice")) {
-        return (void*)entry_vkCreateDevice;
-    }
-    if (!strcmp(name, "vkDestroyDevice")) {
-        return (void*)entry_vkDestroyDevice;
-    }
-    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
-        return (void*)entry_vkEnumerateInstanceExtensionProperties;
-    }
-    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
-        return (void*)entry_vkEnumerateDeviceExtensionProperties;
-    }
-    if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
-        return (void*)entry_vkEnumerateInstanceLayerProperties;
-    }
-    if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
-        return (void*)entry_vkEnumerateDeviceLayerProperties;
-    }
-    if (!strcmp(name, "vkGetDeviceQueue")) {
-        return (void*)entry_vkGetDeviceQueue;
-    }
-    if (!strcmp(name, "vkQueueSubmit")) {
-        return (void*)entry_vkQueueSubmit;
-    }
-    if (!strcmp(name, "vkQueueWaitIdle")) {
-        return (void*)entry_vkQueueWaitIdle;
-    }
-    if (!strcmp(name, "vkDeviceWaitIdle")) {
-        return (void*)entry_vkDeviceWaitIdle;
-    }
-    if (!strcmp(name, "vkAllocateMemory")) {
-        return (void*)entry_vkAllocateMemory;
-    }
-    if (!strcmp(name, "vkFreeMemory")) {
-        return (void*)entry_vkFreeMemory;
-    }
-    if (!strcmp(name, "vkMapMemory")) {
-        return (void*)entry_vkMapMemory;
-    }
-    if (!strcmp(name, "vkUnmapMemory")) {
-        return (void*)entry_vkUnmapMemory;
-    }
-    if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
-        return (void*)entry_vkFlushMappedMemoryRanges;
-    }
-    if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
-        return (void*)entry_vkInvalidateMappedMemoryRanges;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
-        return (void*)entry_vkGetDeviceMemoryCommitment;
-    }
-    if (!strcmp(name, "vkBindBufferMemory")) {
-        return (void*)entry_vkBindBufferMemory;
-    }
-    if (!strcmp(name, "vkBindImageMemory")) {
-        return (void*)entry_vkBindImageMemory;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
-        return (void*)entry_vkGetBufferMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetImageMemoryRequirements")) {
-        return (void*)entry_vkGetImageMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
-        return (void*)entry_vkGetImageSparseMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
-    }
-    if (!strcmp(name, "vkQueueBindSparse")) {
-        return (void*)entry_vkQueueBindSparse;
-    }
-    if (!strcmp(name, "vkCreateFence")) {
-        return (void*)entry_vkCreateFence;
-    }
-    if (!strcmp(name, "vkDestroyFence")) {
-        return (void*)entry_vkDestroyFence;
-    }
-    if (!strcmp(name, "vkResetFences")) {
-        return (void*)entry_vkResetFences;
-    }
-    if (!strcmp(name, "vkGetFenceStatus")) {
-        return (void*)entry_vkGetFenceStatus;
-    }
-    if (!strcmp(name, "vkWaitForFences")) {
-        return (void*)entry_vkWaitForFences;
-    }
-    if (!strcmp(name, "vkCreateSemaphore")) {
-        return (void*)entry_vkCreateSemaphore;
-    }
-    if (!strcmp(name, "vkDestroySemaphore")) {
-        return (void*)entry_vkDestroySemaphore;
-    }
-    if (!strcmp(name, "vkCreateEvent")) {
-        return (void*)entry_vkCreateEvent;
-    }
-    if (!strcmp(name, "vkDestroyEvent")) {
-        return (void*)entry_vkDestroyEvent;
-    }
-    if (!strcmp(name, "vkGetEventStatus")) {
-        return (void*)entry_vkGetEventStatus;
-    }
-    if (!strcmp(name, "vkSetEvent")) {
-        return (void*)entry_vkSetEvent;
-    }
-    if (!strcmp(name, "vkResetEvent")) {
-        return (void*)entry_vkResetEvent;
-    }
-    if (!strcmp(name, "vkCreateQueryPool")) {
-        return (void*)entry_vkCreateQueryPool;
-    }
-    if (!strcmp(name, "vkDestroyQueryPool")) {
-        return (void*)entry_vkDestroyQueryPool;
-    }
-    if (!strcmp(name, "vkGetQueryPoolResults")) {
-        return (void*)entry_vkGetQueryPoolResults;
-    }
-    if (!strcmp(name, "vkCreateBuffer")) {
-        return (void*)entry_vkCreateBuffer;
-    }
-    if (!strcmp(name, "vkDestroyBuffer")) {
-        return (void*)entry_vkDestroyBuffer;
-    }
-    if (!strcmp(name, "vkCreateBufferView")) {
-        return (void*)entry_vkCreateBufferView;
-    }
-    if (!strcmp(name, "vkDestroyBufferView")) {
-        return (void*)entry_vkDestroyBufferView;
-    }
-    if (!strcmp(name, "vkCreateImage")) {
-        return (void*)entry_vkCreateImage;
-    }
-    if (!strcmp(name, "vkDestroyImage")) {
-        return (void*)entry_vkDestroyImage;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout")) {
-        return (void*)entry_vkGetImageSubresourceLayout;
-    }
-    if (!strcmp(name, "vkCreateImageView")) {
-        return (void*)entry_vkCreateImageView;
-    }
-    if (!strcmp(name, "vkDestroyImageView")) {
-        return (void*)entry_vkDestroyImageView;
-    }
-    if (!strcmp(name, "vkCreateShaderModule")) {
-        return (void*)entry_vkCreateShaderModule;
-    }
-    if (!strcmp(name, "vkDestroyShaderModule")) {
-        return (void*)entry_vkDestroyShaderModule;
-    }
-    if (!strcmp(name, "vkCreatePipelineCache")) {
-        return (void*)entry_vkCreatePipelineCache;
-    }
-    if (!strcmp(name, "vkDestroyPipelineCache")) {
-        return (void*)entry_vkDestroyPipelineCache;
-    }
-    if (!strcmp(name, "vkGetPipelineCacheData")) {
-        return (void*)entry_vkGetPipelineCacheData;
-    }
-    if (!strcmp(name, "vkMergePipelineCaches")) {
-        return (void*)entry_vkMergePipelineCaches;
-    }
-    if (!strcmp(name, "vkCreateGraphicsPipelines")) {
-        return (void*)entry_vkCreateGraphicsPipelines;
-    }
-    if (!strcmp(name, "vkCreateComputePipelines")) {
-        return (void*)entry_vkCreateComputePipelines;
-    }
-    if (!strcmp(name, "vkDestroyPipeline")) {
-        return (void*)entry_vkDestroyPipeline;
-    }
-    if (!strcmp(name, "vkCreatePipelineLayout")) {
-        return (void*)entry_vkCreatePipelineLayout;
-    }
-    if (!strcmp(name, "vkDestroyPipelineLayout")) {
-        return (void*)entry_vkDestroyPipelineLayout;
-    }
-    if (!strcmp(name, "vkCreateSampler")) {
-        return (void*)entry_vkCreateSampler;
-    }
-    if (!strcmp(name, "vkDestroySampler")) {
-        return (void*)entry_vkDestroySampler;
-    }
-    if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
-        return (void*)entry_vkCreateDescriptorSetLayout;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
-        return (void*)entry_vkDestroyDescriptorSetLayout;
-    }
-    if (!strcmp(name, "vkCreateDescriptorPool")) {
-        return (void*)entry_vkCreateDescriptorPool;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorPool")) {
-        return (void*)entry_vkDestroyDescriptorPool;
-    }
-    if (!strcmp(name, "vkResetDescriptorPool")) {
-        return (void*)entry_vkResetDescriptorPool;
-    }
-    if (!strcmp(name, "vkAllocateDescriptorSets")) {
-        return (void*)entry_vkAllocateDescriptorSets;
-    }
-    if (!strcmp(name, "vkFreeDescriptorSets")) {
-        return (void*)entry_vkFreeDescriptorSets;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSets")) {
-        return (void*)entry_vkUpdateDescriptorSets;
-    }
-    if (!strcmp(name, "vkCreateFramebuffer")) {
-        return (void*)entry_vkCreateFramebuffer;
-    }
-    if (!strcmp(name, "vkDestroyFramebuffer")) {
-        return (void*)entry_vkDestroyFramebuffer;
-    }
-    if (!strcmp(name, "vkCreateRenderPass")) {
-        return (void*)entry_vkCreateRenderPass;
-    }
-    if (!strcmp(name, "vkDestroyRenderPass")) {
-        return (void*)entry_vkDestroyRenderPass;
-    }
-    if (!strcmp(name, "vkGetRenderAreaGranularity")) {
-        return (void*)entry_vkGetRenderAreaGranularity;
-    }
-    if (!strcmp(name, "vkCreateCommandPool")) {
-        return (void*)entry_vkCreateCommandPool;
-    }
-    if (!strcmp(name, "vkDestroyCommandPool")) {
-        return (void*)entry_vkDestroyCommandPool;
-    }
-    if (!strcmp(name, "vkResetCommandPool")) {
-        return (void*)entry_vkResetCommandPool;
-    }
-    if (!strcmp(name, "vkAllocateCommandBuffers")) {
-        return (void*)entry_vkAllocateCommandBuffers;
-    }
-    if (!strcmp(name, "vkFreeCommandBuffers")) {
-        return (void*)entry_vkFreeCommandBuffers;
-    }
-    if (!strcmp(name, "vkBeginCommandBuffer")) {
-        return (void*)entry_vkBeginCommandBuffer;
-    }
-    if (!strcmp(name, "vkEndCommandBuffer")) {
-        return (void*)entry_vkEndCommandBuffer;
-    }
-    if (!strcmp(name, "vkResetCommandBuffer")) {
-        return (void*)entry_vkResetCommandBuffer;
-    }
-    if (!strcmp(name, "vkCmdBindPipeline")) {
-        return (void*)entry_vkCmdBindPipeline;
-    }
-    if (!strcmp(name, "vkCmdSetViewport")) {
-        return (void*)entry_vkCmdSetViewport;
-    }
-    if (!strcmp(name, "vkCmdSetScissor")) {
-        return (void*)entry_vkCmdSetScissor;
-    }
-    if (!strcmp(name, "vkCmdSetLineWidth")) {
-        return (void*)entry_vkCmdSetLineWidth;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBias")) {
-        return (void*)entry_vkCmdSetDepthBias;
-    }
-    if (!strcmp(name, "vkCmdSetBlendConstants")) {
-        return (void*)entry_vkCmdSetBlendConstants;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBounds")) {
-        return (void*)entry_vkCmdSetDepthBounds;
-    }
-    if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
-        return (void*)entry_vkCmdSetStencilCompareMask;
-    }
-    if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
-        return (void*)entry_vkCmdSetStencilWriteMask;
-    }
-    if (!strcmp(name, "vkCmdSetStencilReference")) {
-        return (void*)entry_vkCmdSetStencilReference;
-    }
-    if (!strcmp(name, "vkCmdBindDescriptorSets")) {
-        return (void*)entry_vkCmdBindDescriptorSets;
-    }
-    if (!strcmp(name, "vkCmdBindIndexBuffer")) {
-        return (void*)entry_vkCmdBindIndexBuffer;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers")) {
-        return (void*)entry_vkCmdBindVertexBuffers;
-    }
-    if (!strcmp(name, "vkCmdDraw")) {
-        return (void*)entry_vkCmdDraw;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexed")) {
-        return (void*)entry_vkCmdDrawIndexed;
-    }
-    if (!strcmp(name, "vkCmdDrawIndirect")) {
-        return (void*)entry_vkCmdDrawIndirect;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
-        return (void*)entry_vkCmdDrawIndexedIndirect;
-    }
-    if (!strcmp(name, "vkCmdDispatch")) {
-        return (void*)entry_vkCmdDispatch;
-    }
-    if (!strcmp(name, "vkCmdDispatchIndirect")) {
-        return (void*)entry_vkCmdDispatchIndirect;
-    }
-    if (!strcmp(name, "vkCmdCopyBuffer")) {
-        return (void*)entry_vkCmdCopyBuffer;
-    }
-    if (!strcmp(name, "vkCmdCopyImage")) {
-        return (void*)entry_vkCmdCopyImage;
-    }
-    if (!strcmp(name, "vkCmdBlitImage")) {
-        return (void*)entry_vkCmdBlitImage;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage")) {
-        return (void*)entry_vkCmdCopyBufferToImage;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
-        return (void*)entry_vkCmdCopyImageToBuffer;
-    }
-    if (!strcmp(name, "vkCmdUpdateBuffer")) {
-        return (void*)entry_vkCmdUpdateBuffer;
-    }
-    if (!strcmp(name, "vkCmdFillBuffer")) {
-        return (void*)entry_vkCmdFillBuffer;
-    }
-    if (!strcmp(name, "vkCmdClearColorImage")) {
-        return (void*)entry_vkCmdClearColorImage;
-    }
-    if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
-        return (void*)entry_vkCmdClearDepthStencilImage;
-    }
-    if (!strcmp(name, "vkCmdClearAttachments")) {
-        return (void*)entry_vkCmdClearAttachments;
-    }
-    if (!strcmp(name, "vkCmdResolveImage")) {
-        return (void*)entry_vkCmdResolveImage;
-    }
-    if (!strcmp(name, "vkCmdSetEvent")) {
-        return (void*)entry_vkCmdSetEvent;
-    }
-    if (!strcmp(name, "vkCmdResetEvent")) {
-        return (void*)entry_vkCmdResetEvent;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents")) {
-        return (void*)entry_vkCmdWaitEvents;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier")) {
-        return (void*)entry_vkCmdPipelineBarrier;
-    }
-    if (!strcmp(name, "vkCmdBeginQuery")) {
-        return (void*)entry_vkCmdBeginQuery;
-    }
-    if (!strcmp(name, "vkCmdEndQuery")) {
-        return (void*)entry_vkCmdEndQuery;
-    }
-    if (!strcmp(name, "vkCmdResetQueryPool")) {
-        return (void*)entry_vkCmdResetQueryPool;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp")) {
-        return (void*)entry_vkCmdWriteTimestamp;
-    }
-    if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
-        return (void*)entry_vkCmdCopyQueryPoolResults;
-    }
-    if (!strcmp(name, "vkCmdPushConstants")) {
-        return (void*)entry_vkCmdPushConstants;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass")) {
-        return (void*)entry_vkCmdBeginRenderPass;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass")) {
-        return (void*)entry_vkCmdNextSubpass;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass")) {
-        return (void*)entry_vkCmdEndRenderPass;
-    }
-    if (!strcmp(name, "vkCmdExecuteCommands")) {
-        return (void*)entry_vkCmdExecuteCommands;
-    }
-#endif
-#ifdef VK_VERSION_1_1
-    if (!strcmp(name, "vkEnumerateInstanceVersion")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkBindBufferMemory2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkBindImageMemory2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDeviceMask")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdDispatchBase")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkTrimCommandPool")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceQueue2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_VERSION_1_2
-    if (!strcmp(name, "vkCmdDrawIndirectCount")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCreateRenderPass2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkResetQueryPool")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkWaitSemaphores")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkSignalSemaphore")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferDeviceAddress")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_VERSION_1_3
-    if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCreatePrivateDataSlot")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkSetPrivateData")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPrivateData")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetEvent2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdResetEvent2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmit2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBuffer2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImage2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBlitImage2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdResolveImage2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRendering")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRendering")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetCullMode")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetFrontFace")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetViewportWithCount")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetScissorWithCount")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilOp")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_android_surface
-    if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_dynamic_rendering
-    if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderingKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance1
-    if (!strcmp(name, "vkTrimCommandPoolKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
-    if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_descriptor_update_template
-    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_create_renderpass2
-    if (!strcmp(name, "vkCreateRenderPass2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_fence_fd
-    if (!strcmp(name, "vkImportFenceFdKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetFenceFdKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
-    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
-    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_bind_memory2
-    if (!strcmp(name, "vkBindBufferMemory2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkBindImageMemory2KHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance3
-    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_buffer_device_address
-    if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
-    if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_synchronization2
-    if (!strcmp(name, "vkCmdSetEvent2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdResetEvent2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmit2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_copy_commands2
-    if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImage2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBlitImage2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdResolveImage2KHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance4
-    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance5
-    if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_ANDROID_native_buffer
-    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkAcquireImageANDROID")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_transform_feedback
-    if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_tooling_info
-    if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_line_rasterization
-    if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
-    if (!strcmp(name, "vkCmdSetCullModeEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_host_image_copy
-    if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCopyImageToImageEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_private_data
-    if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkSetPrivateDataEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetPrivateDataEXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
-    if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
-        return nullptr;
-    }
-#endif
-#ifdef VK_GOOGLE_gfxstream
-    if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetBlobGOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
-        return nullptr;
-    }
-#endif
-    return nullptr;
-}
-void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name) {
-    auto resources = ResourceTracker::get();
-    bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1;
-    bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2;
-    bool has1_3OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_3;
-#ifdef VK_VERSION_1_0
-    if (!strcmp(name, "vkCreateInstance")) {
-        return (void*)entry_vkCreateInstance;
-    }
-    if (!strcmp(name, "vkDestroyInstance")) {
-        return (void*)entry_vkDestroyInstance;
-    }
-    if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
-        return (void*)entry_vkEnumeratePhysicalDevices;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
-        return (void*)entry_vkGetPhysicalDeviceFeatures;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
-    }
-    if (!strcmp(name, "vkGetInstanceProcAddr")) {
-        return (void*)entry_vkGetInstanceProcAddr;
-    }
-    if (!strcmp(name, "vkGetDeviceProcAddr")) {
-        return (void*)entry_vkGetDeviceProcAddr;
-    }
-    if (!strcmp(name, "vkCreateDevice")) {
-        return (void*)entry_vkCreateDevice;
-    }
-    if (!strcmp(name, "vkDestroyDevice")) {
-        return (void*)entry_vkDestroyDevice;
-    }
-    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
-        return (void*)entry_vkEnumerateInstanceExtensionProperties;
-    }
-    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
-        return (void*)entry_vkEnumerateDeviceExtensionProperties;
-    }
-    if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
-        return (void*)entry_vkEnumerateInstanceLayerProperties;
-    }
-    if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
-        return (void*)entry_vkEnumerateDeviceLayerProperties;
-    }
-    if (!strcmp(name, "vkGetDeviceQueue")) {
-        return (void*)entry_vkGetDeviceQueue;
-    }
-    if (!strcmp(name, "vkQueueSubmit")) {
-        return (void*)entry_vkQueueSubmit;
-    }
-    if (!strcmp(name, "vkQueueWaitIdle")) {
-        return (void*)entry_vkQueueWaitIdle;
-    }
-    if (!strcmp(name, "vkDeviceWaitIdle")) {
-        return (void*)entry_vkDeviceWaitIdle;
-    }
-    if (!strcmp(name, "vkAllocateMemory")) {
-        return (void*)entry_vkAllocateMemory;
-    }
-    if (!strcmp(name, "vkFreeMemory")) {
-        return (void*)entry_vkFreeMemory;
-    }
-    if (!strcmp(name, "vkMapMemory")) {
-        return (void*)entry_vkMapMemory;
-    }
-    if (!strcmp(name, "vkUnmapMemory")) {
-        return (void*)entry_vkUnmapMemory;
-    }
-    if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
-        return (void*)entry_vkFlushMappedMemoryRanges;
-    }
-    if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
-        return (void*)entry_vkInvalidateMappedMemoryRanges;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
-        return (void*)entry_vkGetDeviceMemoryCommitment;
-    }
-    if (!strcmp(name, "vkBindBufferMemory")) {
-        return (void*)entry_vkBindBufferMemory;
-    }
-    if (!strcmp(name, "vkBindImageMemory")) {
-        return (void*)entry_vkBindImageMemory;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
-        return (void*)entry_vkGetBufferMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetImageMemoryRequirements")) {
-        return (void*)entry_vkGetImageMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
-        return (void*)entry_vkGetImageSparseMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
-    }
-    if (!strcmp(name, "vkQueueBindSparse")) {
-        return (void*)entry_vkQueueBindSparse;
-    }
-    if (!strcmp(name, "vkCreateFence")) {
-        return (void*)entry_vkCreateFence;
-    }
-    if (!strcmp(name, "vkDestroyFence")) {
-        return (void*)entry_vkDestroyFence;
-    }
-    if (!strcmp(name, "vkResetFences")) {
-        return (void*)entry_vkResetFences;
-    }
-    if (!strcmp(name, "vkGetFenceStatus")) {
-        return (void*)entry_vkGetFenceStatus;
-    }
-    if (!strcmp(name, "vkWaitForFences")) {
-        return (void*)entry_vkWaitForFences;
-    }
-    if (!strcmp(name, "vkCreateSemaphore")) {
-        return (void*)entry_vkCreateSemaphore;
-    }
-    if (!strcmp(name, "vkDestroySemaphore")) {
-        return (void*)entry_vkDestroySemaphore;
-    }
-    if (!strcmp(name, "vkCreateEvent")) {
-        return (void*)entry_vkCreateEvent;
-    }
-    if (!strcmp(name, "vkDestroyEvent")) {
-        return (void*)entry_vkDestroyEvent;
-    }
-    if (!strcmp(name, "vkGetEventStatus")) {
-        return (void*)entry_vkGetEventStatus;
-    }
-    if (!strcmp(name, "vkSetEvent")) {
-        return (void*)entry_vkSetEvent;
-    }
-    if (!strcmp(name, "vkResetEvent")) {
-        return (void*)entry_vkResetEvent;
-    }
-    if (!strcmp(name, "vkCreateQueryPool")) {
-        return (void*)entry_vkCreateQueryPool;
-    }
-    if (!strcmp(name, "vkDestroyQueryPool")) {
-        return (void*)entry_vkDestroyQueryPool;
-    }
-    if (!strcmp(name, "vkGetQueryPoolResults")) {
-        return (void*)entry_vkGetQueryPoolResults;
-    }
-    if (!strcmp(name, "vkCreateBuffer")) {
-        return (void*)entry_vkCreateBuffer;
-    }
-    if (!strcmp(name, "vkDestroyBuffer")) {
-        return (void*)entry_vkDestroyBuffer;
-    }
-    if (!strcmp(name, "vkCreateBufferView")) {
-        return (void*)entry_vkCreateBufferView;
-    }
-    if (!strcmp(name, "vkDestroyBufferView")) {
-        return (void*)entry_vkDestroyBufferView;
-    }
-    if (!strcmp(name, "vkCreateImage")) {
-        return (void*)entry_vkCreateImage;
-    }
-    if (!strcmp(name, "vkDestroyImage")) {
-        return (void*)entry_vkDestroyImage;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout")) {
-        return (void*)entry_vkGetImageSubresourceLayout;
-    }
-    if (!strcmp(name, "vkCreateImageView")) {
-        return (void*)entry_vkCreateImageView;
-    }
-    if (!strcmp(name, "vkDestroyImageView")) {
-        return (void*)entry_vkDestroyImageView;
-    }
-    if (!strcmp(name, "vkCreateShaderModule")) {
-        return (void*)entry_vkCreateShaderModule;
-    }
-    if (!strcmp(name, "vkDestroyShaderModule")) {
-        return (void*)entry_vkDestroyShaderModule;
-    }
-    if (!strcmp(name, "vkCreatePipelineCache")) {
-        return (void*)entry_vkCreatePipelineCache;
-    }
-    if (!strcmp(name, "vkDestroyPipelineCache")) {
-        return (void*)entry_vkDestroyPipelineCache;
-    }
-    if (!strcmp(name, "vkGetPipelineCacheData")) {
-        return (void*)entry_vkGetPipelineCacheData;
-    }
-    if (!strcmp(name, "vkMergePipelineCaches")) {
-        return (void*)entry_vkMergePipelineCaches;
-    }
-    if (!strcmp(name, "vkCreateGraphicsPipelines")) {
-        return (void*)entry_vkCreateGraphicsPipelines;
-    }
-    if (!strcmp(name, "vkCreateComputePipelines")) {
-        return (void*)entry_vkCreateComputePipelines;
-    }
-    if (!strcmp(name, "vkDestroyPipeline")) {
-        return (void*)entry_vkDestroyPipeline;
-    }
-    if (!strcmp(name, "vkCreatePipelineLayout")) {
-        return (void*)entry_vkCreatePipelineLayout;
-    }
-    if (!strcmp(name, "vkDestroyPipelineLayout")) {
-        return (void*)entry_vkDestroyPipelineLayout;
-    }
-    if (!strcmp(name, "vkCreateSampler")) {
-        return (void*)entry_vkCreateSampler;
-    }
-    if (!strcmp(name, "vkDestroySampler")) {
-        return (void*)entry_vkDestroySampler;
-    }
-    if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
-        return (void*)entry_vkCreateDescriptorSetLayout;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
-        return (void*)entry_vkDestroyDescriptorSetLayout;
-    }
-    if (!strcmp(name, "vkCreateDescriptorPool")) {
-        return (void*)entry_vkCreateDescriptorPool;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorPool")) {
-        return (void*)entry_vkDestroyDescriptorPool;
-    }
-    if (!strcmp(name, "vkResetDescriptorPool")) {
-        return (void*)entry_vkResetDescriptorPool;
-    }
-    if (!strcmp(name, "vkAllocateDescriptorSets")) {
-        return (void*)entry_vkAllocateDescriptorSets;
-    }
-    if (!strcmp(name, "vkFreeDescriptorSets")) {
-        return (void*)entry_vkFreeDescriptorSets;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSets")) {
-        return (void*)entry_vkUpdateDescriptorSets;
-    }
-    if (!strcmp(name, "vkCreateFramebuffer")) {
-        return (void*)entry_vkCreateFramebuffer;
-    }
-    if (!strcmp(name, "vkDestroyFramebuffer")) {
-        return (void*)entry_vkDestroyFramebuffer;
-    }
-    if (!strcmp(name, "vkCreateRenderPass")) {
-        return (void*)entry_vkCreateRenderPass;
-    }
-    if (!strcmp(name, "vkDestroyRenderPass")) {
-        return (void*)entry_vkDestroyRenderPass;
-    }
-    if (!strcmp(name, "vkGetRenderAreaGranularity")) {
-        return (void*)entry_vkGetRenderAreaGranularity;
-    }
-    if (!strcmp(name, "vkCreateCommandPool")) {
-        return (void*)entry_vkCreateCommandPool;
-    }
-    if (!strcmp(name, "vkDestroyCommandPool")) {
-        return (void*)entry_vkDestroyCommandPool;
-    }
-    if (!strcmp(name, "vkResetCommandPool")) {
-        return (void*)entry_vkResetCommandPool;
-    }
-    if (!strcmp(name, "vkAllocateCommandBuffers")) {
-        return (void*)entry_vkAllocateCommandBuffers;
-    }
-    if (!strcmp(name, "vkFreeCommandBuffers")) {
-        return (void*)entry_vkFreeCommandBuffers;
-    }
-    if (!strcmp(name, "vkBeginCommandBuffer")) {
-        return (void*)entry_vkBeginCommandBuffer;
-    }
-    if (!strcmp(name, "vkEndCommandBuffer")) {
-        return (void*)entry_vkEndCommandBuffer;
-    }
-    if (!strcmp(name, "vkResetCommandBuffer")) {
-        return (void*)entry_vkResetCommandBuffer;
-    }
-    if (!strcmp(name, "vkCmdBindPipeline")) {
-        return (void*)entry_vkCmdBindPipeline;
-    }
-    if (!strcmp(name, "vkCmdSetViewport")) {
-        return (void*)entry_vkCmdSetViewport;
-    }
-    if (!strcmp(name, "vkCmdSetScissor")) {
-        return (void*)entry_vkCmdSetScissor;
-    }
-    if (!strcmp(name, "vkCmdSetLineWidth")) {
-        return (void*)entry_vkCmdSetLineWidth;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBias")) {
-        return (void*)entry_vkCmdSetDepthBias;
-    }
-    if (!strcmp(name, "vkCmdSetBlendConstants")) {
-        return (void*)entry_vkCmdSetBlendConstants;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBounds")) {
-        return (void*)entry_vkCmdSetDepthBounds;
-    }
-    if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
-        return (void*)entry_vkCmdSetStencilCompareMask;
-    }
-    if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
-        return (void*)entry_vkCmdSetStencilWriteMask;
-    }
-    if (!strcmp(name, "vkCmdSetStencilReference")) {
-        return (void*)entry_vkCmdSetStencilReference;
-    }
-    if (!strcmp(name, "vkCmdBindDescriptorSets")) {
-        return (void*)entry_vkCmdBindDescriptorSets;
-    }
-    if (!strcmp(name, "vkCmdBindIndexBuffer")) {
-        return (void*)entry_vkCmdBindIndexBuffer;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers")) {
-        return (void*)entry_vkCmdBindVertexBuffers;
-    }
-    if (!strcmp(name, "vkCmdDraw")) {
-        return (void*)entry_vkCmdDraw;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexed")) {
-        return (void*)entry_vkCmdDrawIndexed;
-    }
-    if (!strcmp(name, "vkCmdDrawIndirect")) {
-        return (void*)entry_vkCmdDrawIndirect;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
-        return (void*)entry_vkCmdDrawIndexedIndirect;
-    }
-    if (!strcmp(name, "vkCmdDispatch")) {
-        return (void*)entry_vkCmdDispatch;
-    }
-    if (!strcmp(name, "vkCmdDispatchIndirect")) {
-        return (void*)entry_vkCmdDispatchIndirect;
-    }
-    if (!strcmp(name, "vkCmdCopyBuffer")) {
-        return (void*)entry_vkCmdCopyBuffer;
-    }
-    if (!strcmp(name, "vkCmdCopyImage")) {
-        return (void*)entry_vkCmdCopyImage;
-    }
-    if (!strcmp(name, "vkCmdBlitImage")) {
-        return (void*)entry_vkCmdBlitImage;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage")) {
-        return (void*)entry_vkCmdCopyBufferToImage;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
-        return (void*)entry_vkCmdCopyImageToBuffer;
-    }
-    if (!strcmp(name, "vkCmdUpdateBuffer")) {
-        return (void*)entry_vkCmdUpdateBuffer;
-    }
-    if (!strcmp(name, "vkCmdFillBuffer")) {
-        return (void*)entry_vkCmdFillBuffer;
-    }
-    if (!strcmp(name, "vkCmdClearColorImage")) {
-        return (void*)entry_vkCmdClearColorImage;
-    }
-    if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
-        return (void*)entry_vkCmdClearDepthStencilImage;
-    }
-    if (!strcmp(name, "vkCmdClearAttachments")) {
-        return (void*)entry_vkCmdClearAttachments;
-    }
-    if (!strcmp(name, "vkCmdResolveImage")) {
-        return (void*)entry_vkCmdResolveImage;
-    }
-    if (!strcmp(name, "vkCmdSetEvent")) {
-        return (void*)entry_vkCmdSetEvent;
-    }
-    if (!strcmp(name, "vkCmdResetEvent")) {
-        return (void*)entry_vkCmdResetEvent;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents")) {
-        return (void*)entry_vkCmdWaitEvents;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier")) {
-        return (void*)entry_vkCmdPipelineBarrier;
-    }
-    if (!strcmp(name, "vkCmdBeginQuery")) {
-        return (void*)entry_vkCmdBeginQuery;
-    }
-    if (!strcmp(name, "vkCmdEndQuery")) {
-        return (void*)entry_vkCmdEndQuery;
-    }
-    if (!strcmp(name, "vkCmdResetQueryPool")) {
-        return (void*)entry_vkCmdResetQueryPool;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp")) {
-        return (void*)entry_vkCmdWriteTimestamp;
-    }
-    if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
-        return (void*)entry_vkCmdCopyQueryPoolResults;
-    }
-    if (!strcmp(name, "vkCmdPushConstants")) {
-        return (void*)entry_vkCmdPushConstants;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass")) {
-        return (void*)entry_vkCmdBeginRenderPass;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass")) {
-        return (void*)entry_vkCmdNextSubpass;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass")) {
-        return (void*)entry_vkCmdEndRenderPass;
-    }
-    if (!strcmp(name, "vkCmdExecuteCommands")) {
-        return (void*)entry_vkCmdExecuteCommands;
-    }
-#endif
-#ifdef VK_VERSION_1_1
-    if (!strcmp(name, "vkEnumerateInstanceVersion")) {
-        return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
-    }
-    if (!strcmp(name, "vkBindBufferMemory2")) {
-        return (void*)dynCheck_entry_vkBindBufferMemory2;
-    }
-    if (!strcmp(name, "vkBindImageMemory2")) {
-        return (void*)dynCheck_entry_vkBindImageMemory2;
-    }
-    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
-        return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures;
-    }
-    if (!strcmp(name, "vkCmdSetDeviceMask")) {
-        return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
-    }
-    if (!strcmp(name, "vkCmdDispatchBase")) {
-        return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
-    }
-    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
-        return (void*)dynCheck_entry_vkGetImageMemoryRequirements2;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
-        return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
-        return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
-                              : nullptr;
-    }
-    if (!strcmp(name, "vkTrimCommandPool")) {
-        return (void*)dynCheck_entry_vkTrimCommandPool;
-    }
-    if (!strcmp(name, "vkGetDeviceQueue2")) {
-        return (void*)dynCheck_entry_vkGetDeviceQueue2;
-    }
-    if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
-        return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversion;
-    }
-    if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
-        return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversion;
-    }
-    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
-        return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplate;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
-        return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplate;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
-        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplate;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
-                              : nullptr;
-    }
-    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
-        return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupport;
-    }
-#endif
-#ifdef VK_VERSION_1_2
-    if (!strcmp(name, "vkCmdDrawIndirectCount")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
-    }
-    if (!strcmp(name, "vkCreateRenderPass2")) {
-        return (void*)dynCheck_entry_vkCreateRenderPass2;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
-    }
-    if (!strcmp(name, "vkResetQueryPool")) {
-        return (void*)dynCheck_entry_vkResetQueryPool;
-    }
-    if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
-        return (void*)dynCheck_entry_vkGetSemaphoreCounterValue;
-    }
-    if (!strcmp(name, "vkWaitSemaphores")) {
-        return (void*)dynCheck_entry_vkWaitSemaphores;
-    }
-    if (!strcmp(name, "vkSignalSemaphore")) {
-        return (void*)dynCheck_entry_vkSignalSemaphore;
-    }
-    if (!strcmp(name, "vkGetBufferDeviceAddress")) {
-        return (void*)dynCheck_entry_vkGetBufferDeviceAddress;
-    }
-    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
-        return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddress;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
-        return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress;
-    }
-#endif
-#ifdef VK_VERSION_1_3
-    if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
-        return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
-    }
-    if (!strcmp(name, "vkCreatePrivateDataSlot")) {
-        return (void*)dynCheck_entry_vkCreatePrivateDataSlot;
-    }
-    if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
-        return (void*)dynCheck_entry_vkDestroyPrivateDataSlot;
-    }
-    if (!strcmp(name, "vkSetPrivateData")) {
-        return (void*)dynCheck_entry_vkSetPrivateData;
-    }
-    if (!strcmp(name, "vkGetPrivateData")) {
-        return (void*)dynCheck_entry_vkGetPrivateData;
-    }
-    if (!strcmp(name, "vkCmdSetEvent2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdResetEvent2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmit2")) {
-        return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBuffer2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBlitImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdResolveImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRendering")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRendering")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetCullMode")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetFrontFace")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetViewportWithCount")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetScissorWithCount")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilOp")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
-        return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
-        return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
-        return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements;
-    }
-#endif
-#ifdef VK_KHR_android_surface
-    if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_android_surface");
-        return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_dynamic_rendering
-    if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBeginRenderingKHR;
-    }
-    if (!strcmp(name, "vkCmdEndRenderingKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdEndRenderingKHR;
-    }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance1
-    if (!strcmp(name, "vkTrimCommandPoolKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkTrimCommandPoolKHR;
-    }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
-    if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkImportSemaphoreFdKHR;
-    }
-    if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetSemaphoreFdKHR;
-    }
-#endif
-#ifdef VK_KHR_descriptor_update_template
-    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR;
-    }
-#endif
-#ifdef VK_KHR_create_renderpass2
-    if (!strcmp(name, "vkCreateRenderPass2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCreateRenderPass2KHR;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBeginRenderPass2KHR;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdNextSubpass2KHR;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdEndRenderPass2KHR;
-    }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
-        bool hasExt =
-            resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_fence_fd
-    if (!strcmp(name, "vkImportFenceFdKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkImportFenceFdKHR;
-    }
-    if (!strcmp(name, "vkGetFenceFdKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetFenceFdKHR;
-    }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
-    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetImageMemoryRequirements2KHR;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2KHR;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR;
-    }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
-    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversionKHR;
-    }
-    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversionKHR;
-    }
-#endif
-#ifdef VK_KHR_bind_memory2
-    if (!strcmp(name, "vkBindBufferMemory2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkBindBufferMemory2KHR;
-    }
-    if (!strcmp(name, "vkBindImageMemory2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkBindImageMemory2KHR;
-    }
-#endif
-#ifdef VK_KHR_maintenance3
-    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR;
-    }
-#endif
-#ifdef VK_KHR_buffer_device_address
-    if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetBufferDeviceAddressKHR;
-    }
-    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
-    }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
-    if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetPipelineExecutablePropertiesKHR;
-    }
-    if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetPipelineExecutableStatisticsKHR;
-    }
-    if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR;
-    }
-#endif
-#ifdef VK_KHR_synchronization2
-    if (!strcmp(name, "vkCmdSetEvent2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetEvent2KHR;
-    }
-    if (!strcmp(name, "vkCmdResetEvent2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdResetEvent2KHR;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdWaitEvents2KHR;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdPipelineBarrier2KHR;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdWriteTimestamp2KHR;
-    }
-    if (!strcmp(name, "vkQueueSubmit2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)entry_vkQueueSubmit2KHR;
-    }
-    if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdWriteBufferMarker2AMD;
-    }
-    if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)entry_vkGetQueueCheckpointData2NV;
-    }
-#endif
-#ifdef VK_KHR_copy_commands2
-    if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdCopyBuffer2KHR;
-    }
-    if (!strcmp(name, "vkCmdCopyImage2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdCopyImage2KHR;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdCopyBufferToImage2KHR;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdCopyImageToBuffer2KHR;
-    }
-    if (!strcmp(name, "vkCmdBlitImage2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBlitImage2KHR;
-    }
-    if (!strcmp(name, "vkCmdResolveImage2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdResolveImage2KHR;
-    }
-#endif
-#ifdef VK_KHR_maintenance4
-    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR;
-    }
-    if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR;
-    }
-#endif
-#ifdef VK_KHR_maintenance5
-    if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBindIndexBuffer2KHR;
-    }
-    if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetRenderingAreaGranularityKHR;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetImageSubresourceLayout2KHR;
-    }
-#endif
-#ifdef VK_ANDROID_native_buffer
-    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetSwapchainGrallocUsageANDROID;
-    }
-    if (!strcmp(name, "vkAcquireImageANDROID")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkAcquireImageANDROID;
-    }
-    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)entry_vkQueueSignalReleaseImageANDROID;
-    }
-    if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID;
-    }
-#endif
-#ifdef VK_EXT_transform_feedback
-    if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT;
-    }
-    if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBeginTransformFeedbackEXT;
-    }
-    if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdEndTransformFeedbackEXT;
-    }
-    if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBeginQueryIndexedEXT;
-    }
-    if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdEndQueryIndexedEXT;
-    }
-    if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdDrawIndirectByteCountEXT;
-    }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID;
-    }
-    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID;
-    }
-#endif
-#ifdef VK_EXT_tooling_info
-    if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT;
-    }
-#endif
-#ifdef VK_EXT_line_rasterization
-    if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetLineStippleEXT;
-    }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
-    if (!strcmp(name, "vkCmdSetCullModeEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetCullModeEXT;
-    }
-    if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetFrontFaceEXT;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetPrimitiveTopologyEXT;
-    }
-    if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetViewportWithCountEXT;
-    }
-    if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetScissorWithCountEXT;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdBindVertexBuffers2EXT;
-    }
-    if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetDepthTestEnableEXT;
-    }
-    if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetDepthWriteEnableEXT;
-    }
-    if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetDepthCompareOpEXT;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT;
-    }
-    if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetStencilTestEnableEXT;
-    }
-    if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetStencilOpEXT;
-    }
-#endif
-#ifdef VK_EXT_host_image_copy
-    if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCopyMemoryToImageEXT;
-    }
-    if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCopyImageToMemoryEXT;
-    }
-    if (!strcmp(name, "vkCopyImageToImageEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCopyImageToImageEXT;
-    }
-    if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkTransitionImageLayoutEXT;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetImageSubresourceLayout2EXT;
-    }
-#endif
-#ifdef VK_EXT_private_data
-    if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCreatePrivateDataSlotEXT;
-    }
-    if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkDestroyPrivateDataSlotEXT;
-    }
-    if (!strcmp(name, "vkSetPrivateDataEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkSetPrivateDataEXT;
-    }
-    if (!strcmp(name, "vkGetPrivateDataEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkGetPrivateDataEXT;
-    }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
-    if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetPatchControlPointsEXT;
-    }
-    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetDepthBiasEnableEXT;
-    }
-    if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetLogicOpEXT;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
-        // TODO(b/236246382): Check support for device extension;
-        return (void*)dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT;
-    }
-#endif
-#ifdef VK_GOOGLE_gfxstream
-    if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE
-                      : nullptr;
-    }
-    if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayout2GOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetBlobGOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkGetBlobGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE
-                      : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
-    }
-#endif
-    return nullptr;
-}
-void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name) {
-    auto resources = ResourceTracker::get();
-    bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1;
-    bool has1_2OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_2;
-    bool has1_3OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_3;
-#ifdef VK_VERSION_1_0
-    if (!strcmp(name, "vkCreateInstance")) {
-        return (void*)entry_vkCreateInstance;
-    }
-    if (!strcmp(name, "vkDestroyInstance")) {
-        return (void*)entry_vkDestroyInstance;
-    }
-    if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
-        return (void*)entry_vkEnumeratePhysicalDevices;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
-        return (void*)entry_vkGetPhysicalDeviceFeatures;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
-    }
-    if (!strcmp(name, "vkGetInstanceProcAddr")) {
-        return (void*)entry_vkGetInstanceProcAddr;
-    }
-    if (!strcmp(name, "vkGetDeviceProcAddr")) {
-        return (void*)entry_vkGetDeviceProcAddr;
-    }
-    if (!strcmp(name, "vkCreateDevice")) {
-        return (void*)entry_vkCreateDevice;
-    }
-    if (!strcmp(name, "vkDestroyDevice")) {
-        return (void*)entry_vkDestroyDevice;
-    }
-    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
-        return (void*)entry_vkEnumerateInstanceExtensionProperties;
-    }
-    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
-        return (void*)entry_vkEnumerateDeviceExtensionProperties;
-    }
-    if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
-        return (void*)entry_vkEnumerateInstanceLayerProperties;
-    }
-    if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
-        return (void*)entry_vkEnumerateDeviceLayerProperties;
-    }
-    if (!strcmp(name, "vkGetDeviceQueue")) {
-        return (void*)entry_vkGetDeviceQueue;
-    }
-    if (!strcmp(name, "vkQueueSubmit")) {
-        return (void*)entry_vkQueueSubmit;
-    }
-    if (!strcmp(name, "vkQueueWaitIdle")) {
-        return (void*)entry_vkQueueWaitIdle;
-    }
-    if (!strcmp(name, "vkDeviceWaitIdle")) {
-        return (void*)entry_vkDeviceWaitIdle;
-    }
-    if (!strcmp(name, "vkAllocateMemory")) {
-        return (void*)entry_vkAllocateMemory;
-    }
-    if (!strcmp(name, "vkFreeMemory")) {
-        return (void*)entry_vkFreeMemory;
-    }
-    if (!strcmp(name, "vkMapMemory")) {
-        return (void*)entry_vkMapMemory;
-    }
-    if (!strcmp(name, "vkUnmapMemory")) {
-        return (void*)entry_vkUnmapMemory;
-    }
-    if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
-        return (void*)entry_vkFlushMappedMemoryRanges;
-    }
-    if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
-        return (void*)entry_vkInvalidateMappedMemoryRanges;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
-        return (void*)entry_vkGetDeviceMemoryCommitment;
-    }
-    if (!strcmp(name, "vkBindBufferMemory")) {
-        return (void*)entry_vkBindBufferMemory;
-    }
-    if (!strcmp(name, "vkBindImageMemory")) {
-        return (void*)entry_vkBindImageMemory;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
-        return (void*)entry_vkGetBufferMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetImageMemoryRequirements")) {
-        return (void*)entry_vkGetImageMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
-        return (void*)entry_vkGetImageSparseMemoryRequirements;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
-        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
-    }
-    if (!strcmp(name, "vkQueueBindSparse")) {
-        return (void*)entry_vkQueueBindSparse;
-    }
-    if (!strcmp(name, "vkCreateFence")) {
-        return (void*)entry_vkCreateFence;
-    }
-    if (!strcmp(name, "vkDestroyFence")) {
-        return (void*)entry_vkDestroyFence;
-    }
-    if (!strcmp(name, "vkResetFences")) {
-        return (void*)entry_vkResetFences;
-    }
-    if (!strcmp(name, "vkGetFenceStatus")) {
-        return (void*)entry_vkGetFenceStatus;
-    }
-    if (!strcmp(name, "vkWaitForFences")) {
-        return (void*)entry_vkWaitForFences;
-    }
-    if (!strcmp(name, "vkCreateSemaphore")) {
-        return (void*)entry_vkCreateSemaphore;
-    }
-    if (!strcmp(name, "vkDestroySemaphore")) {
-        return (void*)entry_vkDestroySemaphore;
-    }
-    if (!strcmp(name, "vkCreateEvent")) {
-        return (void*)entry_vkCreateEvent;
-    }
-    if (!strcmp(name, "vkDestroyEvent")) {
-        return (void*)entry_vkDestroyEvent;
-    }
-    if (!strcmp(name, "vkGetEventStatus")) {
-        return (void*)entry_vkGetEventStatus;
-    }
-    if (!strcmp(name, "vkSetEvent")) {
-        return (void*)entry_vkSetEvent;
-    }
-    if (!strcmp(name, "vkResetEvent")) {
-        return (void*)entry_vkResetEvent;
-    }
-    if (!strcmp(name, "vkCreateQueryPool")) {
-        return (void*)entry_vkCreateQueryPool;
-    }
-    if (!strcmp(name, "vkDestroyQueryPool")) {
-        return (void*)entry_vkDestroyQueryPool;
-    }
-    if (!strcmp(name, "vkGetQueryPoolResults")) {
-        return (void*)entry_vkGetQueryPoolResults;
-    }
-    if (!strcmp(name, "vkCreateBuffer")) {
-        return (void*)entry_vkCreateBuffer;
-    }
-    if (!strcmp(name, "vkDestroyBuffer")) {
-        return (void*)entry_vkDestroyBuffer;
-    }
-    if (!strcmp(name, "vkCreateBufferView")) {
-        return (void*)entry_vkCreateBufferView;
-    }
-    if (!strcmp(name, "vkDestroyBufferView")) {
-        return (void*)entry_vkDestroyBufferView;
-    }
-    if (!strcmp(name, "vkCreateImage")) {
-        return (void*)entry_vkCreateImage;
-    }
-    if (!strcmp(name, "vkDestroyImage")) {
-        return (void*)entry_vkDestroyImage;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout")) {
-        return (void*)entry_vkGetImageSubresourceLayout;
-    }
-    if (!strcmp(name, "vkCreateImageView")) {
-        return (void*)entry_vkCreateImageView;
-    }
-    if (!strcmp(name, "vkDestroyImageView")) {
-        return (void*)entry_vkDestroyImageView;
-    }
-    if (!strcmp(name, "vkCreateShaderModule")) {
-        return (void*)entry_vkCreateShaderModule;
-    }
-    if (!strcmp(name, "vkDestroyShaderModule")) {
-        return (void*)entry_vkDestroyShaderModule;
-    }
-    if (!strcmp(name, "vkCreatePipelineCache")) {
-        return (void*)entry_vkCreatePipelineCache;
-    }
-    if (!strcmp(name, "vkDestroyPipelineCache")) {
-        return (void*)entry_vkDestroyPipelineCache;
-    }
-    if (!strcmp(name, "vkGetPipelineCacheData")) {
-        return (void*)entry_vkGetPipelineCacheData;
-    }
-    if (!strcmp(name, "vkMergePipelineCaches")) {
-        return (void*)entry_vkMergePipelineCaches;
-    }
-    if (!strcmp(name, "vkCreateGraphicsPipelines")) {
-        return (void*)entry_vkCreateGraphicsPipelines;
-    }
-    if (!strcmp(name, "vkCreateComputePipelines")) {
-        return (void*)entry_vkCreateComputePipelines;
-    }
-    if (!strcmp(name, "vkDestroyPipeline")) {
-        return (void*)entry_vkDestroyPipeline;
-    }
-    if (!strcmp(name, "vkCreatePipelineLayout")) {
-        return (void*)entry_vkCreatePipelineLayout;
-    }
-    if (!strcmp(name, "vkDestroyPipelineLayout")) {
-        return (void*)entry_vkDestroyPipelineLayout;
-    }
-    if (!strcmp(name, "vkCreateSampler")) {
-        return (void*)entry_vkCreateSampler;
-    }
-    if (!strcmp(name, "vkDestroySampler")) {
-        return (void*)entry_vkDestroySampler;
-    }
-    if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
-        return (void*)entry_vkCreateDescriptorSetLayout;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
-        return (void*)entry_vkDestroyDescriptorSetLayout;
-    }
-    if (!strcmp(name, "vkCreateDescriptorPool")) {
-        return (void*)entry_vkCreateDescriptorPool;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorPool")) {
-        return (void*)entry_vkDestroyDescriptorPool;
-    }
-    if (!strcmp(name, "vkResetDescriptorPool")) {
-        return (void*)entry_vkResetDescriptorPool;
-    }
-    if (!strcmp(name, "vkAllocateDescriptorSets")) {
-        return (void*)entry_vkAllocateDescriptorSets;
-    }
-    if (!strcmp(name, "vkFreeDescriptorSets")) {
-        return (void*)entry_vkFreeDescriptorSets;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSets")) {
-        return (void*)entry_vkUpdateDescriptorSets;
-    }
-    if (!strcmp(name, "vkCreateFramebuffer")) {
-        return (void*)entry_vkCreateFramebuffer;
-    }
-    if (!strcmp(name, "vkDestroyFramebuffer")) {
-        return (void*)entry_vkDestroyFramebuffer;
-    }
-    if (!strcmp(name, "vkCreateRenderPass")) {
-        return (void*)entry_vkCreateRenderPass;
-    }
-    if (!strcmp(name, "vkDestroyRenderPass")) {
-        return (void*)entry_vkDestroyRenderPass;
-    }
-    if (!strcmp(name, "vkGetRenderAreaGranularity")) {
-        return (void*)entry_vkGetRenderAreaGranularity;
-    }
-    if (!strcmp(name, "vkCreateCommandPool")) {
-        return (void*)entry_vkCreateCommandPool;
-    }
-    if (!strcmp(name, "vkDestroyCommandPool")) {
-        return (void*)entry_vkDestroyCommandPool;
-    }
-    if (!strcmp(name, "vkResetCommandPool")) {
-        return (void*)entry_vkResetCommandPool;
-    }
-    if (!strcmp(name, "vkAllocateCommandBuffers")) {
-        return (void*)entry_vkAllocateCommandBuffers;
-    }
-    if (!strcmp(name, "vkFreeCommandBuffers")) {
-        return (void*)entry_vkFreeCommandBuffers;
-    }
-    if (!strcmp(name, "vkBeginCommandBuffer")) {
-        return (void*)entry_vkBeginCommandBuffer;
-    }
-    if (!strcmp(name, "vkEndCommandBuffer")) {
-        return (void*)entry_vkEndCommandBuffer;
-    }
-    if (!strcmp(name, "vkResetCommandBuffer")) {
-        return (void*)entry_vkResetCommandBuffer;
-    }
-    if (!strcmp(name, "vkCmdBindPipeline")) {
-        return (void*)entry_vkCmdBindPipeline;
-    }
-    if (!strcmp(name, "vkCmdSetViewport")) {
-        return (void*)entry_vkCmdSetViewport;
-    }
-    if (!strcmp(name, "vkCmdSetScissor")) {
-        return (void*)entry_vkCmdSetScissor;
-    }
-    if (!strcmp(name, "vkCmdSetLineWidth")) {
-        return (void*)entry_vkCmdSetLineWidth;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBias")) {
-        return (void*)entry_vkCmdSetDepthBias;
-    }
-    if (!strcmp(name, "vkCmdSetBlendConstants")) {
-        return (void*)entry_vkCmdSetBlendConstants;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBounds")) {
-        return (void*)entry_vkCmdSetDepthBounds;
-    }
-    if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
-        return (void*)entry_vkCmdSetStencilCompareMask;
-    }
-    if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
-        return (void*)entry_vkCmdSetStencilWriteMask;
-    }
-    if (!strcmp(name, "vkCmdSetStencilReference")) {
-        return (void*)entry_vkCmdSetStencilReference;
-    }
-    if (!strcmp(name, "vkCmdBindDescriptorSets")) {
-        return (void*)entry_vkCmdBindDescriptorSets;
-    }
-    if (!strcmp(name, "vkCmdBindIndexBuffer")) {
-        return (void*)entry_vkCmdBindIndexBuffer;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers")) {
-        return (void*)entry_vkCmdBindVertexBuffers;
-    }
-    if (!strcmp(name, "vkCmdDraw")) {
-        return (void*)entry_vkCmdDraw;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexed")) {
-        return (void*)entry_vkCmdDrawIndexed;
-    }
-    if (!strcmp(name, "vkCmdDrawIndirect")) {
-        return (void*)entry_vkCmdDrawIndirect;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
-        return (void*)entry_vkCmdDrawIndexedIndirect;
-    }
-    if (!strcmp(name, "vkCmdDispatch")) {
-        return (void*)entry_vkCmdDispatch;
-    }
-    if (!strcmp(name, "vkCmdDispatchIndirect")) {
-        return (void*)entry_vkCmdDispatchIndirect;
-    }
-    if (!strcmp(name, "vkCmdCopyBuffer")) {
-        return (void*)entry_vkCmdCopyBuffer;
-    }
-    if (!strcmp(name, "vkCmdCopyImage")) {
-        return (void*)entry_vkCmdCopyImage;
-    }
-    if (!strcmp(name, "vkCmdBlitImage")) {
-        return (void*)entry_vkCmdBlitImage;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage")) {
-        return (void*)entry_vkCmdCopyBufferToImage;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
-        return (void*)entry_vkCmdCopyImageToBuffer;
-    }
-    if (!strcmp(name, "vkCmdUpdateBuffer")) {
-        return (void*)entry_vkCmdUpdateBuffer;
-    }
-    if (!strcmp(name, "vkCmdFillBuffer")) {
-        return (void*)entry_vkCmdFillBuffer;
-    }
-    if (!strcmp(name, "vkCmdClearColorImage")) {
-        return (void*)entry_vkCmdClearColorImage;
-    }
-    if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
-        return (void*)entry_vkCmdClearDepthStencilImage;
-    }
-    if (!strcmp(name, "vkCmdClearAttachments")) {
-        return (void*)entry_vkCmdClearAttachments;
-    }
-    if (!strcmp(name, "vkCmdResolveImage")) {
-        return (void*)entry_vkCmdResolveImage;
-    }
-    if (!strcmp(name, "vkCmdSetEvent")) {
-        return (void*)entry_vkCmdSetEvent;
-    }
-    if (!strcmp(name, "vkCmdResetEvent")) {
-        return (void*)entry_vkCmdResetEvent;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents")) {
-        return (void*)entry_vkCmdWaitEvents;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier")) {
-        return (void*)entry_vkCmdPipelineBarrier;
-    }
-    if (!strcmp(name, "vkCmdBeginQuery")) {
-        return (void*)entry_vkCmdBeginQuery;
-    }
-    if (!strcmp(name, "vkCmdEndQuery")) {
-        return (void*)entry_vkCmdEndQuery;
-    }
-    if (!strcmp(name, "vkCmdResetQueryPool")) {
-        return (void*)entry_vkCmdResetQueryPool;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp")) {
-        return (void*)entry_vkCmdWriteTimestamp;
-    }
-    if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
-        return (void*)entry_vkCmdCopyQueryPoolResults;
-    }
-    if (!strcmp(name, "vkCmdPushConstants")) {
-        return (void*)entry_vkCmdPushConstants;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass")) {
-        return (void*)entry_vkCmdBeginRenderPass;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass")) {
-        return (void*)entry_vkCmdNextSubpass;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass")) {
-        return (void*)entry_vkCmdEndRenderPass;
-    }
-    if (!strcmp(name, "vkCmdExecuteCommands")) {
-        return (void*)entry_vkCmdExecuteCommands;
-    }
-#endif
-#ifdef VK_VERSION_1_1
-    if (!strcmp(name, "vkEnumerateInstanceVersion")) {
-        return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
-    }
-    if (!strcmp(name, "vkBindBufferMemory2")) {
-        return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr;
-    }
-    if (!strcmp(name, "vkBindImageMemory2")) {
-        return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
-        return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDeviceMask")) {
-        return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
-    }
-    if (!strcmp(name, "vkCmdDispatchBase")) {
-        return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
-    }
-    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
-        return nullptr;
-    }
-    if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
-                              : nullptr;
-    }
-    if (!strcmp(name, "vkTrimCommandPool")) {
-        return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceQueue2")) {
-        return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr;
-    }
-    if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
-        return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr;
-    }
-    if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
-        return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr;
-    }
-    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
-        return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
-        return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
-        return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
-        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
-                              : nullptr;
-    }
-    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
-        return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr;
-    }
-#endif
-#ifdef VK_VERSION_1_2
-    if (!strcmp(name, "vkCmdDrawIndirectCount")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
-    }
-    if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
-    }
-    if (!strcmp(name, "vkCreateRenderPass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCreateRenderPass2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass2")) {
-        return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
-    }
-    if (!strcmp(name, "vkResetQueryPool")) {
-        return has1_2OrHigher ? (void*)entry_vkResetQueryPool : nullptr;
-    }
-    if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
-        return has1_2OrHigher ? (void*)entry_vkGetSemaphoreCounterValue : nullptr;
-    }
-    if (!strcmp(name, "vkWaitSemaphores")) {
-        return has1_2OrHigher ? (void*)entry_vkWaitSemaphores : nullptr;
-    }
-    if (!strcmp(name, "vkSignalSemaphore")) {
-        return has1_2OrHigher ? (void*)entry_vkSignalSemaphore : nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferDeviceAddress")) {
-        return has1_2OrHigher ? (void*)entry_vkGetBufferDeviceAddress : nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
-        return has1_2OrHigher ? (void*)entry_vkGetBufferOpaqueCaptureAddress : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
-        return has1_2OrHigher ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddress : nullptr;
-    }
-#endif
-#ifdef VK_VERSION_1_3
-    if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
-        return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
-    }
-    if (!strcmp(name, "vkCreatePrivateDataSlot")) {
-        return has1_3OrHigher ? (void*)entry_vkCreatePrivateDataSlot : nullptr;
-    }
-    if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
-        return has1_3OrHigher ? (void*)entry_vkDestroyPrivateDataSlot : nullptr;
-    }
-    if (!strcmp(name, "vkSetPrivateData")) {
-        return has1_3OrHigher ? (void*)entry_vkSetPrivateData : nullptr;
-    }
-    if (!strcmp(name, "vkGetPrivateData")) {
-        return has1_3OrHigher ? (void*)entry_vkGetPrivateData : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetEvent2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdResetEvent2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmit2")) {
-        return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBuffer2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBlitImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdResolveImage2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRendering")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRendering")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetCullMode")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetFrontFace")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetViewportWithCount")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetScissorWithCount")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilOp")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
-        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
-        return has1_3OrHigher ? (void*)entry_vkGetDeviceBufferMemoryRequirements : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
-        return has1_3OrHigher ? (void*)entry_vkGetDeviceImageMemoryRequirements : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
-        return has1_3OrHigher ? (void*)entry_vkGetDeviceImageSparseMemoryRequirements : nullptr;
-    }
-#endif
-#ifdef VK_KHR_android_surface
-    if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_android_surface");
-        return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_dynamic_rendering
-    if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
-        return hasExt ? (void*)entry_vkCmdBeginRenderingKHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderingKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
-        return hasExt ? (void*)entry_vkCmdEndRenderingKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_get_physical_device_properties2
-    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance1
-    if (!strcmp(name, "vkTrimCommandPoolKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance1");
-        return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_memory_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_capabilities");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_semaphore_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_semaphore_fd
-    if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
-        return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
-        return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_descriptor_update_template
-    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
-        return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr;
-    }
-    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
-        return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
-        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_create_renderpass2
-    if (!strcmp(name, "vkCreateRenderPass2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
-        return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
-        return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
-        return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
-        return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_fence_capabilities
-    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_capabilities");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_external_fence_fd
-    if (!strcmp(name, "vkImportFenceFdKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
-        return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetFenceFdKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
-        return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_get_memory_requirements2
-    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
-        return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
-        return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
-        return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_sampler_ycbcr_conversion
-    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
-        return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr;
-    }
-    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
-        return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_bind_memory2
-    if (!strcmp(name, "vkBindBufferMemory2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
-        return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkBindImageMemory2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
-        return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance3
-    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance3");
-        return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_buffer_device_address
-    if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
-        return hasExt ? (void*)entry_vkGetBufferDeviceAddressKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
-        return hasExt ? (void*)entry_vkGetBufferOpaqueCaptureAddressKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
-        return hasExt ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
-    if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
-        return hasExt ? (void*)entry_vkGetPipelineExecutablePropertiesKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
-        return hasExt ? (void*)entry_vkGetPipelineExecutableStatisticsKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
-        bool hasExt =
-            resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
-        return hasExt ? (void*)entry_vkGetPipelineExecutableInternalRepresentationsKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_synchronization2
-    if (!strcmp(name, "vkCmdSetEvent2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkCmdSetEvent2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdResetEvent2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkCmdResetEvent2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkCmdWaitEvents2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkCmdPipelineBarrier2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkCmdWriteTimestamp2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmit2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkQueueSubmit2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkCmdWriteBufferMarker2AMD : nullptr;
-    }
-    if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
-        return hasExt ? (void*)entry_vkGetQueueCheckpointData2NV : nullptr;
-    }
-#endif
-#ifdef VK_KHR_copy_commands2
-    if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
-        return hasExt ? (void*)entry_vkCmdCopyBuffer2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImage2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
-        return hasExt ? (void*)entry_vkCmdCopyImage2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
-        return hasExt ? (void*)entry_vkCmdCopyBufferToImage2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
-        return hasExt ? (void*)entry_vkCmdCopyImageToBuffer2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBlitImage2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
-        return hasExt ? (void*)entry_vkCmdBlitImage2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkCmdResolveImage2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
-        return hasExt ? (void*)entry_vkCmdResolveImage2KHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance4
-    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
-        return hasExt ? (void*)entry_vkGetDeviceBufferMemoryRequirementsKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
-        return hasExt ? (void*)entry_vkGetDeviceImageMemoryRequirementsKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
-        return hasExt ? (void*)entry_vkGetDeviceImageSparseMemoryRequirementsKHR : nullptr;
-    }
-#endif
-#ifdef VK_KHR_maintenance5
-    if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
-        return hasExt ? (void*)entry_vkCmdBindIndexBuffer2KHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
-        return hasExt ? (void*)entry_vkGetRenderingAreaGranularityKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
-        return hasExt ? (void*)entry_vkGetDeviceImageSubresourceLayoutKHR : nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
-        return hasExt ? (void*)entry_vkGetImageSubresourceLayout2KHR : nullptr;
-    }
-#endif
-#ifdef VK_ANDROID_native_buffer
-    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
-        return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr;
-    }
-    if (!strcmp(name, "vkAcquireImageANDROID")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
-        return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
-        return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr;
-    }
-    if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
-        return hasExt ? (void*)entry_vkGetSwapchainGrallocUsage2ANDROID : nullptr;
-    }
-#endif
-#ifdef VK_EXT_transform_feedback
-    if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
-        return hasExt ? (void*)entry_vkCmdBindTransformFeedbackBuffersEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
-        return hasExt ? (void*)entry_vkCmdBeginTransformFeedbackEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
-        return hasExt ? (void*)entry_vkCmdEndTransformFeedbackEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
-        return hasExt ? (void*)entry_vkCmdBeginQueryIndexedEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
-        return hasExt ? (void*)entry_vkCmdEndQueryIndexedEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
-        return hasExt ? (void*)entry_vkCmdDrawIndirectByteCountEXT : nullptr;
-    }
-#endif
-#ifdef VK_ANDROID_external_memory_android_hardware_buffer
-    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
-        bool hasExt = resources->hasDeviceExtension(
-            device, "VK_ANDROID_external_memory_android_hardware_buffer");
-        return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr;
-    }
-    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
-        bool hasExt = resources->hasDeviceExtension(
-            device, "VK_ANDROID_external_memory_android_hardware_buffer");
-        return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr;
-    }
-#endif
-#ifdef VK_EXT_tooling_info
-    if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_tooling_info");
-        return hasExt ? (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT : nullptr;
-    }
-#endif
-#ifdef VK_EXT_line_rasterization
-    if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_line_rasterization");
-        return hasExt ? (void*)entry_vkCmdSetLineStippleEXT : nullptr;
-    }
-#endif
-#ifdef VK_EXT_extended_dynamic_state
-    if (!strcmp(name, "vkCmdSetCullModeEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetCullModeEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetFrontFaceEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetPrimitiveTopologyEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetViewportWithCountEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetScissorWithCountEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdBindVertexBuffers2EXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetDepthTestEnableEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetDepthWriteEnableEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetDepthCompareOpEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetDepthBoundsTestEnableEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetStencilTestEnableEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
-        return hasExt ? (void*)entry_vkCmdSetStencilOpEXT : nullptr;
-    }
-#endif
-#ifdef VK_EXT_host_image_copy
-    if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
-        return hasExt ? (void*)entry_vkCopyMemoryToImageEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
-        return hasExt ? (void*)entry_vkCopyImageToMemoryEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCopyImageToImageEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
-        return hasExt ? (void*)entry_vkCopyImageToImageEXT : nullptr;
-    }
-    if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
-        return hasExt ? (void*)entry_vkTransitionImageLayoutEXT : nullptr;
-    }
-    if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
-        return hasExt ? (void*)entry_vkGetImageSubresourceLayout2EXT : nullptr;
-    }
-#endif
-#ifdef VK_EXT_private_data
-    if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
-        return hasExt ? (void*)entry_vkCreatePrivateDataSlotEXT : nullptr;
-    }
-    if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
-        return hasExt ? (void*)entry_vkDestroyPrivateDataSlotEXT : nullptr;
-    }
-    if (!strcmp(name, "vkSetPrivateDataEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
-        return hasExt ? (void*)entry_vkSetPrivateDataEXT : nullptr;
-    }
-    if (!strcmp(name, "vkGetPrivateDataEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
-        return hasExt ? (void*)entry_vkGetPrivateDataEXT : nullptr;
-    }
-#endif
-#ifdef VK_EXT_extended_dynamic_state2
-    if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
-        return hasExt ? (void*)entry_vkCmdSetPatchControlPointsEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
-        return hasExt ? (void*)entry_vkCmdSetRasterizerDiscardEnableEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
-        return hasExt ? (void*)entry_vkCmdSetDepthBiasEnableEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
-        return hasExt ? (void*)entry_vkCmdSetLogicOpEXT : nullptr;
-    }
-    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
-        return hasExt ? (void*)entry_vkCmdSetPrimitiveRestartEnableEXT : nullptr;
-    }
-#endif
-#ifdef VK_GOOGLE_gfxstream
-    if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkFreeMemorySyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkGetLinearImageLayoutGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkGetLinearImageLayout2GOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkGetBlobGOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkGetBlobGOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE : nullptr;
-    }
-    if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
-        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
-        return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
-    }
+#ifdef VK_QNX_external_memory_screen_buffer
 #endif
-    return nullptr;
-}
-
-}  // namespace vk
-}  // namespace gfxstream
diff --git a/guest/vulkan_enc/gfxstream_vk_private.cpp b/guest/vulkan_enc/gfxstream_vk_private.cpp
new file mode 100644
index 0000000..ba552ea
--- /dev/null
+++ b/guest/vulkan_enc/gfxstream_vk_private.cpp
@@ -0,0 +1,53 @@
+// Copyright (C) 2023 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gfxstream_vk_private.h"
+
+#include "vk_sync_dummy.h"
+
+static bool isNoopSemaphore(gfxstream_vk_semaphore* semaphore) {
+    /* Under the assumption that Mesa VK runtime queue submission is used, WSI flow
+     * sets this temporary state to a dummy sync type (when no explicit dma-buf
+     * synchronization is available). For gfxstream case, ignore this semaphore
+     * when this is the case. Synchronization will be done on the host.
+     */
+    return (semaphore && semaphore->vk.temporary &&
+            vk_sync_type_is_dummy(semaphore->vk.temporary->type));
+}
+
+std::vector<VkSemaphore> transformVkSemaphoreList(const VkSemaphore* pSemaphores,
+                                                  uint32_t semaphoreCount) {
+    std::vector<VkSemaphore> outSemaphores;
+    for (uint32_t j = 0; j < semaphoreCount; ++j) {
+        VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, pSemaphores[j]);
+        if (!isNoopSemaphore(gfxstream_semaphore)) {
+            outSemaphores.push_back(gfxstream_semaphore->internal_object);
+        }
+    }
+    return outSemaphores;
+}
+
+std::vector<VkSemaphoreSubmitInfo> transformVkSemaphoreSubmitInfoList(
+    const VkSemaphoreSubmitInfo* pSemaphoreSubmitInfos, uint32_t semaphoreSubmitInfoCount) {
+    std::vector<VkSemaphoreSubmitInfo> outSemaphoreSubmitInfo;
+    for (uint32_t j = 0; j < semaphoreSubmitInfoCount; ++j) {
+        VkSemaphoreSubmitInfo outInfo = pSemaphoreSubmitInfos[j];
+        VK_FROM_HANDLE(gfxstream_vk_semaphore, gfxstream_semaphore, outInfo.semaphore);
+        if (!isNoopSemaphore(gfxstream_semaphore)) {
+            outInfo.semaphore = gfxstream_semaphore->internal_object;
+            outSemaphoreSubmitInfo.push_back(outInfo);
+        }
+    }
+    return outSemaphoreSubmitInfo;
+}
diff --git a/guest/vulkan_enc/gfxstream_vk_private.h b/guest/vulkan_enc/gfxstream_vk_private.h
new file mode 100644
index 0000000..5062854
--- /dev/null
+++ b/guest/vulkan_enc/gfxstream_vk_private.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright © 2023 Google Inc.
+ *
+ * derived from panvk_private.h driver which is:
+ * Copyright © 2021 Collabora Ltd.
+ * Copyright © 2016 Red Hat.
+ * Copyright © 2016 Bas Nieuwenhuizen
+ * Copyright © 2015 Intel Corporation
+ *
+ * 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 (including the next
+ * paragraph) 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.
+ */
+
+#ifndef GFXSTREAM_VK_PRIVATE_H
+#define GFXSTREAM_VK_PRIVATE_H
+
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vulkan/vk_icd.h>
+#include <vulkan/vulkan.h>
+
+#include <vector>
+
+#include "gfxstream_vk_entrypoints.h"
+#include "vk_alloc.h"
+#include "vk_buffer.h"
+#include "vk_buffer_view.h"
+#include "vk_command_buffer.h"
+#include "vk_command_pool.h"
+#include "vk_descriptor_update_template.h"
+#include "vk_device.h"
+#include "vk_device_memory.h"
+#include "vk_extensions.h"
+#include "vk_fence.h"
+#include "vk_image.h"
+#include "vk_instance.h"
+#include "vk_log.h"
+#include "vk_object.h"
+#include "vk_physical_device.h"
+#include "vk_query_pool.h"
+#include "vk_queue.h"
+#include "vk_semaphore.h"
+#include "vulkan/wsi/wsi_common.h"
+
+struct gfxstream_vk_instance {
+    struct vk_instance vk;
+    uint32_t api_version;
+    VkInstance internal_object;
+};
+
+struct gfxstream_vk_physical_device {
+    struct vk_physical_device vk;
+
+    struct wsi_device wsi_device;
+    const struct vk_sync_type* sync_types[2];
+    struct gfxstream_vk_instance* instance;
+    VkPhysicalDevice internal_object;
+};
+
+struct gfxstream_vk_device {
+    struct vk_device vk;
+
+    struct vk_device_dispatch_table cmd_dispatch;
+    struct gfxstream_vk_physical_device* physical_device;
+    VkDevice internal_object;
+};
+
+struct gfxstream_vk_queue {
+    struct vk_queue vk;
+    struct gfxstream_vk_device* device;
+    VkQueue internal_object;
+};
+
+struct gfxstream_vk_pipeline_cache {
+    struct vk_object_base base;
+    VkPipelineCache internal_object;
+};
+
+struct gfxstream_vk_device_memory {
+    struct vk_device_memory vk;
+    VkDeviceMemory internal_object;
+};
+
+struct gfxstream_vk_descriptor_set_layout {
+    struct vk_object_base base;
+    VkDescriptorSetLayout internal_object;
+};
+
+struct gfxstream_vk_pipeline_layout {
+    struct vk_object_base base;
+    VkPipelineLayout internal_object;
+};
+
+struct gfxstream_vk_descriptor_pool {
+    struct vk_object_base base;
+    VkDescriptorPool internal_object;
+};
+
+struct gfxstream_vk_buffer {
+    struct vk_buffer vk;
+    VkBuffer internal_object;
+};
+
+struct gfxstream_vk_command_pool {
+    struct vk_command_pool vk;
+    VkCommandPool internal_object;
+};
+
+struct gfxstream_vk_command_buffer {
+    struct vk_command_buffer vk;
+    VkCommandBuffer internal_object;
+};
+
+struct gfxstream_vk_event {
+    struct vk_object_base base;
+    VkEvent internal_object;
+};
+
+struct gfxstream_vk_pipeline {
+    struct vk_object_base base;
+    VkPipeline internal_object;
+};
+
+struct gfxstream_vk_image {
+    struct vk_image vk;
+    VkImage internal_object;
+};
+
+struct gfxstream_vk_image_view {
+    struct vk_image_view vk;
+    VkImageView internal_object;
+};
+
+struct gfxstream_vk_buffer_view {
+    struct vk_buffer_view vk;
+    VkBufferView internal_object;
+};
+
+struct gfxstream_vk_framebuffer {
+    struct vk_object_base base;
+    VkFramebuffer internal_object;
+};
+
+struct gfxstream_vk_render_pass {
+    struct vk_object_base base;
+    VkRenderPass internal_object;
+};
+
+struct gfxstream_vk_fence {
+    struct vk_fence vk;
+    VkFence internal_object;
+};
+
+struct gfxstream_vk_semaphore {
+    struct vk_semaphore vk;
+    VkSemaphore internal_object;
+};
+
+struct gfxstream_vk_query_pool {
+    struct vk_query_pool vk;
+    VkQueryPool internal_object;
+};
+
+struct gfxstream_vk_shader_module {
+    struct vk_object_base base;
+    VkShaderModule internal_object;
+};
+
+struct gfxstream_vk_descriptor_update_template {
+    struct vk_object_base base;
+    VkDescriptorUpdateTemplate internal_object;
+};
+
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_command_buffer, vk.base, VkCommandBuffer,
+                       VK_OBJECT_TYPE_COMMAND_BUFFER)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_device, vk.base, VkDevice, VK_OBJECT_TYPE_DEVICE)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_instance, vk.base, VkInstance, VK_OBJECT_TYPE_INSTANCE)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_physical_device, vk.base, VkPhysicalDevice,
+                       VK_OBJECT_TYPE_PHYSICAL_DEVICE)
+VK_DEFINE_HANDLE_CASTS(gfxstream_vk_queue, vk.base, VkQueue, VK_OBJECT_TYPE_QUEUE)
+
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_command_pool, vk.base, VkCommandPool,
+                               VK_OBJECT_TYPE_COMMAND_POOL)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_buffer, vk.base, VkBuffer, VK_OBJECT_TYPE_BUFFER)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_buffer_view, vk.base, VkBufferView,
+                               VK_OBJECT_TYPE_BUFFER_VIEW)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_pool, base, VkDescriptorPool,
+                               VK_OBJECT_TYPE_DESCRIPTOR_POOL)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_set_layout, base, VkDescriptorSetLayout,
+                               VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_device_memory, vk.base, VkDeviceMemory,
+                               VK_OBJECT_TYPE_DEVICE_MEMORY)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_event, base, VkEvent, VK_OBJECT_TYPE_EVENT)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_framebuffer, base, VkFramebuffer,
+                               VK_OBJECT_TYPE_FRAMEBUFFER)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_image, vk.base, VkImage, VK_OBJECT_TYPE_IMAGE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_image_view, vk.base, VkImageView,
+                               VK_OBJECT_TYPE_IMAGE_VIEW);
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline_cache, base, VkPipelineCache,
+                               VK_OBJECT_TYPE_PIPELINE_CACHE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline, base, VkPipeline, VK_OBJECT_TYPE_PIPELINE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_pipeline_layout, base, VkPipelineLayout,
+                               VK_OBJECT_TYPE_PIPELINE_LAYOUT)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_render_pass, base, VkRenderPass,
+                               VK_OBJECT_TYPE_RENDER_PASS)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_fence, vk.base, VkFence, VK_OBJECT_TYPE_FENCE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_semaphore, vk.base, VkSemaphore,
+                               VK_OBJECT_TYPE_SEMAPHORE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_query_pool, vk.base, VkQueryPool,
+                               VK_OBJECT_TYPE_QUERY_POOL)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_shader_module, base, VkShaderModule,
+                               VK_OBJECT_TYPE_SHADER_MODULE)
+VK_DEFINE_NONDISP_HANDLE_CASTS(gfxstream_vk_descriptor_update_template, base,
+                               VkDescriptorUpdateTemplate,
+                               VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE)
+
+VkResult gfxstream_vk_wsi_init(struct gfxstream_vk_physical_device* physical_device);
+
+void gfxstream_vk_wsi_finish(struct gfxstream_vk_physical_device* physical_device);
+
+std::vector<VkSemaphore> transformVkSemaphoreList(const VkSemaphore* pSemaphores,
+                                                  uint32_t semaphoreCount);
+
+std::vector<VkSemaphoreSubmitInfo> transformVkSemaphoreSubmitInfoList(
+    const VkSemaphoreSubmitInfo* pSemaphoreSubmitInfos, uint32_t semaphoreSubmitInfoCount);
+
+#endif /* GFXSTREAM_VK_PRIVATE_H */
diff --git a/guest/vulkan_enc/goldfish_vk_counting_guest.cpp b/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
index baa197b..0ca2b28 100644
--- a/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_counting_guest.cpp
@@ -6411,6 +6411,39 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    uint32_t featureBits, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count) {
+    (void)featureBits;
+    (void)rootType;
+    (void)toCount;
+    (void)count;
+    *count += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = toCount->sType;
+    }
+    count_extension_struct(featureBits, rootType, toCount->pNext, count);
+    *count += sizeof(VkBool32);
+}
+
+void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    uint32_t featureBits, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count) {
+    (void)featureBits;
+    (void)rootType;
+    (void)toCount;
+    (void)count;
+    *count += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = toCount->sType;
+    }
+    count_extension_struct(featureBits, rootType, toCount->pNext, count);
+    *count += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
+    *count += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -7232,6 +7265,8 @@
 }
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 void count_extension_struct(uint32_t featureBits, VkStructureType rootType,
                             const void* structExtension, size_t* count) {
     VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -8127,6 +8162,24 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                featureBits, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+                    structExtension),
+                count);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                featureBits, rootType,
+                reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension),
+                count);
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             count_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_counting_guest.h b/guest/vulkan_enc/goldfish_vk_counting_guest.h
index 3b6e71a..d8db6b2 100644
--- a/guest/vulkan_enc/goldfish_vk_counting_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_counting_guest.h
@@ -1512,6 +1512,16 @@
                       count_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void count_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    uint32_t featureBits, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* toCount, size_t* count);
+
+void count_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    uint32_t featureBits, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* toCount, size_t* count);
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -1799,6 +1809,8 @@
     const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toCount, size_t* count);
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
index a9edede..23cc624 100644
--- a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.cpp
@@ -7395,6 +7395,54 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -8513,6 +8561,8 @@
 }
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                                const void* structExtension, void* structExtension_out) {
     if (!structExtension) {
@@ -9462,6 +9512,25 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
index f6a7fdb..da8bc90 100644
--- a/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_deepcopy_guest.h
@@ -1653,6 +1653,18 @@
                       deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void deepcopy_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* from,
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT* to);
+
+void deepcopy_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* from,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* to);
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -1975,6 +1987,8 @@
     VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to);
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
index 0a20303..979fed2 100644
--- a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.cpp
@@ -140,6 +140,8 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -210,6 +212,8 @@
 #endif
 #ifdef VK_EXT_image_compression_control_swapchain
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 uint32_t goldfish_vk_struct_type(const void* structExtension) {
     const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
     return asStructType;
@@ -609,6 +613,14 @@
             return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
@@ -1154,6 +1166,14 @@
             return sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT);
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
diff --git a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h
index 0064c66..71c7390 100644
--- a/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_extension_structs_guest.h
@@ -160,6 +160,8 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -230,6 +232,8 @@
 #endif
 #ifdef VK_EXT_image_compression_control_swapchain
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index a36522b..3edd322 100644
--- a/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -12008,6 +12008,60 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+    vkStream->write((VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    vkStream->read((VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+    vkStream->read((VkBool32*)&forUnmarshaling->depthClipEnable, sizeof(VkBool32));
+}
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -13393,6 +13447,8 @@
 }
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 void marshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
                               const void* structExtension) {
     VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -14212,6 +14268,22 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -15295,6 +15367,21 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_marshaling_guest.h b/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
index 39877d3..008d90e 100644
--- a/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_marshaling_guest.h
@@ -3148,6 +3148,24 @@
                       unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void marshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClipEnableFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* forUnmarshaling);
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -3706,6 +3724,8 @@
     VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling);
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 const char* api_opcode_to_string(const uint32_t opcode);
 
 #define OP_vkFirst_old 20000
diff --git a/guest/vulkan_enc/goldfish_vk_private_defs.h b/guest/vulkan_enc/goldfish_vk_private_defs.h
index 0867320..d50e6f1 100644
--- a/guest/vulkan_enc/goldfish_vk_private_defs.h
+++ b/guest/vulkan_enc/goldfish_vk_private_defs.h
@@ -23,16 +23,16 @@
 
 #ifdef __cplusplus
 
-template<class T, typename F>
+template <class T, typename F>
 bool arrayany(const T* arr, uint32_t begin, uint32_t end, const F& func) {
     const T* e = arr + end;
     return std::find_if(arr + begin, e, func) != e;
 }
 
-#define DEFINE_ALIAS_FUNCTION(ORIGINAL_FN, ALIAS_FN) \
-template <typename... Args> \
-inline auto ALIAS_FN(Args&&... args) -> decltype(ORIGINAL_FN(std::forward<Args>(args)...)) { \
-  return ORIGINAL_FN(std::forward<Args>(args)...); \
-}
+#define DEFINE_ALIAS_FUNCTION(ORIGINAL_FN, ALIAS_FN)                                             \
+    template <typename... Args>                                                                  \
+    inline auto ALIAS_FN(Args&&... args) -> decltype(ORIGINAL_FN(std::forward<Args>(args)...)) { \
+        return ORIGINAL_FN(std::forward<Args>(args)...);                                         \
+    }
 
 #endif
diff --git a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
index 71f3a94..6c223e7 100644
--- a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.cpp
@@ -8086,6 +8086,41 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr) {
+    (void)vkStream;
+    (void)rootType;
+    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+    memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr) {
+    (void)vkStream;
+    (void)rootType;
+    memcpy(*ptr, (VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    reservedmarshal_extension_struct(vkStream, rootType, forMarshaling->pNext, ptr);
+    memcpy(*ptr, (VkPipelineRasterizationDepthClipStateCreateFlagsEXT*)&forMarshaling->flags,
+           sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT));
+    *ptr += sizeof(VkPipelineRasterizationDepthClipStateCreateFlagsEXT);
+    memcpy(*ptr, (VkBool32*)&forMarshaling->depthClipEnable, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -8994,6 +9029,8 @@
 }
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 void reservedmarshal_extension_struct(VulkanStreamGuest* vkStream, VkStructureType rootType,
                                       const void* structExtension, uint8_t** ptr) {
     VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -9880,6 +9917,24 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(
+                    structExtension),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             reservedmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
index f1a8a1c..ac2de29 100644
--- a/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_reserved_marshaling_guest.h
@@ -1685,6 +1685,16 @@
                       reservedmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void reservedmarshal_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* forMarshaling, uint8_t** ptr);
+
+void reservedmarshal_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    VulkanStreamGuest* vkStream, VkStructureType rootType,
+    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* forMarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -1991,6 +2001,8 @@
     uint8_t** ptr);
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/goldfish_vk_transform_guest.cpp b/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
index 8eb7cd7..8aa5c7d 100644
--- a/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
+++ b/guest/vulkan_enc/goldfish_vk_transform_guest.cpp
@@ -6870,6 +6870,46 @@
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    ResourceTracker* resourceTracker,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    ResourceTracker* resourceTracker,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -7826,6 +7866,8 @@
 }
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 void transform_tohost_extension_struct(ResourceTracker* resourceTracker,
                                        void* structExtension_out) {
     if (!structExtension_out) {
@@ -8600,6 +8642,21 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -9631,6 +9688,21 @@
             break;
         }
 #endif
+#ifdef VK_EXT_depth_clip_enable
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
+            transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_vertex_attribute_divisor
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
             transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/guest/vulkan_enc/goldfish_vk_transform_guest.h b/guest/vulkan_enc/goldfish_vk_transform_guest.h
index 6dff96d..fb8ef89 100644
--- a/guest/vulkan_enc/goldfish_vk_transform_guest.h
+++ b/guest/vulkan_enc/goldfish_vk_transform_guest.h
@@ -2663,6 +2663,22 @@
                       transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
+#ifdef VK_EXT_depth_clip_enable
+void transform_tohost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
+    ResourceTracker* resourceTracker, VkPhysicalDeviceDepthClipEnableFeaturesEXT* toTransform);
+
+void transform_tohost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    ResourceTracker* resourceTracker,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
+    ResourceTracker* resourceTracker,
+    VkPipelineRasterizationDepthClipStateCreateInfoEXT* toTransform);
+
+#endif
 #ifdef VK_EXT_swapchain_colorspace
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -3131,6 +3147,8 @@
     VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform);
 
 #endif
+#ifdef VK_QNX_external_memory_screen_buffer
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/guest/vulkan_enc/meson.build b/guest/vulkan_enc/meson.build
index c94dd0d..33709bb 100644
--- a/guest/vulkan_enc/meson.build
+++ b/guest/vulkan_enc/meson.build
@@ -1,6 +1,17 @@
 # Copyright 2022 Android Open Source Project
 # SPDX-License-Identifier: MIT
 
+gfxstream_vk_entrypoints = custom_target(
+  'gfxstream_vk_entrypoints',
+  input : [vk_entrypoints_gen, vk_api_xml],
+  output : ['gfxstream_vk_entrypoints.h', 'gfxstream_vk_entrypoints.c'],
+  command : [
+    prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--proto', '--weak',
+    '--out-h', '@OUTPUT0@', '--out-c', '@OUTPUT1@', '--prefix', 'gfxstream_vk',
+    '--beta', with_vulkan_beta.to_string()
+  ],
+)
+
 files_lib_vulkan_enc = files(
   'CommandBufferStagingStream.cpp',
   'DescriptorSetVirtualization.cpp',
@@ -19,16 +30,5 @@
   'goldfish_vk_marshaling_guest.cpp',
   'goldfish_vk_reserved_marshaling_guest.cpp',
   'goldfish_vk_transform_guest.cpp',
-)
-
-lib_vulkan_enc = static_library(
-   'vulkan_enc',
-   files_lib_vulkan_enc,
-   cpp_args: cpp_args,
-   include_directories: [inc_android_emu, inc_guest_iostream, inc_android_compat,
-                         inc_opengl_codec, inc_render_enc, inc_system,
-                         inc_goldfish_address_space, inc_platform,
-                         inc_vulkan_headers, inc_opengl_headers, inc_codec_common],
-   link_with: [lib_platform],
-   dependencies: dependency('libdrm'),
+  'gfxstream_vk_private.cpp',
 )
diff --git a/guest/vulkan_enc/vk_format_info.h b/guest/vulkan_enc/vk_format_info.h
index 9fbc82a..2d5d84e 100644
--- a/guest/vulkan_enc/vk_format_info.h
+++ b/guest/vulkan_enc/vk_format_info.h
@@ -35,8 +35,8 @@
     HAL_PIXEL_FORMAT_YV12 = 842094169,
 };
 #endif
-#include <vulkan/vulkan.h>
 #include <vndk/hardware_buffer.h>
+#include <vulkan/vulkan.h>
 
 namespace gfxstream {
 namespace vk {
@@ -55,165 +55,149 @@
 // formats such as AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 could be
 // either VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM or
 // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
-static inline VkFormat
-vk_format_from_android(unsigned android_format)
-{
-   switch (android_format) {
-   case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
-      return VK_FORMAT_R8G8B8A8_UNORM;
-   case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
-      return VK_FORMAT_R8G8B8A8_UNORM;
-   case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
-      return VK_FORMAT_R8G8B8_UNORM;
-   case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
-      return VK_FORMAT_R5G6B5_UNORM_PACK16;
-   case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
-      return VK_FORMAT_R16G16B16A16_SFLOAT;
-   case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
-      return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
-   case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
-   case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
-      return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
+static inline VkFormat vk_format_from_android(unsigned android_format) {
+    switch (android_format) {
+        case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+            return VK_FORMAT_R8G8B8A8_UNORM;
+        case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+            return VK_FORMAT_R8G8B8A8_UNORM;
+        case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+            return VK_FORMAT_R8G8B8_UNORM;
+        case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+            return VK_FORMAT_R5G6B5_UNORM_PACK16;
+        case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+            return VK_FORMAT_R16G16B16A16_SFLOAT;
+        case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+            return VK_FORMAT_A2B10G10R10_UNORM_PACK32;
+        case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
+        case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
+            return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
 #if __ANDROID_API__ >= 30
-   case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
-      return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
+        case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+            return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
 #endif
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-   case HAL_PIXEL_FORMAT_YV12:
-   case OMX_COLOR_FormatYUV420Planar:
-      return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
-   case AHARDWAREBUFFER_FORMAT_BLOB:
+        case HAL_PIXEL_FORMAT_YV12:
+        case OMX_COLOR_FormatYUV420Planar:
+            return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
+        case AHARDWAREBUFFER_FORMAT_BLOB:
 #endif
-   default:
-      return VK_FORMAT_UNDEFINED;
-   }
+        default:
+            return VK_FORMAT_UNDEFINED;
+    }
 }
 
-static inline unsigned
-android_format_from_vk(VkFormat vk_format)
-{
-   switch (vk_format) {
-   case VK_FORMAT_R8G8B8A8_UNORM:
-      return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
-   case VK_FORMAT_R8G8B8_UNORM:
-      return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
-   case VK_FORMAT_R5G6B5_UNORM_PACK16:
-      return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
-   case VK_FORMAT_R16G16B16A16_SFLOAT:
-      return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
-   case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
-      return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
-   case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
-      return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
-   case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
-      return HAL_PIXEL_FORMAT_YV12;
-   default:
-      return AHARDWAREBUFFER_FORMAT_BLOB;
-   }
+static inline unsigned android_format_from_vk(VkFormat vk_format) {
+    switch (vk_format) {
+        case VK_FORMAT_R8G8B8A8_UNORM:
+            return AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM;
+        case VK_FORMAT_R8G8B8_UNORM:
+            return AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM;
+        case VK_FORMAT_R5G6B5_UNORM_PACK16:
+            return AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM;
+        case VK_FORMAT_R16G16B16A16_SFLOAT:
+            return AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT;
+        case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+            return AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM;
+        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+            return HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL;
+        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+            return HAL_PIXEL_FORMAT_YV12;
+        default:
+            return AHARDWAREBUFFER_FORMAT_BLOB;
+    }
 }
 
-static inline bool
-android_format_is_yuv(unsigned android_format)
-{
-   switch (android_format) {
-   case AHARDWAREBUFFER_FORMAT_BLOB:
-   case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
-   case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
-   case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
-   case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
-   case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
-   case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
-   case AHARDWAREBUFFER_FORMAT_D16_UNORM:
-   case AHARDWAREBUFFER_FORMAT_D24_UNORM:
-   case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
-   case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
-   case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
-   case AHARDWAREBUFFER_FORMAT_S8_UINT:
-      return false;
-   case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
-   case OMX_COLOR_FormatYUV420Planar:
-   case HAL_PIXEL_FORMAT_YV12:
+static inline bool android_format_is_yuv(unsigned android_format) {
+    switch (android_format) {
+        case AHARDWAREBUFFER_FORMAT_BLOB:
+        case AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM:
+        case AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM:
+        case AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM:
+        case AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM:
+        case AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT:
+        case AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM:
+        case AHARDWAREBUFFER_FORMAT_D16_UNORM:
+        case AHARDWAREBUFFER_FORMAT_D24_UNORM:
+        case AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT:
+        case AHARDWAREBUFFER_FORMAT_D32_FLOAT:
+        case AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT:
+        case AHARDWAREBUFFER_FORMAT_S8_UINT:
+            return false;
+        case HAL_PIXEL_FORMAT_NV12_Y_TILED_INTEL:
+        case OMX_COLOR_FormatYUV420Planar:
+        case HAL_PIXEL_FORMAT_YV12:
 #if __ANDROID_API__ >= 30
-   case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
+        case AHARDWAREBUFFER_FORMAT_YCbCr_P010:
 #endif
-   case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
-      return true;
-   default:
-      ALOGE("%s: unhandled format: %d", __FUNCTION__, android_format);
-      return false;
-   }
+        case AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420:
+            return true;
+        default:
+            ALOGE("%s: unhandled format: %d", __FUNCTION__, android_format);
+            return false;
+    }
 }
 
-static inline VkImageAspectFlags
-vk_format_aspects(VkFormat format)
-{
-   switch (format) {
-   case VK_FORMAT_UNDEFINED:
-      return 0;
+static inline VkImageAspectFlags vk_format_aspects(VkFormat format) {
+    switch (format) {
+        case VK_FORMAT_UNDEFINED:
+            return 0;
 
-   case VK_FORMAT_S8_UINT:
-      return VK_IMAGE_ASPECT_STENCIL_BIT;
+        case VK_FORMAT_S8_UINT:
+            return VK_IMAGE_ASPECT_STENCIL_BIT;
 
-   case VK_FORMAT_D16_UNORM_S8_UINT:
-   case VK_FORMAT_D24_UNORM_S8_UINT:
-   case VK_FORMAT_D32_SFLOAT_S8_UINT:
-      return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+        case VK_FORMAT_D16_UNORM_S8_UINT:
+        case VK_FORMAT_D24_UNORM_S8_UINT:
+        case VK_FORMAT_D32_SFLOAT_S8_UINT:
+            return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
 
-   case VK_FORMAT_D16_UNORM:
-   case VK_FORMAT_X8_D24_UNORM_PACK32:
-   case VK_FORMAT_D32_SFLOAT:
-      return VK_IMAGE_ASPECT_DEPTH_BIT;
+        case VK_FORMAT_D16_UNORM:
+        case VK_FORMAT_X8_D24_UNORM_PACK32:
+        case VK_FORMAT_D32_SFLOAT:
+            return VK_IMAGE_ASPECT_DEPTH_BIT;
 
-   case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
-   case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
-   case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
-   case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
-   case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
-   case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
-   case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
-   case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
-   case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
-   case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
-   case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
-   case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
-      return (VK_IMAGE_ASPECT_PLANE_0_BIT |
-              VK_IMAGE_ASPECT_PLANE_1_BIT |
-              VK_IMAGE_ASPECT_PLANE_2_BIT);
+        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+        case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+        case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
+        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+        case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+        case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+        case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
+            return (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT |
+                    VK_IMAGE_ASPECT_PLANE_2_BIT);
 
-   case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
-   case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
-   case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
-   case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
-   case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
-   case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
-   case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
-   case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
-      return (VK_IMAGE_ASPECT_PLANE_0_BIT |
-              VK_IMAGE_ASPECT_PLANE_1_BIT);
+        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+        case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+        case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+        case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+        case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+            return (VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT);
 
-   default:
-      return VK_IMAGE_ASPECT_COLOR_BIT;
-   }
+        default:
+            return VK_IMAGE_ASPECT_COLOR_BIT;
+    }
 }
 
-static inline bool
-vk_format_is_color(VkFormat format)
-{
-   return vk_format_aspects(format) == VK_IMAGE_ASPECT_COLOR_BIT;
+static inline bool vk_format_is_color(VkFormat format) {
+    return vk_format_aspects(format) == VK_IMAGE_ASPECT_COLOR_BIT;
 }
 
-static inline bool
-vk_format_is_depth_or_stencil(VkFormat format)
-{
-   const VkImageAspectFlags aspects = vk_format_aspects(format);
-   return aspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
+static inline bool vk_format_is_depth_or_stencil(VkFormat format) {
+    const VkImageAspectFlags aspects = vk_format_aspects(format);
+    return aspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
 }
 
-static inline bool
-vk_format_has_depth(VkFormat format)
-{
-   const VkImageAspectFlags aspects = vk_format_aspects(format);
-   return aspects & VK_IMAGE_ASPECT_DEPTH_BIT;
+static inline bool vk_format_has_depth(VkFormat format) {
+    const VkImageAspectFlags aspects = vk_format_aspects(format);
+    return aspects & VK_IMAGE_ASPECT_DEPTH_BIT;
 }
 
 }  // namespace vk
diff --git a/guest/vulkan_enc/vk_platform_compat.h b/guest/vulkan_enc/vk_platform_compat.h
index e182bac..38f78cd 100644
--- a/guest/vulkan_enc/vk_platform_compat.h
+++ b/guest/vulkan_enc/vk_platform_compat.h
@@ -18,13 +18,13 @@
 #if VK_HEADER_VERSION < 76
 
 typedef struct VkBaseOutStructure {
-    VkStructureType               sType;
-    struct VkBaseOutStructure*    pNext;
+    VkStructureType sType;
+    struct VkBaseOutStructure* pNext;
 } VkBaseOutStructure;
 
 typedef struct VkBaseInStructure {
-    VkStructureType                    sType;
-    const struct VkBaseInStructure*    pNext;
+    VkStructureType sType;
+    const struct VkBaseInStructure* pNext;
 } VkBaseInStructure;
 
-#endif // VK_HEADER_VERSION < 76
+#endif  // VK_HEADER_VERSION < 76
diff --git a/guest/vulkan_enc/vk_struct_id.h b/guest/vulkan_enc/vk_struct_id.h
index 0ca2ff5..eaae46b 100644
--- a/guest/vulkan_enc/vk_struct_id.h
+++ b/guest/vulkan_enc/vk_struct_id.h
@@ -20,18 +20,25 @@
 #include "vk_android_native_buffer_gfxstream.h"
 #include "vulkan_gfxstream.h"
 
-namespace gfxstream {
-namespace vk {
+// anonymous
+namespace {
 
-template <class T> struct vk_get_vk_struct_id;
+template <class T>
+struct vk_get_vk_struct_id;
 
-#define REGISTER_VK_STRUCT_ID(T, ID) \
-    template <> struct vk_get_vk_struct_id<T> { static constexpr VkStructureType id = ID; }
+#define REGISTER_VK_STRUCT_ID(T, ID)              \
+    template <>                                   \
+    struct vk_get_vk_struct_id<T> {               \
+        static constexpr VkStructureType id = ID; \
+    }
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferPropertiesANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID);
-REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferFormatPropertiesANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
-REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferUsageANDROID, VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID);
+REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferPropertiesANDROID,
+                      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID);
+REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferFormatPropertiesANDROID,
+                      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID);
+REGISTER_VK_STRUCT_ID(VkAndroidHardwareBufferUsageANDROID,
+                      VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID);
 #endif
 REGISTER_VK_STRUCT_ID(VkBufferCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkImageCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
@@ -40,52 +47,79 @@
 REGISTER_VK_STRUCT_ID(VkNativeBufferANDROID, VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID);
 REGISTER_VK_STRUCT_ID(VkExternalFormatANDROID, VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID);
 #endif
-REGISTER_VK_STRUCT_ID(VkExternalMemoryBufferCreateInfo, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkExternalMemoryImageCreateInfo, VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkExternalMemoryBufferCreateInfo,
+                      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkExternalMemoryImageCreateInfo,
+                      VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkMemoryAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
-REGISTER_VK_STRUCT_ID(VkMemoryDedicatedAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
-REGISTER_VK_STRUCT_ID(VkMemoryDedicatedRequirements, VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
+REGISTER_VK_STRUCT_ID(VkMemoryDedicatedAllocateInfo,
+                      VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO);
+REGISTER_VK_STRUCT_ID(VkMemoryDedicatedRequirements,
+                      VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS);
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-REGISTER_VK_STRUCT_ID(VkImportAndroidHardwareBufferInfoANDROID, VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
+REGISTER_VK_STRUCT_ID(VkImportAndroidHardwareBufferInfoANDROID,
+                      VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID);
 #endif
+REGISTER_VK_STRUCT_ID(VkImportMemoryFdInfoKHR, VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR);
 REGISTER_VK_STRUCT_ID(VkExportMemoryAllocateInfo, VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO);
 REGISTER_VK_STRUCT_ID(VkMemoryRequirements2, VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2);
 REGISTER_VK_STRUCT_ID(VkSemaphoreCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkExportSemaphoreCreateInfoKHR, VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR);
-REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkExportSemaphoreCreateInfoKHR,
+                      VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR);
+REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionCreateInfo,
+                      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkImportColorBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE);
 REGISTER_VK_STRUCT_ID(VkImageViewCreateInfo, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
 #ifdef VK_USE_PLATFORM_FUCHSIA
-REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA, VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
-REGISTER_VK_STRUCT_ID(VkBufferCollectionBufferCreateInfoFUCHSIA, VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkImportMemoryBufferCollectionFUCHSIA,
+                      VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkImportMemoryZirconHandleInfoFUCHSIA,
+                      VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkBufferCollectionImageCreateInfoFUCHSIA,
+                      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA);
+REGISTER_VK_STRUCT_ID(VkBufferCollectionBufferCreateInfoFUCHSIA,
+                      VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA);
 #endif  // VK_USE_PLATFORM_FUCHSIA
 REGISTER_VK_STRUCT_ID(VkSamplerCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkSamplerCustomBorderColorCreateInfoEXT, VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
-REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionInfo, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
+REGISTER_VK_STRUCT_ID(VkSamplerCustomBorderColorCreateInfoEXT,
+                      VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT);
+REGISTER_VK_STRUCT_ID(VkSamplerYcbcrConversionInfo,
+                      VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO);
 REGISTER_VK_STRUCT_ID(VkFenceCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkExportFenceCreateInfo, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkImportBufferGOOGLE, VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE);
 REGISTER_VK_STRUCT_ID(VkCreateBlobGOOGLE, VK_STRUCTURE_TYPE_CREATE_BLOB_GOOGLE);
-REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties, VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceImageFormatInfo2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalImageFormatInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
+REGISTER_VK_STRUCT_ID(VkExternalImageFormatProperties,
+                      VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceImageFormatInfo2,
+                      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalImageFormatInfo,
+                      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO);
 REGISTER_VK_STRUCT_ID(VkSemaphoreTypeCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkPhysicalDeviceFeatures2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
 REGISTER_VK_STRUCT_ID(VkPhysicalDeviceProperties2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT,
+                      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT);
 REGISTER_VK_STRUCT_ID(VkMemoryAllocateFlagsInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO);
-REGISTER_VK_STRUCT_ID(VkMemoryOpaqueCaptureAddressAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
+REGISTER_VK_STRUCT_ID(VkMemoryOpaqueCaptureAddressAllocateInfo,
+                      VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO);
 REGISTER_VK_STRUCT_ID(VkBindImageMemoryInfo, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
-REGISTER_VK_STRUCT_ID(VkBindImageMemorySwapchainInfoKHR, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
-REGISTER_VK_STRUCT_ID(VkBufferOpaqueCaptureAddressCreateInfo, VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkBufferDeviceAddressCreateInfoEXT, VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT);
-REGISTER_VK_STRUCT_ID(VkGraphicsPipelineCreateInfo, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkPipelineRenderingCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
-REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalSemaphoreInfo, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
+REGISTER_VK_STRUCT_ID(VkBindImageMemorySwapchainInfoKHR,
+                      VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR);
+REGISTER_VK_STRUCT_ID(VkBufferOpaqueCaptureAddressCreateInfo,
+                      VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkBufferDeviceAddressCreateInfoEXT,
+                      VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT);
+REGISTER_VK_STRUCT_ID(VkGraphicsPipelineCreateInfo,
+                      VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkPipelineRenderingCreateInfo,
+                      VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkPhysicalDeviceExternalSemaphoreInfo,
+                      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO);
+REGISTER_VK_STRUCT_ID(VkRenderPassBeginInfo, VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO);
+REGISTER_VK_STRUCT_ID(VkRenderPassAttachmentBeginInfo,
+                      VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO);
 
 #undef REGISTER_VK_STRUCT_ID
 
-}  // namespace vk
-}  // namespace gfxstream
+}  // namespace
diff --git a/guest/vulkan_enc/vk_util.h b/guest/vulkan_enc/vk_util.h
index 2e3267f..e18bdde 100644
--- a/guest/vulkan_enc/vk_util.h
+++ b/guest/vulkan_enc/vk_util.h
@@ -25,29 +25,29 @@
 
 /* common inlines and macros for vulkan drivers */
 
-#include <vulkan/vulkan.h>
 #include <stdlib.h>
+#include <vulkan/vulkan.h>
+
 #include "vk_struct_id.h"
 
-namespace gfxstream {
-namespace vk {
+namespace {  // anonymous
 
 struct vk_struct_common {
     VkStructureType sType;
-    struct vk_struct_common *pNext;
+    struct vk_struct_common* pNext;
 };
 
 struct vk_struct_chain_iterator {
     vk_struct_common* value;
 };
 
-#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(__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)
+#define vk_foreach_struct_const(__iter, __start)                                            \
+    for (const struct vk_struct_common* __iter = (const struct vk_struct_common*)(__start); \
+         __iter; __iter = __iter->pNext)
 
 /**
  * A wrapper for a Vulkan output array. A Vulkan output array is one that
@@ -79,92 +79,84 @@
  *    }
  */
 struct __vk_outarray {
-   /** May be null. */
-   void *data;
+    /** May be null. */
+    void* data;
 
-   /**
-    * Capacity, in number of elements. Capacity is unlimited (UINT32_MAX) if
-    * data is null.
-    */
-   uint32_t cap;
+    /**
+     * Capacity, in number of elements. Capacity is unlimited (UINT32_MAX) if
+     * data is null.
+     */
+    uint32_t cap;
 
-   /**
-    * Count of elements successfully written to the array. Every write is
-    * considered successful if data is null.
-    */
-   uint32_t *filled_len;
+    /**
+     * Count of elements successfully written to the array. Every write is
+     * considered successful if data is null.
+     */
+    uint32_t* filled_len;
 
-   /**
-    * Count of elements that would have been written to the array if its
-    * capacity were sufficient. Vulkan functions often return VK_INCOMPLETE
-    * when `*filled_len < wanted_len`.
-    */
-   uint32_t wanted_len;
+    /**
+     * Count of elements that would have been written to the array if its
+     * capacity were sufficient. Vulkan functions often return VK_INCOMPLETE
+     * when `*filled_len < wanted_len`.
+     */
+    uint32_t wanted_len;
 };
 
-static inline void
-__vk_outarray_init(struct __vk_outarray *a,
-                   void *data, uint32_t * len)
-{
-   a->data = data;
-   a->cap = *len;
-   a->filled_len = len;
-   *a->filled_len = 0;
-   a->wanted_len = 0;
+static inline void __vk_outarray_init(struct __vk_outarray* a, void* data, uint32_t* len) {
+    a->data = data;
+    a->cap = *len;
+    a->filled_len = len;
+    *a->filled_len = 0;
+    a->wanted_len = 0;
 
-   if (a->data == NULL)
-      a->cap = UINT32_MAX;
+    if (a->data == NULL) a->cap = UINT32_MAX;
 }
 
-static inline VkResult
-__vk_outarray_status(const struct __vk_outarray *a)
-{
-   if (*a->filled_len < a->wanted_len)
-      return VK_INCOMPLETE;
-   else
-      return VK_SUCCESS;
+static inline VkResult __vk_outarray_status(const struct __vk_outarray* a) {
+    if (*a->filled_len < a->wanted_len)
+        return VK_INCOMPLETE;
+    else
+        return VK_SUCCESS;
 }
 
-static inline void *
-__vk_outarray_next(struct __vk_outarray *a, size_t elem_size)
-{
-   void *p = NULL;
+static inline void* __vk_outarray_next(struct __vk_outarray* a, size_t elem_size) {
+    void* p = NULL;
 
-   a->wanted_len += 1;
+    a->wanted_len += 1;
 
-   if (*a->filled_len >= a->cap)
-      return NULL;
+    if (*a->filled_len >= a->cap) return NULL;
 
-   if (a->data != NULL)
-      p = ((uint8_t*)a->data) + (*a->filled_len) * elem_size;
+    if (a->data != NULL) p = ((uint8_t*)a->data) + (*a->filled_len) * elem_size;
 
-   *a->filled_len += 1;
+    *a->filled_len += 1;
 
-   return p;
+    return p;
 }
 
-#define vk_outarray(elem_t) \
-   struct { \
-      struct __vk_outarray base; \
-      elem_t meta[]; \
-   }
+#define vk_outarray(elem_t)        \
+    struct {                       \
+        struct __vk_outarray base; \
+        elem_t meta[];             \
+    }
 
 #define vk_outarray_typeof_elem(a) __typeof__((a)->meta[0])
 #define vk_outarray_sizeof_elem(a) sizeof((a)->meta[0])
 
-#define vk_outarray_init(a, data, len) \
-   __vk_outarray_init(&(a)->base, (data), (len))
+#define vk_outarray_init(a, data, len) __vk_outarray_init(&(a)->base, (data), (len))
 
-#define VK_OUTARRAY_MAKE(name, data, len) \
-   vk_outarray(__typeof__((data)[0])) name; \
-   vk_outarray_init(&name, (data), (len))
+#define VK_OUTARRAY_MAKE(name, data, len)    \
+    vk_outarray(__typeof__((data)[0])) name; \
+    vk_outarray_init(&name, (data), (len))
 
-#define vk_outarray_status(a) \
-   __vk_outarray_status(&(a)->base)
+#define VK_OUTARRAY_MAKE_TYPED(type, name, data, len) \
+    vk_outarray(type) name;                           \
+    vk_outarray_init(&name, (data), (len))
 
-#define vk_outarray_next(a) \
-   ((vk_outarray_typeof_elem(a) *) \
-      __vk_outarray_next(&(a)->base, vk_outarray_sizeof_elem(a)))
+#define vk_outarray_status(a) __vk_outarray_status(&(a)->base)
+
+#define vk_outarray_next(a) vk_outarray_next_typed(vk_outarray_typeof_elem(a), a)
+#define vk_outarray_next_typed(type, a) \
+    ((type*)__vk_outarray_next(&(a)->base, vk_outarray_sizeof_elem(a)))
 
 /**
  * Append to a Vulkan output array.
@@ -186,31 +178,30 @@
  * points to the newly appended element.
  */
 #define vk_outarray_append(a, elem) \
-   for (vk_outarray_typeof_elem(a) *elem = vk_outarray_next(a); \
-        elem != NULL; elem = NULL)
+    for (vk_outarray_typeof_elem(a)* elem = vk_outarray_next(a); elem != NULL; elem = NULL)
 
-static inline void *
-__vk_find_struct(void *start, VkStructureType sType)
-{
-   vk_foreach_struct(s, start) {
-      if (s->sType == sType)
-         return s;
-   }
+#define vk_outarray_append_typed(type, a, elem) \
+    for (type* elem = vk_outarray_next_typed(type, a); elem != NULL; elem = NULL)
 
-   return NULL;
+static inline void* __vk_find_struct(void* start, VkStructureType sType) {
+    vk_foreach_struct(s, start) {
+        if (s->sType == sType) return s;
+    }
+
+    return NULL;
 }
 
-template <class T, class H> T* vk_find_struct(H* head)
-{
+template <class T, class H>
+T* vk_find_struct(H* head) {
     (void)vk_get_vk_struct_id<H>::id;
     return static_cast<T*>(__vk_find_struct(static_cast<void*>(head), vk_get_vk_struct_id<T>::id));
 }
 
-template <class T, class H> const T* vk_find_struct(const H* head)
-{
+template <class T, class H>
+const T* vk_find_struct(const H* head) {
     (void)vk_get_vk_struct_id<H>::id;
     return static_cast<const T*>(__vk_find_struct(const_cast<void*>(static_cast<const void*>(head)),
-                                 vk_get_vk_struct_id<T>::id));
+                                                  vk_get_vk_struct_id<T>::id));
 }
 
 uint32_t vk_get_driver_version(void);
@@ -219,25 +210,25 @@
 
 #define VK_EXT_OFFSET (1000000000UL)
 #define VK_ENUM_EXTENSION(__enum) \
-   ((__enum) >= VK_EXT_OFFSET ? ((((__enum) - VK_EXT_OFFSET) / 1000UL) + 1) : 0)
-#define VK_ENUM_OFFSET(__enum) \
-   ((__enum) >= VK_EXT_OFFSET ? ((__enum) % 1000) : (__enum))
+    ((__enum) >= VK_EXT_OFFSET ? ((((__enum)-VK_EXT_OFFSET) / 1000UL) + 1) : 0)
+#define VK_ENUM_OFFSET(__enum) ((__enum) >= VK_EXT_OFFSET ? ((__enum) % 1000) : (__enum))
 
-template <class T> T vk_make_orphan_copy(const T& vk_struct) {
+template <class T>
+T vk_make_orphan_copy(const T& vk_struct) {
     T copy = vk_struct;
     copy.pNext = NULL;
     return copy;
 }
 
-template <class T> vk_struct_chain_iterator vk_make_chain_iterator(T* vk_struct)
-{
+template <class T>
+vk_struct_chain_iterator vk_make_chain_iterator(T* vk_struct) {
     (void)vk_get_vk_struct_id<T>::id;
-    vk_struct_chain_iterator result = { reinterpret_cast<vk_struct_common*>(vk_struct) };
+    vk_struct_chain_iterator result = {reinterpret_cast<vk_struct_common*>(vk_struct)};
     return result;
 }
 
-template <class T> void vk_append_struct(vk_struct_chain_iterator* i, T* vk_struct)
-{
+template <class T>
+void vk_append_struct(vk_struct_chain_iterator* i, T* vk_struct) {
     (void)vk_get_vk_struct_id<T>::id;
 
     vk_struct_common* p = i->value;
@@ -245,13 +236,12 @@
         ::abort();
     }
 
-    p->pNext = reinterpret_cast<vk_struct_common *>(vk_struct);
+    p->pNext = reinterpret_cast<vk_struct_common*>(vk_struct);
     vk_struct->pNext = NULL;
 
     *i = vk_make_chain_iterator(vk_struct);
 }
 
-}  // namespace vk
-}  // namespace gfxstream
+}  // namespace
 
 #endif /* VK_UTIL_H */