| // Copyright (C) 2018 The Android Open Source Project |
| // Copyright (C) 2018 Google Inc. |
| // |
| // 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. |
| |
| // Autogenerated module VkDecoderSnapshot |
| // |
| // (impl) generated by scripts/genvk.py -registry |
| // ../../../../../hardware/google/gfxstream/third_party/vulkan_docs/xml/vk.xml -registryGfxstream |
| // xml/vk_gfxstream.xml cereal -o ../../../../../hardware/google/gfxstream/host/vulkan/cereal |
| // |
| // Please do not modify directly; |
| // re-run mesa3d/src/gfxstream/codegen/generate-gfxstream-vulkan.sh, |
| // or directly from Python by defining: |
| // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml |
| // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py |
| // CEREAL_OUTPUT_DIR: Where to put the generated sources. |
| // |
| // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o |
| // $CEREAL_OUTPUT_DIR |
| // |
| |
| #include "VkDecoderSnapshot.h" |
| |
| #include <mutex> |
| |
| #include "VkDecoderGlobalState.h" |
| #include "VkReconstruction.h" |
| #include "VulkanBoxedHandles.h" |
| #include "VulkanHandleMapping.h" |
| #include "gfxstream/ThreadAnnotations.h" |
| |
| namespace gfxstream { |
| namespace vk { |
| |
| class VkDecoderSnapshot::Impl { |
| public: |
| Impl() {} |
| |
| void clear() { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.clear(); |
| } |
| |
| void saveReplayBuffers(gfxstream::Stream* stream) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.saveReplayBuffers(stream); |
| } |
| |
| static void loadReplayBuffers(gfxstream::Stream* stream, std::vector<uint64_t>* outHandleBuffer, |
| std::vector<uint8_t>* outDecoderBuffer) { |
| VkReconstruction::loadReplayBuffers(stream, outHandleBuffer, outDecoderBuffer); |
| } |
| |
| VkSnapshotApiCallHandle createApiCallInfo() { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| return mReconstruction.createApiCallInfo(); |
| } |
| |
| void destroyApiCallInfoIfUnused(VkSnapshotApiCallHandle apiCallHandle) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| return mReconstruction.destroyApiCallInfoIfUnused(apiCallHandle); |
| } |
| |
| void addOrderedBoxedHandlesCreatedByCall(VkSnapshotApiCallHandle apiCallHandle, |
| VkObjectHandle* boxedHandles, |
| uint32_t boxedHandlesCount) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| return mReconstruction.addOrderedBoxedHandlesCreatedByCall(apiCallHandle, boxedHandles, |
| boxedHandlesCount); |
| } |
| |
| #ifdef VK_VERSION_1_0 |
| void vkCreateInstance(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { |
| if (!pInstance) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pInstance create |
| mReconstruction.addHandles((const uint64_t*)pInstance, 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pInstance, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pInstance, 1); |
| } |
| void vkDestroyInstance(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkInstance instance, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // instance destroy |
| mReconstruction.removeHandles((const uint64_t*)(&instance), 1, true); |
| } |
| void vkEnumeratePhysicalDevices(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices) { |
| if (!pPhysicalDevices) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pPhysicalDevices create |
| mReconstruction.addHandles((const uint64_t*)pPhysicalDevices, (*pPhysicalDeviceCount)); |
| mReconstruction.addHandleDependency((const uint64_t*)pPhysicalDevices, |
| (*pPhysicalDeviceCount), (uint64_t)(uintptr_t)instance); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| if (pPhysicalDeviceCount) { |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pPhysicalDevices, |
| (*pPhysicalDeviceCount), apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi( |
| apiCallHandle, (const uint64_t*)pPhysicalDevices, (*pPhysicalDeviceCount)); |
| } |
| } |
| void vkGetPhysicalDeviceFeatures(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures* pFeatures) {} |
| void vkGetPhysicalDeviceFormatProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, VkFormat format, |
| VkFormatProperties* pFormatProperties) {} |
| void vkGetPhysicalDeviceImageFormatProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, VkFormat format, |
| VkImageType type, VkImageTiling tiling, |
| VkImageUsageFlags usage, VkImageCreateFlags flags, |
| VkImageFormatProperties* pImageFormatProperties) { |
| } |
| void vkGetPhysicalDeviceProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties* pProperties) {} |
| void vkGetPhysicalDeviceQueueFamilyProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {} |
| void vkGetPhysicalDeviceMemoryProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) {} |
| void vkGetInstanceProcAddr(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, PFN_vkVoidFunction input_result, |
| VkInstance instance, const char* pName) {} |
| void vkGetDeviceProcAddr(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| PFN_vkVoidFunction input_result, VkDevice device, const char* pName) {} |
| void vkCreateDevice(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkPhysicalDevice physicalDevice, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { |
| if (!pDevice) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pDevice create |
| mReconstruction.addHandles((const uint64_t*)pDevice, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pDevice, 1, |
| (uint64_t)(uintptr_t)physicalDevice); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pDevice, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pDevice, 1); |
| } |
| void vkDestroyDevice(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // device destroy |
| mReconstruction.removeHandles((const uint64_t*)(&device), 1, true); |
| } |
| void vkEnumerateInstanceExtensionProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| const char* pLayerName, uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties) {} |
| void vkEnumerateDeviceExtensionProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, |
| const char* pLayerName, uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties) {} |
| void vkEnumerateInstanceLayerProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties) {} |
| void vkEnumerateDeviceLayerProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties) {} |
| void vkGetDeviceQueue(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) {} |
| void vkQueueSubmit(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, VkFence fence) {} |
| void vkQueueWaitIdle(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue) {} |
| void vkDeviceWaitIdle(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device) {} |
| void vkAllocateMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { |
| if (!pMemory) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pMemory create |
| mReconstruction.addHandles((const uint64_t*)pMemory, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pMemory, 1, |
| (uint64_t)(uintptr_t)device); |
| const VkMemoryDedicatedAllocateInfo* dedicatedAllocateInfo = |
| vk_find_struct<VkMemoryDedicatedAllocateInfo>(pAllocateInfo); |
| if (dedicatedAllocateInfo) { |
| if (dedicatedAllocateInfo->image) { |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pMemory, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage( |
| dedicatedAllocateInfo->image)); |
| } |
| if (dedicatedAllocateInfo->buffer) { |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pMemory, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer( |
| dedicatedAllocateInfo->buffer)); |
| } |
| } |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pMemory, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pMemory, 1); |
| } |
| void vkFreeMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // memory destroy |
| mReconstruction.removeHandles((const uint64_t*)(&memory), 1, true); |
| } |
| void vkMapMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, |
| VkMemoryMapFlags flags, void** ppData) {} |
| void vkUnmapMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDeviceMemory memory) {} |
| void vkFlushMappedMemoryRanges(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) {} |
| void vkInvalidateMappedMemoryRanges(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) {} |
| void vkGetDeviceMemoryCommitment(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes) {} |
| void vkBindBufferMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkBuffer buffer, |
| VkDeviceMemory memory, VkDeviceSize memoryOffset) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkBindMemory); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDeviceMemory(memory)); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)(unboxed_to_boxed_non_dispatchable_VkBuffer(buffer))); |
| } |
| void vkBindImageMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkImage image, |
| VkDeviceMemory memory, VkDeviceSize memoryOffset) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkBindMemory); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDeviceMemory(memory)); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage(image)); |
| } |
| void vkGetBufferMemoryRequirements(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements) {} |
| void vkGetImageMemoryRequirements(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImage image, |
| VkMemoryRequirements* pMemoryRequirements) {} |
| void vkGetImageSparseMemoryRequirements( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {} |
| void vkGetPhysicalDeviceSparseImageFormatProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, |
| VkImageTiling tiling, uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties* pProperties) {} |
| void vkQueueBindSparse(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, VkFence fence) {} |
| void vkCreateFence(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkFence* pFence) { |
| if (!pFence) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pFence create |
| mReconstruction.addHandles((const uint64_t*)pFence, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pFence, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pFence, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pFence, 1); |
| } |
| void vkDestroyFence(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkFence fence, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // fence destroy |
| mReconstruction.removeHandles((const uint64_t*)(&fence), 1, true); |
| } |
| void vkResetFences(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t fenceCount, |
| const VkFence* pFences) {} |
| void vkGetFenceStatus(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkFence fence) {} |
| void vkWaitForFences(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t fenceCount, |
| const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) {} |
| void vkCreateSemaphore(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { |
| if (!pSemaphore) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pSemaphore create |
| mReconstruction.addHandles((const uint64_t*)pSemaphore, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pSemaphore, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pSemaphore, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pSemaphore, 1); |
| } |
| void vkDestroySemaphore(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // semaphore destroy |
| mReconstruction.removeHandles((const uint64_t*)(&semaphore), 1, true); |
| } |
| void vkCreateEvent(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { |
| if (!pEvent) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pEvent create |
| mReconstruction.addHandles((const uint64_t*)pEvent, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pEvent, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pEvent, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pEvent, 1); |
| } |
| void vkDestroyEvent(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkEvent event, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // event destroy |
| mReconstruction.removeHandles((const uint64_t*)(&event), 1, true); |
| } |
| void vkGetEventStatus(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkEvent event) {} |
| void vkSetEvent(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkEvent event) {} |
| void vkResetEvent(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkEvent event) {} |
| void vkCreateQueryPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { |
| if (!pQueryPool) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pQueryPool create |
| mReconstruction.addHandles((const uint64_t*)pQueryPool, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pQueryPool, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pQueryPool, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pQueryPool, 1); |
| } |
| void vkDestroyQueryPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // queryPool destroy |
| mReconstruction.removeHandles((const uint64_t*)(&queryPool), 1, true); |
| } |
| void vkGetQueryPoolResults(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, |
| size_t dataSize, void* pData, VkDeviceSize stride, |
| VkQueryResultFlags flags) {} |
| void vkCreateBuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { |
| if (!pBuffer) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pBuffer create |
| mReconstruction.addHandles((const uint64_t*)pBuffer, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pBuffer, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pBuffer, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pBuffer, 1); |
| } |
| void vkDestroyBuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // buffer destroy |
| mReconstruction.removeHandles((const uint64_t*)(&buffer), 1, true); |
| } |
| void vkCreateBufferView(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { |
| if (!pView) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pView create |
| mReconstruction.addHandles((const uint64_t*)pView, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pView, 1, (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pView, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pView, 1); |
| } |
| void vkDestroyBufferView(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // bufferView destroy |
| mReconstruction.removeHandles((const uint64_t*)(&bufferView), 1, true); |
| } |
| void vkCreateImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkImage* pImage) { |
| if (!pImage) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pImage create |
| mReconstruction.addHandles((const uint64_t*)pImage, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pImage, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pImage, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pImage, 1); |
| } |
| void vkDestroyImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkImage image, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // image destroy |
| mReconstruction.removeHandles((const uint64_t*)(&image), 1, true); |
| } |
| void vkGetImageSubresourceLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImage image, |
| const VkImageSubresource* pSubresource, |
| VkSubresourceLayout* pLayout) {} |
| void vkCreateImageView(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkImageView* pView) { |
| if (!pView) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pView create |
| mReconstruction.addHandles((const uint64_t*)pView, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pView, 1, (uint64_t)(uintptr_t)device); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pView, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage(pCreateInfo->image)); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pView, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pView, 1); |
| } |
| void vkDestroyImageView(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkImageView imageView, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // imageView destroy |
| mReconstruction.removeHandles((const uint64_t*)(&imageView), 1, true); |
| } |
| void vkCreateShaderModule(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule) { |
| if (!pShaderModule) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pShaderModule create |
| mReconstruction.addHandles((const uint64_t*)pShaderModule, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pShaderModule, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pShaderModule, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pShaderModule, 1); |
| } |
| void vkDestroyShaderModule(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // shaderModule destroy |
| mReconstruction.removeHandles((const uint64_t*)(&shaderModule), 1, false); |
| } |
| void vkCreatePipelineCache(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache) { |
| if (!pPipelineCache) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pPipelineCache create |
| mReconstruction.addHandles((const uint64_t*)pPipelineCache, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pPipelineCache, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelineCache, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pPipelineCache, 1); |
| } |
| void vkDestroyPipelineCache(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pipelineCache destroy |
| mReconstruction.removeHandles((const uint64_t*)(&pipelineCache), 1, true); |
| } |
| void vkGetPipelineCacheData(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {} |
| void vkMergePipelineCaches(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkPipelineCache dstCache, uint32_t srcCacheCount, |
| const VkPipelineCache* pSrcCaches) {} |
| void vkCreateGraphicsPipelines(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkPipelineCache pipelineCache, uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) { |
| if (!pPipelines) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pPipelines create |
| mReconstruction.addHandles((const uint64_t*)pPipelines, createInfoCount); |
| mReconstruction.addHandleDependency((const uint64_t*)pPipelines, createInfoCount, |
| (uint64_t)(uintptr_t)device); |
| for (uint32_t i = 0; i < createInfoCount; ++i) { |
| for (uint32_t j = 0; j < pCreateInfos[i].stageCount; ++j) { |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(pPipelines + i), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkShaderModule( |
| pCreateInfos[i].pStages[j].module)); |
| } |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(pPipelines + i), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkRenderPass( |
| pCreateInfos[i].renderPass)); |
| } |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelines, createInfoCount, |
| apiCallHandle, VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pPipelines, |
| createInfoCount); |
| } |
| void vkCreateComputePipelines(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkPipelineCache pipelineCache, uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, |
| const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { |
| if (!pPipelines) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pPipelines create |
| mReconstruction.addHandles((const uint64_t*)pPipelines, createInfoCount); |
| mReconstruction.addHandleDependency((const uint64_t*)pPipelines, createInfoCount, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelines, createInfoCount, |
| apiCallHandle, VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pPipelines, |
| createInfoCount); |
| } |
| void vkDestroyPipeline(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pipeline destroy |
| mReconstruction.removeHandles((const uint64_t*)(&pipeline), 1, true); |
| } |
| void vkCreatePipelineLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout) { |
| if (!pPipelineLayout) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pPipelineLayout create |
| mReconstruction.addHandles((const uint64_t*)pPipelineLayout, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pPipelineLayout, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelineLayout, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pPipelineLayout, 1); |
| } |
| void vkDestroyPipelineLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pipelineLayout destroy |
| mReconstruction.removeHandles((const uint64_t*)(&pipelineLayout), 1, true); |
| } |
| void vkCreateSampler(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { |
| if (!pSampler) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pSampler create |
| mReconstruction.addHandles((const uint64_t*)pSampler, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pSampler, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pSampler, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pSampler, 1); |
| } |
| void vkDestroySampler(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkSampler sampler, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // sampler destroy |
| mReconstruction.removeHandles((const uint64_t*)(&sampler), 1, true); |
| } |
| void vkCreateDescriptorSetLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout) { |
| if (!pSetLayout) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pSetLayout create |
| mReconstruction.addHandles((const uint64_t*)pSetLayout, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pSetLayout, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pSetLayout, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pSetLayout, 1); |
| } |
| void vkDestroyDescriptorSetLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // descriptorSetLayout destroy |
| mReconstruction.removeHandles((const uint64_t*)(&descriptorSetLayout), 1, true); |
| } |
| void vkCreateDescriptorPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool) { |
| if (!pDescriptorPool) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pDescriptorPool create |
| mReconstruction.addHandles((const uint64_t*)pDescriptorPool, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pDescriptorPool, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorPool, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pDescriptorPool, 1); |
| } |
| void vkDestroyDescriptorPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // descriptorPool destroy |
| mReconstruction.removeHandles((const uint64_t*)(&descriptorPool), 1, true); |
| } |
| void vkResetDescriptorPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {} |
| void vkAllocateDescriptorSets(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, |
| VkDescriptorSet* pDescriptorSets) { |
| if (!pDescriptorSets) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pDescriptorSets create |
| mReconstruction.addHandles((const uint64_t*)pDescriptorSets, |
| pAllocateInfo->descriptorSetCount); |
| mReconstruction.addHandleDependency((const uint64_t*)pDescriptorSets, |
| pAllocateInfo->descriptorSetCount, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pDescriptorSets, pAllocateInfo->descriptorSetCount, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDescriptorPool( |
| pAllocateInfo->descriptorPool)); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorSets, |
| pAllocateInfo->descriptorSetCount, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pDescriptorSets, |
| pAllocateInfo->descriptorSetCount); |
| } |
| void vkFreeDescriptorSets(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pDescriptorSets destroy |
| mReconstruction.removeHandles((const uint64_t*)pDescriptorSets, descriptorSetCount, true); |
| } |
| void vkUpdateDescriptorSets(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, |
| const VkCopyDescriptorSet* pDescriptorCopies) {} |
| void vkCreateFramebuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { |
| if (!pFramebuffer) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pFramebuffer create |
| mReconstruction.addHandles((const uint64_t*)pFramebuffer, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pFramebuffer, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pFramebuffer, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkRenderPass( |
| pCreateInfo->renderPass)); |
| if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0) { |
| for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) { |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pFramebuffer, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImageView( |
| pCreateInfo->pAttachments[i])); |
| } |
| } |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pFramebuffer, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pFramebuffer, 1); |
| } |
| void vkDestroyFramebuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // framebuffer destroy |
| mReconstruction.removeHandles((const uint64_t*)(&framebuffer), 1, true); |
| } |
| void vkCreateRenderPass(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { |
| if (!pRenderPass) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pRenderPass create |
| mReconstruction.addHandles((const uint64_t*)pRenderPass, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pRenderPass, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pRenderPass, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pRenderPass, 1); |
| } |
| void vkDestroyRenderPass(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // renderPass destroy |
| mReconstruction.removeHandles((const uint64_t*)(&renderPass), 1, true); |
| } |
| void vkGetRenderAreaGranularity(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkRenderPass renderPass, |
| VkExtent2D* pGranularity) {} |
| void vkCreateCommandPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { |
| if (!pCommandPool) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pCommandPool create |
| mReconstruction.addHandles((const uint64_t*)pCommandPool, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pCommandPool, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pCommandPool, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pCommandPool, 1); |
| } |
| void vkDestroyCommandPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // commandPool destroy |
| mReconstruction.removeHandles((const uint64_t*)(&commandPool), 1, true); |
| } |
| void vkResetCommandPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.removeGrandChildren( |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkCommandPool(commandPool)); |
| } |
| void vkAllocateCommandBuffers(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers) { |
| if (!pCommandBuffers) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pCommandBuffers create |
| mReconstruction.addHandles((const uint64_t*)pCommandBuffers, |
| pAllocateInfo->commandBufferCount); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)pCommandBuffers, pAllocateInfo->commandBufferCount, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkCommandPool( |
| pAllocateInfo->commandPool)); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pCommandBuffers, |
| pAllocateInfo->commandBufferCount, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pCommandBuffers, |
| pAllocateInfo->commandBufferCount); |
| } |
| void vkFreeCommandBuffers(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, VkCommandPool commandPool, |
| uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pCommandBuffers destroy |
| mReconstruction.removeHandles((const uint64_t*)pCommandBuffers, commandBufferCount, true); |
| } |
| void vkBeginCommandBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // commandBuffer modify |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| for (uint32_t i = 0; i < 1; ++i) { |
| // commandBuffer is already boxed, no need to box again |
| VkCommandBuffer boxed = VkCommandBuffer((&commandBuffer)[i]); |
| mReconstruction.forEachHandleAddModifyApi((const uint64_t*)(&boxed), 1, apiCallHandle); |
| } |
| } |
| void vkEndCommandBuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkCommandBuffer commandBuffer) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // commandBuffer modify |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| for (uint32_t i = 0; i < 1; ++i) { |
| // commandBuffer is already boxed, no need to box again |
| VkCommandBuffer boxed = VkCommandBuffer((&commandBuffer)[i]); |
| mReconstruction.forEachHandleAddModifyApi((const uint64_t*)(&boxed), 1, apiCallHandle); |
| } |
| } |
| void vkResetCommandBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.removeDescendantsOfHandle((uint64_t)(uintptr_t)commandBuffer); |
| } |
| void vkCmdBindPipeline(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkPipeline(pipeline)); |
| } |
| void vkCmdSetViewport(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstViewport, |
| uint32_t viewportCount, const VkViewport* pViewports) {} |
| void vkCmdSetScissor(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstScissor, |
| uint32_t scissorCount, const VkRect2D* pScissors) {} |
| void vkCmdSetLineWidth(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, float lineWidth) {} |
| void vkCmdSetDepthBias(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, float depthBiasConstantFactor, |
| float depthBiasClamp, float depthBiasSlopeFactor) {} |
| void vkCmdSetBlendConstants(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const float blendConstants[4]) {} |
| void vkCmdSetDepthBounds(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, float minDepthBounds, |
| float maxDepthBounds) {} |
| void vkCmdSetStencilCompareMask(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, |
| uint32_t compareMask) {} |
| void vkCmdSetStencilWriteMask(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, |
| uint32_t writeMask) {} |
| void vkCmdSetStencilReference(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, |
| uint32_t reference) {} |
| void vkCmdBindDescriptorSets(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, |
| uint32_t firstSet, uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {} |
| void vkCmdBindIndexBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {} |
| void vkCmdBindVertexBuffers(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, uint32_t bindingCount, |
| const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| for (uint32_t i = 0; i < bindingCount; ++i) { |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer(pBuffers[i])); |
| } |
| } |
| void vkCmdDraw(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, |
| uint32_t firstVertex, uint32_t firstInstance) {} |
| void vkCmdDrawIndexed(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t indexCount, |
| uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, |
| uint32_t firstInstance) {} |
| void vkCmdDrawIndirect(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, |
| uint32_t drawCount, uint32_t stride) {} |
| void vkCmdDrawIndexedIndirect(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, |
| VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {} |
| void vkCmdDispatch(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, |
| uint32_t groupCountZ) {} |
| void vkCmdDispatchIndirect(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset) {} |
| void vkCmdCopyBuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, |
| uint32_t regionCount, const VkBufferCopy* pRegions) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer(srcBuffer)); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer(dstBuffer)); |
| } |
| void vkCmdCopyImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage srcImage, |
| VkImageLayout srcImageLayout, VkImage dstImage, |
| VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkImageCopy* pRegions) {} |
| void vkCmdBlitImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage srcImage, |
| VkImageLayout srcImageLayout, VkImage dstImage, |
| VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkImageBlit* pRegions, VkFilter filter) {} |
| void vkCmdCopyBufferToImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, |
| uint32_t regionCount, const VkBufferImageCopy* pRegions) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer(srcBuffer)); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage(dstImage)); |
| } |
| void vkCmdCopyImageToBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, |
| uint32_t regionCount, const VkBufferImageCopy* pRegions) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage(srcImage)); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer(dstBuffer)); |
| } |
| void vkCmdUpdateBuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) {} |
| void vkCmdFillBuffer(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, |
| VkDeviceSize size, uint32_t data) {} |
| void vkCmdClearColorImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkImage image, VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) {} |
| void vkCmdClearDepthStencilImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {} |
| void vkCmdClearAttachments(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, const VkClearAttachment* pAttachments, |
| uint32_t rectCount, const VkClearRect* pRects) {} |
| void vkCmdResolveImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage srcImage, |
| VkImageLayout srcImageLayout, VkImage dstImage, |
| VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkImageResolve* pRegions) {} |
| void vkCmdSetEvent(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags stageMask) {} |
| void vkCmdResetEvent(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags stageMask) {} |
| void vkCmdWaitEvents(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| 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 vkCmdPipelineBarrier(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, |
| VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, |
| const VkMemoryBarrier* pMemoryBarriers, |
| uint32_t bufferMemoryBarrierCount, |
| const VkBufferMemoryBarrier* pBufferMemoryBarriers, |
| uint32_t imageMemoryBarrierCount, |
| const VkImageMemoryBarrier* pImageMemoryBarriers) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| for (uint32_t i = 0; i < bufferMemoryBarrierCount; ++i) { |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkBuffer( |
| pBufferMemoryBarriers[i].buffer)); |
| } |
| for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) { |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage( |
| pImageMemoryBarriers[i].image)); |
| } |
| } |
| void vkCmdBeginQuery(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, |
| VkQueryControlFlags flags) {} |
| void vkCmdEndQuery(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {} |
| void vkCmdResetQueryPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t firstQuery, uint32_t queryCount) {} |
| void vkCmdWriteTimestamp(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, uint32_t query) {} |
| void vkCmdCopyQueryPoolResults(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, VkDeviceSize stride, |
| VkQueryResultFlags flags) {} |
| void vkCmdPushConstants(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, |
| const void* pValues) {} |
| void vkCmdBeginRenderPass(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkFramebuffer( |
| pRenderPassBegin->framebuffer)); |
| } |
| void vkCmdNextSubpass(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkSubpassContents contents) {} |
| void vkCmdEndRenderPass(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) {} |
| void vkCmdExecuteCommands(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void vkEnumerateInstanceVersion(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, uint32_t* pApiVersion) {} |
| void vkBindBufferMemory2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) {} |
| void vkBindImageMemory2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkBindMemory); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| for (uint32_t i = 0; i < bindInfoCount; ++i) { |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)&handle, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDeviceMemory( |
| pBindInfos[i].memory)); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)&handle, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage( |
| pBindInfos[i].image)); |
| } |
| } |
| void vkGetDeviceGroupPeerMemoryFeatures(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, uint32_t heapIndex, |
| uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {} |
| void vkCmdSetDeviceMask(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t deviceMask) {} |
| void vkCmdDispatchBase(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, |
| uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, |
| uint32_t groupCountZ) {} |
| void vkEnumeratePhysicalDeviceGroups( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {} |
| void vkGetImageMemoryRequirements2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetBufferMemoryRequirements2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetImageSparseMemoryRequirements2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {} |
| void vkGetPhysicalDeviceFeatures2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2* pFeatures) {} |
| void vkGetPhysicalDeviceProperties2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2* pProperties) {} |
| void vkGetPhysicalDeviceFormatProperties2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, VkFormat format, |
| VkFormatProperties2* pFormatProperties) {} |
| void vkGetPhysicalDeviceImageFormatProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, |
| VkImageFormatProperties2* pImageFormatProperties) {} |
| void vkGetPhysicalDeviceQueueFamilyProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {} |
| void vkGetPhysicalDeviceMemoryProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {} |
| void vkGetPhysicalDeviceSparseImageFormatProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties2* pProperties) {} |
| void vkTrimCommandPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkCommandPool commandPool, VkCommandPoolTrimFlags flags) {} |
| void vkGetDeviceQueue2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) {} |
| void vkCreateSamplerYcbcrConversion(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) { |
| if (!pYcbcrConversion) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pYcbcrConversion create |
| mReconstruction.addHandles((const uint64_t*)pYcbcrConversion, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pYcbcrConversion, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pYcbcrConversion, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pYcbcrConversion, |
| 1); |
| } |
| void vkDestroySamplerYcbcrConversion(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // ycbcrConversion destroy |
| mReconstruction.removeHandles((const uint64_t*)(&ycbcrConversion), 1, true); |
| } |
| void vkCreateDescriptorUpdateTemplate(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { |
| if (!pDescriptorUpdateTemplate) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pDescriptorUpdateTemplate create |
| mReconstruction.addHandles((const uint64_t*)pDescriptorUpdateTemplate, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pDescriptorUpdateTemplate, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorUpdateTemplate, 1, |
| apiCallHandle, VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, |
| (const uint64_t*)pDescriptorUpdateTemplate, 1); |
| } |
| void vkDestroyDescriptorUpdateTemplate(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // descriptorUpdateTemplate destroy |
| mReconstruction.removeHandles((const uint64_t*)(&descriptorUpdateTemplate), 1, true); |
| } |
| void vkUpdateDescriptorSetWithTemplate(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) {} |
| void vkGetPhysicalDeviceExternalBufferProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, |
| VkExternalBufferProperties* pExternalBufferProperties) {} |
| void vkGetPhysicalDeviceExternalFenceProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, |
| VkExternalFenceProperties* pExternalFenceProperties) {} |
| void vkGetPhysicalDeviceExternalSemaphoreProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {} |
| void vkGetDescriptorSetLayoutSupport(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) {} |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void vkCmdDrawIndirectCount(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, uint32_t maxDrawCount, |
| uint32_t stride) {} |
| void vkCmdDrawIndexedIndirectCount(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, |
| VkDeviceSize offset, VkBuffer countBuffer, |
| VkDeviceSize countBufferOffset, uint32_t maxDrawCount, |
| uint32_t stride) {} |
| void vkCreateRenderPass2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { |
| if (!pRenderPass) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pRenderPass create |
| mReconstruction.addHandles((const uint64_t*)pRenderPass, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pRenderPass, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pRenderPass, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pRenderPass, 1); |
| } |
| void vkCmdBeginRenderPass2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfo* pSubpassBeginInfo) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| mReconstruction.addApiCallDependencyOnVkObject( |
| apiCallHandle, (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkFramebuffer( |
| pRenderPassBegin->framebuffer)); |
| } |
| void vkCmdNextSubpass2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) {} |
| void vkCmdEndRenderPass2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) {} |
| void vkResetQueryPool(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {} |
| void vkGetSemaphoreCounterValue(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkSemaphore semaphore, |
| uint64_t* pValue) {} |
| void vkWaitSemaphores(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) {} |
| void vkSignalSemaphore(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreSignalInfo* pSignalInfo) {} |
| void vkGetBufferDeviceAddress(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDeviceAddress input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) {} |
| void vkGetBufferOpaqueCaptureAddress(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| uint64_t input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) {} |
| void vkGetDeviceMemoryOpaqueCaptureAddress( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, uint64_t input_result, |
| VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {} |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void vkGetPhysicalDeviceToolProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkPhysicalDevice physicalDevice, |
| uint32_t* pToolCount, |
| VkPhysicalDeviceToolProperties* pToolProperties) {} |
| void vkCreatePrivateDataSlot(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot) { |
| if (!pPrivateDataSlot) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pPrivateDataSlot create |
| mReconstruction.addHandles((const uint64_t*)pPrivateDataSlot, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pPrivateDataSlot, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pPrivateDataSlot, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pPrivateDataSlot, |
| 1); |
| } |
| void vkDestroyPrivateDataSlot(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // privateDataSlot destroy |
| mReconstruction.removeHandles((const uint64_t*)(&privateDataSlot), 1, true); |
| } |
| void vkSetPrivateData(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkObjectType objectType, |
| uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { |
| } |
| void vkGetPrivateData(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkObjectType objectType, uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, uint64_t* pData) {} |
| void vkCmdSetEvent2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) {} |
| void vkCmdResetEvent2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags2 stageMask) {} |
| void vkCmdWaitEvents2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t eventCount, |
| const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {} |
| void vkCmdPipelineBarrier2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) {} |
| void vkCmdWriteTimestamp2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {} |
| void vkQueueSubmit2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, VkFence fence) {} |
| void vkCmdCopyBuffer2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { |
| } |
| void vkCmdCopyImage2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) {} |
| void vkCmdCopyBufferToImage2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {} |
| void vkCmdCopyImageToBuffer2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {} |
| void vkCmdBlitImage2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) {} |
| void vkCmdResolveImage2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) {} |
| void vkCmdBeginRendering(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) { |
| } |
| void vkCmdEndRendering(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) {} |
| void vkCmdSetCullMode(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {} |
| void vkCmdSetFrontFace(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkFrontFace frontFace) {} |
| void vkCmdSetPrimitiveTopology(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) {} |
| void vkCmdSetViewportWithCount(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t viewportCount, |
| const VkViewport* pViewports) {} |
| void vkCmdSetScissorWithCount(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t scissorCount, |
| const VkRect2D* pScissors) {} |
| void vkCmdBindVertexBuffers2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstBinding, |
| uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, |
| const VkDeviceSize* pStrides) {} |
| void vkCmdSetDepthTestEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {} |
| void vkCmdSetDepthWriteEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {} |
| void vkCmdSetDepthCompareOp(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) {} |
| void vkCmdSetDepthBoundsTestEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) {} |
| void vkCmdSetStencilTestEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {} |
| void vkCmdSetStencilOp(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, |
| VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, |
| VkCompareOp compareOp) {} |
| void vkCmdSetRasterizerDiscardEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) {} |
| void vkCmdSetDepthBiasEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {} |
| void vkCmdSetPrimitiveRestartEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) {} |
| void vkGetDeviceBufferMemoryRequirements(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetDeviceImageMemoryRequirements(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetDeviceImageSparseMemoryRequirements( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {} |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void vkCmdSetLineStipple(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, |
| uint16_t lineStipplePattern) {} |
| void vkMapMemory2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) {} |
| void vkUnmapMemory2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkMemoryUnmapInfo* pMemoryUnmapInfo) {} |
| void vkCmdBindIndexBuffer2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, |
| VkIndexType indexType) {} |
| void vkGetRenderingAreaGranularity(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkRenderingAreaInfo* pRenderingAreaInfo, |
| VkExtent2D* pGranularity) {} |
| void vkGetDeviceImageSubresourceLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkDeviceImageSubresourceInfo* pInfo, |
| VkSubresourceLayout2* pLayout) {} |
| void vkGetImageSubresourceLayout2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImage image, |
| const VkImageSubresource2* pSubresource, |
| VkSubresourceLayout2* pLayout) {} |
| void vkCmdPushDescriptorSet(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, |
| uint32_t set, uint32_t descriptorWriteCount, |
| const VkWriteDescriptorSet* pDescriptorWrites) {} |
| void vkCmdPushDescriptorSetWithTemplate(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| VkPipelineLayout layout, uint32_t set, |
| const void* pData) {} |
| void vkCmdSetRenderingAttachmentLocations( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderingAttachmentLocationInfo* pLocationInfo) {} |
| void vkCmdSetRenderingInputAttachmentIndices( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) {} |
| void vkCmdBindDescriptorSets2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) {} |
| void vkCmdPushConstants2(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkPushConstantsInfo* pPushConstantsInfo) {} |
| void vkCmdPushDescriptorSet2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) {} |
| void vkCmdPushDescriptorSetWithTemplate2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) {} |
| void vkCopyMemoryToImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {} |
| void vkCopyImageToMemory(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {} |
| void vkCopyImageToImage(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCopyImageToImageInfo* pCopyImageToImageInfo) {} |
| void vkTransitionImageLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t transitionCount, |
| const VkHostImageLayoutTransitionInfo* pTransitions) {} |
| #endif |
| #ifdef VK_KHR_swapchain |
| void vkCreateSwapchainKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { |
| if (!pSwapchain) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pSwapchain create |
| mReconstruction.addHandles((const uint64_t*)pSwapchain, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pSwapchain, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pSwapchain, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pSwapchain, 1); |
| } |
| void vkDestroySwapchainKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // swapchain destroy |
| mReconstruction.removeHandles((const uint64_t*)(&swapchain), 1, true); |
| } |
| void vkGetSwapchainImagesKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkSwapchainKHR swapchain, |
| uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {} |
| void vkAcquireNextImageKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, |
| VkFence fence, uint32_t* pImageIndex) {} |
| void vkQueuePresentKHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, |
| const VkPresentInfoKHR* pPresentInfo) {} |
| void vkGetDeviceGroupPresentCapabilitiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {} |
| void vkGetDeviceGroupSurfacePresentModesKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkSurfaceKHR surface, |
| VkDeviceGroupPresentModeFlagsKHR* pModes) {} |
| void vkGetPhysicalDevicePresentRectanglesKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, |
| VkSurfaceKHR surface, uint32_t* pRectCount, |
| VkRect2D* pRects) {} |
| void vkAcquireNextImage2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, |
| uint32_t* pImageIndex) {} |
| #endif |
| #ifdef VK_KHR_dynamic_rendering |
| void vkCmdBeginRenderingKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) {} |
| void vkCmdEndRenderingKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer) {} |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void vkGetPhysicalDeviceFeatures2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2* pFeatures) {} |
| void vkGetPhysicalDeviceProperties2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2* pProperties) {} |
| void vkGetPhysicalDeviceFormatProperties2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, VkFormat format, |
| VkFormatProperties2* pFormatProperties) {} |
| void vkGetPhysicalDeviceImageFormatProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, |
| VkImageFormatProperties2* pImageFormatProperties) {} |
| void vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) {} |
| void vkGetPhysicalDeviceMemoryProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {} |
| void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties2* pProperties) {} |
| #endif |
| #ifdef VK_KHR_maintenance1 |
| void vkTrimCommandPoolKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) {} |
| #endif |
| #ifdef VK_KHR_external_memory_capabilities |
| void vkGetPhysicalDeviceExternalBufferPropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, |
| VkExternalBufferProperties* pExternalBufferProperties) {} |
| #endif |
| #ifdef VK_KHR_external_semaphore_capabilities |
| void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {} |
| #endif |
| #ifdef VK_KHR_external_semaphore_fd |
| void vkImportSemaphoreFdKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {} |
| void vkGetSemaphoreFdKHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {} |
| #endif |
| #ifdef VK_KHR_descriptor_update_template |
| void vkCreateDescriptorUpdateTemplateKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { |
| if (!pDescriptorUpdateTemplate) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pDescriptorUpdateTemplate create |
| mReconstruction.addHandles((const uint64_t*)pDescriptorUpdateTemplate, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pDescriptorUpdateTemplate, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorUpdateTemplate, 1, |
| apiCallHandle, VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, |
| (const uint64_t*)pDescriptorUpdateTemplate, 1); |
| } |
| void vkDestroyDescriptorUpdateTemplateKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // descriptorUpdateTemplate destroy |
| mReconstruction.removeHandles((const uint64_t*)(&descriptorUpdateTemplate), 1, true); |
| } |
| void vkUpdateDescriptorSetWithTemplateKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorSet descriptorSet, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) {} |
| #endif |
| #ifdef VK_KHR_create_renderpass2 |
| void vkCreateRenderPass2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) { |
| if (!pRenderPass) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pRenderPass create |
| mReconstruction.addHandles((const uint64_t*)pRenderPass, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pRenderPass, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pRenderPass, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pRenderPass, 1); |
| } |
| void vkCmdBeginRenderPass2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| const VkSubpassBeginInfo* pSubpassBeginInfo) {} |
| void vkCmdNextSubpass2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) {} |
| void vkCmdEndRenderPass2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) {} |
| #endif |
| #ifdef VK_KHR_external_fence_capabilities |
| void vkGetPhysicalDeviceExternalFencePropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, |
| VkExternalFenceProperties* pExternalFenceProperties) {} |
| #endif |
| #ifdef VK_KHR_external_fence_fd |
| void vkImportFenceFdKHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {} |
| void vkGetFenceFdKHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {} |
| #endif |
| #ifdef VK_KHR_get_memory_requirements2 |
| void vkGetImageMemoryRequirements2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetBufferMemoryRequirements2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetImageSparseMemoryRequirements2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {} |
| #endif |
| #ifdef VK_KHR_sampler_ycbcr_conversion |
| void vkCreateSamplerYcbcrConversionKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) { |
| if (!pYcbcrConversion) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pYcbcrConversion create |
| mReconstruction.addHandles((const uint64_t*)pYcbcrConversion, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pYcbcrConversion, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pYcbcrConversion, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pYcbcrConversion, |
| 1); |
| } |
| void vkDestroySamplerYcbcrConversionKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // ycbcrConversion destroy |
| mReconstruction.removeHandles((const uint64_t*)(&ycbcrConversion), 1, true); |
| } |
| #endif |
| #ifdef VK_KHR_bind_memory2 |
| void vkBindBufferMemory2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) {} |
| void vkBindImageMemory2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkBindMemory); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| for (uint32_t i = 0; i < bindInfoCount; ++i) { |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)&handle, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDeviceMemory( |
| pBindInfos[i].memory)); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)&handle, 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkImage( |
| pBindInfos[i].image)); |
| } |
| } |
| #endif |
| #ifdef VK_KHR_maintenance3 |
| void vkGetDescriptorSetLayoutSupportKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, |
| VkDescriptorSetLayoutSupport* pSupport) {} |
| #endif |
| #ifdef VK_KHR_buffer_device_address |
| void vkGetBufferDeviceAddressKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDeviceAddress input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) {} |
| void vkGetBufferOpaqueCaptureAddressKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| uint64_t input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) {} |
| void vkGetDeviceMemoryOpaqueCaptureAddressKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, uint64_t input_result, |
| VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {} |
| #endif |
| #ifdef VK_KHR_pipeline_executable_properties |
| void vkGetPipelineExecutablePropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, |
| VkPipelineExecutablePropertiesKHR* pProperties) {} |
| void vkGetPipelineExecutableStatisticsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) {} |
| void vkGetPipelineExecutableInternalRepresentationsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, |
| uint32_t* pInternalRepresentationCount, |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {} |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void vkCmdSetEvent2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) {} |
| void vkCmdResetEvent2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags2 stageMask) {} |
| void vkCmdWaitEvents2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t eventCount, |
| const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) {} |
| void vkCmdPipelineBarrier2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) {} |
| void vkCmdWriteTimestamp2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, |
| VkQueryPool queryPool, uint32_t query) {} |
| void vkQueueSubmit2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, VkFence fence) {} |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void vkCmdCopyBuffer2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) {} |
| void vkCmdCopyImage2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { |
| } |
| void vkCmdCopyBufferToImage2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {} |
| void vkCmdCopyImageToBuffer2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {} |
| void vkCmdBlitImage2KHR(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { |
| } |
| void vkCmdResolveImage2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) {} |
| #endif |
| #ifdef VK_KHR_maintenance4 |
| void vkGetDeviceBufferMemoryRequirementsKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetDeviceImageMemoryRequirementsKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) {} |
| void vkGetDeviceImageSparseMemoryRequirementsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {} |
| #endif |
| #ifdef VK_KHR_maintenance5 |
| void vkCmdBindIndexBuffer2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, |
| VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) {} |
| void vkGetRenderingAreaGranularityKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, |
| const VkRenderingAreaInfo* pRenderingAreaInfo, |
| VkExtent2D* pGranularity) {} |
| void vkGetDeviceImageSubresourceLayoutKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageSubresourceInfo* pInfo, |
| VkSubresourceLayout2* pLayout) {} |
| void vkGetImageSubresourceLayout2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImage image, |
| const VkImageSubresource2* pSubresource, |
| VkSubresourceLayout2* pLayout) {} |
| #endif |
| #ifdef VK_KHR_line_rasterization |
| void vkCmdSetLineStippleKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, uint16_t lineStipplePattern) {} |
| #endif |
| #ifdef VK_ANDROID_native_buffer |
| void vkGetSwapchainGrallocUsageANDROID(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkFormat format, |
| VkImageUsageFlags imageUsage, int* grallocUsage) {} |
| void vkAcquireImageANDROID(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkImage image, int nativeFenceFd, VkSemaphore semaphore, |
| VkFence fence) {} |
| void vkQueueSignalReleaseImageANDROID(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, |
| uint32_t waitSemaphoreCount, |
| const VkSemaphore* pWaitSemaphores, VkImage image, |
| int* pNativeFenceFd) {} |
| void vkGetSwapchainGrallocUsage2ANDROID(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkFormat format, |
| VkImageUsageFlags imageUsage, |
| VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, |
| uint64_t* grallocConsumerUsage, |
| uint64_t* grallocProducerUsage) {} |
| #endif |
| #ifdef VK_EXT_debug_report |
| void vkCreateDebugReportCallbackEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkInstance instance, |
| const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugReportCallbackEXT* pCallback) { |
| if (!pCallback) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pCallback create |
| mReconstruction.addHandles((const uint64_t*)pCallback, 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pCallback, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pCallback, 1); |
| } |
| void vkDestroyDebugReportCallbackEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkInstance instance, VkDebugReportCallbackEXT callback, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // callback destroy |
| mReconstruction.removeHandles((const uint64_t*)(&callback), 1, true); |
| } |
| void vkDebugReportMessageEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkInstance instance, VkDebugReportFlagsEXT flags, |
| VkDebugReportObjectTypeEXT objectType, uint64_t object, |
| size_t location, int32_t messageCode, const char* pLayerPrefix, |
| const char* pMessage) {} |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void vkCmdBindTransformFeedbackBuffersEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {} |
| void vkCmdBeginTransformFeedbackEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, |
| const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) {} |
| void vkCmdEndTransformFeedbackEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, |
| uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) {} |
| void vkCmdBeginQueryIndexedEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t query, VkQueryControlFlags flags, uint32_t index) {} |
| void vkCmdEndQueryIndexedEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t query, uint32_t index) {} |
| void vkCmdDrawIndirectByteCountEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t instanceCount, |
| uint32_t firstInstance, VkBuffer counterBuffer, |
| VkDeviceSize counterBufferOffset, uint32_t counterOffset, |
| uint32_t vertexStride) {} |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void vkSetDebugUtilsObjectNameEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {} |
| void vkSetDebugUtilsObjectTagEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {} |
| void vkQueueBeginDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {} |
| void vkQueueEndDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue) {} |
| void vkQueueInsertDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {} |
| void vkCmdBeginDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) {} |
| void vkCmdEndDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) {} |
| void vkCmdInsertDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) {} |
| void vkCreateDebugUtilsMessengerEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkInstance instance, |
| const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDebugUtilsMessengerEXT* pMessenger) { |
| if (!pMessenger) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pMessenger create |
| mReconstruction.addHandles((const uint64_t*)pMessenger, 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pMessenger, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pMessenger, 1); |
| } |
| void vkDestroyDebugUtilsMessengerEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkInstance instance, VkDebugUtilsMessengerEXT messenger, |
| const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // messenger destroy |
| mReconstruction.removeHandles((const uint64_t*)(&messenger), 1, true); |
| } |
| void vkSubmitDebugUtilsMessageEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {} |
| #endif |
| #ifdef VK_EXT_image_drm_format_modifier |
| void vkGetImageDrmFormatModifierPropertiesEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) {} |
| #endif |
| #ifdef VK_EXT_external_memory_host |
| void vkGetMemoryHostPointerPropertiesEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) {} |
| #endif |
| #ifdef VK_EXT_tooling_info |
| void vkGetPhysicalDeviceToolPropertiesEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, uint32_t* pToolCount, |
| VkPhysicalDeviceToolProperties* pToolProperties) {} |
| #endif |
| #ifdef VK_EXT_line_rasterization |
| void vkCmdSetLineStippleEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, uint16_t lineStipplePattern) {} |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void vkCmdSetCullModeEXT(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {} |
| void vkCmdSetFrontFaceEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkFrontFace frontFace) {} |
| void vkCmdSetPrimitiveTopologyEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) {} |
| void vkCmdSetViewportWithCountEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t viewportCount, |
| const VkViewport* pViewports) {} |
| void vkCmdSetScissorWithCountEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t scissorCount, |
| const VkRect2D* pScissors) {} |
| void vkCmdBindVertexBuffers2EXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstBinding, |
| uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, |
| const VkDeviceSize* pStrides) {} |
| void vkCmdSetDepthTestEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {} |
| void vkCmdSetDepthWriteEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) {} |
| void vkCmdSetDepthCompareOpEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) {} |
| void vkCmdSetDepthBoundsTestEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) {} |
| void vkCmdSetStencilTestEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) {} |
| void vkCmdSetStencilOpEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, |
| VkStencilOp depthFailOp, VkCompareOp compareOp) {} |
| #endif |
| #ifdef VK_EXT_host_image_copy |
| void vkCopyMemoryToImageEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) {} |
| void vkCopyImageToMemoryEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) {} |
| void vkCopyImageToImageEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkCopyImageToImageInfo* pCopyImageToImageInfo) {} |
| void vkTransitionImageLayoutEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| uint32_t transitionCount, |
| const VkHostImageLayoutTransitionInfo* pTransitions) {} |
| void vkGetImageSubresourceLayout2EXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImage image, |
| const VkImageSubresource2* pSubresource, |
| VkSubresourceLayout2* pLayout) {} |
| #endif |
| #ifdef VK_EXT_swapchain_maintenance1 |
| void vkReleaseSwapchainImagesEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {} |
| #endif |
| #ifdef VK_EXT_private_data |
| void vkCreatePrivateDataSlotEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot) {} |
| void vkDestroyPrivateDataSlotEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) {} |
| void vkSetPrivateDataEXT(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkObjectType objectType, |
| uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, |
| uint64_t data) {} |
| void vkGetPrivateDataEXT(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkObjectType objectType, uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, uint64_t* pData) {} |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state2 |
| void vkCmdSetPatchControlPointsEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t patchControlPoints) { |
| } |
| void vkCmdSetRasterizerDiscardEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) {} |
| void vkCmdSetDepthBiasEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {} |
| void vkCmdSetLogicOpEXT(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkLogicOp logicOp) {} |
| void vkCmdSetPrimitiveRestartEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) {} |
| #endif |
| #ifdef VK_EXT_color_write_enable |
| void vkCmdSetColorWriteEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t attachmentCount, |
| const VkBool32* pColorWriteEnables) {} |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void vkMapMemoryIntoAddressSpaceGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkDeviceMemory memory, uint64_t* pAddress) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkMapMemory); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDeviceMemory(memory)); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| } |
| void vkUpdateDescriptorSetWithTemplateSizedGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, 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) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| if (m_state->batchedDescriptorSetUpdateEnabled()) { |
| return; |
| } |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkUpdateDescriptorSets); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.addHandleDependency((const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| } |
| void vkBeginCommandBufferAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo) {} |
| void vkEndCommandBufferAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) {} |
| void vkResetCommandBufferAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags) {} |
| void vkCommandBufferHostSyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t needHostSync, |
| uint32_t sequenceNumber) {} |
| void vkCreateImageWithRequirementsGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImage* pImage, |
| VkMemoryRequirements* pMemoryRequirements) { |
| if (!pImage) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pImage create |
| mReconstruction.addHandles((const uint64_t*)pImage, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pImage, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pImage, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pImage, 1); |
| } |
| void vkCreateBufferWithRequirementsGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, |
| VkMemoryRequirements* pMemoryRequirements) { |
| if (!pBuffer) return; |
| if (input_result != VK_SUCCESS) return; |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // pBuffer create |
| mReconstruction.addHandles((const uint64_t*)pBuffer, 1); |
| mReconstruction.addHandleDependency((const uint64_t*)pBuffer, 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)pBuffer, 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)pBuffer, 1); |
| } |
| void vkGetMemoryHostAddressInfoGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkDeviceMemory memory, uint64_t* pAddress, |
| uint64_t* pSize, uint64_t* pHostmemId) {} |
| void vkFreeMemorySyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| // memory destroy |
| mReconstruction.removeHandles((const uint64_t*)(&memory), 1, true); |
| } |
| void vkQueueHostSyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, uint32_t needHostSync, |
| uint32_t sequenceNumber) {} |
| void vkQueueSubmitAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, |
| VkFence fence) {} |
| void vkQueueWaitIdleAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue) {} |
| void vkQueueBindSparseAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue, uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, VkFence fence) {} |
| void vkGetLinearImageLayoutGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkFormat format, VkDeviceSize* pOffset, |
| VkDeviceSize* pRowPitchAlignment) {} |
| void vkGetLinearImageLayout2GOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, const VkImageCreateInfo* pCreateInfo, |
| VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment) {} |
| void vkQueueFlushCommandsGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue, VkCommandBuffer commandBuffer, |
| VkDeviceSize dataSize, const void* pData) { |
| // Note: special implementation |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkCmdOp); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.removeDescendantsOfHandle((uint64_t)(uintptr_t)commandBuffer); |
| mReconstruction.addHandleDependency((const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)commandBuffer); |
| // Track that `handle` depends on previously tracked dependencies (e.g. the handle for this |
| // `vkQueueFlushCommandsGOOGLE()` call depends on the `VkPipeline` handle from |
| // `vkCmdBindPipeline()`). |
| mReconstruction.addHandleDependenciesForApiCallDependencies(apiCallHandle, handle); |
| } |
| void vkQueueCommitDescriptorSetUpdatesGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkQueue queue, |
| uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools, |
| uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts, |
| const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool, |
| const uint32_t* pDescriptorSetPendingAllocation, |
| const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount, |
| const VkWriteDescriptorSet* pPendingDescriptorWrites) {} |
| void vkCollectDescriptorPoolIdsGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDescriptorPool descriptorPool, |
| uint32_t* pPoolIdCount, uint64_t* pPoolIds) {} |
| void vkQueueSignalReleaseImageANDROIDAsyncGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkQueue queue, |
| uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image) {} |
| void vkQueueFlushCommandsFromAuxMemoryGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| VkCommandBuffer commandBuffer, |
| VkDeviceMemory deviceMemory, |
| VkDeviceSize dataOffset, VkDeviceSize dataSize) {} |
| void vkGetBlobGOOGLE(gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkDeviceMemory memory) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkMapMemory); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.addHandleDependency( |
| (const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)unboxed_to_boxed_non_dispatchable_VkDeviceMemory(memory)); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| } |
| void vkUpdateDescriptorSetWithTemplateSized2GOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, 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) { |
| std::lock_guard<std::mutex> lock(mReconstructionMutex); |
| VkDecoderGlobalState* m_state = VkDecoderGlobalState::get(); |
| if (m_state->batchedDescriptorSetUpdateEnabled()) { |
| return; |
| } |
| uint64_t handle = m_state->newGlobalVkGenericHandle(Tag_VkUpdateDescriptorSets); |
| mReconstruction.addHandles((const uint64_t*)(&handle), 1); |
| mReconstruction.setApiTrace(apiCallHandle, apiCallPacket, apiCallPacketSize); |
| mReconstruction.addHandleDependency((const uint64_t*)(&handle), 1, |
| (uint64_t)(uintptr_t)device); |
| mReconstruction.forEachHandleAddApi((const uint64_t*)(&handle), 1, apiCallHandle, |
| VkReconstruction::CREATED); |
| mReconstruction.setCreatedHandlesForApi(apiCallHandle, (const uint64_t*)(&handle), 1); |
| } |
| void vkQueueSubmitAsync2GOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkQueue queue, uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, VkFence fence) {} |
| void vkGetSemaphoreGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkSemaphore semaphore, uint64_t syncId) {} |
| #endif |
| private: |
| std::mutex mReconstructionMutex; |
| VkReconstruction mReconstruction GUARDED_BY(mReconstructionMutex); |
| }; |
| |
| VkDecoderSnapshot::VkDecoderSnapshot() : mImpl(new VkDecoderSnapshot::Impl()) {} |
| |
| void VkDecoderSnapshot::clear() { mImpl->clear(); } |
| |
| void VkDecoderSnapshot::saveReplayBuffers(gfxstream::Stream* stream) { |
| mImpl->saveReplayBuffers(stream); |
| } |
| |
| /*static*/ |
| void VkDecoderSnapshot::loadReplayBuffers(gfxstream::Stream* stream, |
| std::vector<uint64_t>* outHandleBuffer, |
| std::vector<uint8_t>* outDecoderBuffer) { |
| VkDecoderSnapshot::Impl::loadReplayBuffers(stream, outHandleBuffer, outDecoderBuffer); |
| } |
| |
| VkSnapshotApiCallHandle VkDecoderSnapshot::createApiCallInfo() { |
| return mImpl->createApiCallInfo(); |
| } |
| |
| void VkDecoderSnapshot::destroyApiCallInfoIfUnused(VkSnapshotApiCallHandle handle) { |
| mImpl->destroyApiCallInfoIfUnused(handle); |
| } |
| |
| void VkDecoderSnapshot::addOrderedBoxedHandlesCreatedByCall(VkSnapshotApiCallHandle apiCallHandle, |
| VkObjectHandle* boxedHandles, |
| uint32_t boxedHandlesCount) { |
| mImpl->addOrderedBoxedHandlesCreatedByCall(apiCallHandle, boxedHandles, boxedHandlesCount); |
| } |
| |
| VkDecoderSnapshot::~VkDecoderSnapshot() = default; |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateInstance(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, |
| const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance) { |
| mImpl->vkCreateInstance(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| pCreateInfo, pAllocator, pInstance); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyInstance(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyInstance(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, instance, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkEnumeratePhysicalDevices( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { |
| mImpl->vkEnumeratePhysicalDevices(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, instance, pPhysicalDeviceCount, |
| pPhysicalDevices); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceFeatures(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures* pFeatures) { |
| mImpl->vkGetPhysicalDeviceFeatures(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| physicalDevice, pFeatures); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceFormatProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkFormat format, VkFormatProperties* pFormatProperties) { |
| mImpl->vkGetPhysicalDeviceFormatProperties(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, physicalDevice, format, |
| pFormatProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceImageFormatProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, |
| VkImageUsageFlags usage, VkImageCreateFlags flags, |
| VkImageFormatProperties* pImageFormatProperties) { |
| mImpl->vkGetPhysicalDeviceImageFormatProperties( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, physicalDevice, format, |
| type, tiling, usage, flags, pImageFormatProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceProperties(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties* pProperties) { |
| mImpl->vkGetPhysicalDeviceProperties(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| physicalDevice, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceQueueFamilyProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { |
| mImpl->vkGetPhysicalDeviceQueueFamilyProperties( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, |
| pQueueFamilyPropertyCount, pQueueFamilyProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceMemoryProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) { |
| mImpl->vkGetPhysicalDeviceMemoryProperties( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pMemoryProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetInstanceProcAddr(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| PFN_vkVoidFunction input_result, VkInstance instance, |
| const char* pName) { |
| mImpl->vkGetInstanceProcAddr(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, instance, pName); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetDeviceProcAddr(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| PFN_vkVoidFunction input_result, VkDevice device, |
| const char* pName) { |
| mImpl->vkGetDeviceProcAddr(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pName); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateDevice(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkPhysicalDevice physicalDevice, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { |
| mImpl->vkCreateDevice(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| physicalDevice, pCreateInfo, pAllocator, pDevice); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyDevice(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDevice(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkEnumerateInstanceExtensionProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { |
| mImpl->vkEnumerateInstanceExtensionProperties(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, pLayerName, |
| pPropertyCount, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkEnumerateDeviceExtensionProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties) { |
| mImpl->vkEnumerateDeviceExtensionProperties(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, physicalDevice, |
| pLayerName, pPropertyCount, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkEnumerateInstanceLayerProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| uint32_t* pPropertyCount, VkLayerProperties* pProperties) { |
| mImpl->vkEnumerateInstanceLayerProperties(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, pPropertyCount, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkEnumerateDeviceLayerProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { |
| mImpl->vkEnumerateDeviceLayerProperties(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, physicalDevice, pPropertyCount, |
| pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetDeviceQueue(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, uint32_t queueFamilyIndex, |
| uint32_t queueIndex, VkQueue* pQueue) { |
| mImpl->vkGetDeviceQueue(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| queueFamilyIndex, queueIndex, pQueue); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkQueueSubmit(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, uint32_t submitCount, |
| const VkSubmitInfo* pSubmits, VkFence fence) { |
| mImpl->vkQueueSubmit(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, queue, |
| submitCount, pSubmits, fence); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkQueueWaitIdle(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue) { |
| mImpl->vkQueueWaitIdle(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| queue); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDeviceWaitIdle(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device) { |
| mImpl->vkDeviceWaitIdle(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkAllocateMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkMemoryAllocateInfo* pAllocateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDeviceMemory* pMemory) { |
| mImpl->vkAllocateMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pAllocateInfo, pAllocator, pMemory); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkFreeMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkFreeMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, memory, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkMapMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkDeviceMemory memory, |
| VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, |
| void** ppData) { |
| mImpl->vkMapMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, |
| memory, offset, size, flags, ppData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkUnmapMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkDeviceMemory memory) { |
| mImpl->vkUnmapMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, memory); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkFlushMappedMemoryRanges(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, uint32_t memoryRangeCount, |
| const VkMappedMemoryRange* pMemoryRanges) { |
| mImpl->vkFlushMappedMemoryRanges(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, memoryRangeCount, pMemoryRanges); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkInvalidateMappedMemoryRanges( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { |
| mImpl->vkInvalidateMappedMemoryRanges(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, memoryRangeCount, pMemoryRanges); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetDeviceMemoryCommitment(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkDeviceMemory memory, |
| VkDeviceSize* pCommittedMemoryInBytes) { |
| mImpl->vkGetDeviceMemoryCommitment(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, memory, pCommittedMemoryInBytes); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkBindBufferMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkBuffer buffer, |
| VkDeviceMemory memory, VkDeviceSize memoryOffset) { |
| mImpl->vkBindBufferMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, buffer, memory, memoryOffset); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkBindImageMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkImage image, |
| VkDeviceMemory memory, VkDeviceSize memoryOffset) { |
| mImpl->vkBindImageMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, image, memory, memoryOffset); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetBufferMemoryRequirements(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkBuffer buffer, |
| VkMemoryRequirements* pMemoryRequirements) { |
| mImpl->vkGetBufferMemoryRequirements(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, buffer, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetImageMemoryRequirements(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkImage image, |
| VkMemoryRequirements* pMemoryRequirements) { |
| mImpl->vkGetImageMemoryRequirements(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, image, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetImageSparseMemoryRequirements( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, VkImage image, |
| uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { |
| mImpl->vkGetImageSparseMemoryRequirements(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, image, pSparseMemoryRequirementCount, |
| pSparseMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceSparseImageFormatProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, |
| VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { |
| mImpl->vkGetPhysicalDeviceSparseImageFormatProperties( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, format, type, |
| samples, usage, tiling, pPropertyCount, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkQueueBindSparse(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, |
| uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, |
| VkFence fence) { |
| mImpl->vkQueueBindSparse(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| queue, bindInfoCount, pBindInfo, fence); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateFence(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkFenceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkFence* pFence) { |
| mImpl->vkCreateFence(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pFence); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyFence(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkFence fence, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyFence(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, fence, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkResetFences(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t fenceCount, |
| const VkFence* pFences) { |
| mImpl->vkResetFences(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, fenceCount, pFences); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetFenceStatus(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkFence fence) { |
| mImpl->vkGetFenceStatus(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, fence); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkWaitForFences(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, uint32_t fenceCount, |
| const VkFence* pFences, VkBool32 waitAll, |
| uint64_t timeout) { |
| mImpl->vkWaitForFences(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, fenceCount, pFences, waitAll, timeout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateSemaphore(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSemaphore* pSemaphore) { |
| mImpl->vkCreateSemaphore(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pSemaphore); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroySemaphore(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkSemaphore semaphore, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroySemaphore(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| semaphore, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateEvent(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkEventCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { |
| mImpl->vkCreateEvent(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pEvent); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyEvent(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkEvent event, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyEvent(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, event, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetEventStatus(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkEvent event) { |
| mImpl->vkGetEventStatus(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, event); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkSetEvent(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkEvent event) { |
| mImpl->vkSetEvent(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, |
| event); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkResetEvent(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, VkEvent event) { |
| mImpl->vkResetEvent(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, |
| event); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateQueryPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkQueryPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkQueryPool* pQueryPool) { |
| mImpl->vkCreateQueryPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pQueryPool); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyQueryPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkQueryPool queryPool, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyQueryPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| queryPool, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetQueryPoolResults( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, |
| VkDeviceSize stride, VkQueryResultFlags flags) { |
| mImpl->vkGetQueryPoolResults(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, queryPool, firstQuery, queryCount, dataSize, |
| pData, stride, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { |
| mImpl->vkCreateBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pBuffer); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkBuffer buffer, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, buffer, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateBufferView(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkBufferViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkBufferView* pView) { |
| mImpl->vkCreateBufferView(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pView); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyBufferView(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkBufferView bufferView, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyBufferView(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| bufferView, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkImage* pImage) { |
| mImpl->vkCreateImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pImage); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImage image, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, image, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetImageSubresourceLayout( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, VkImage image, |
| const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { |
| mImpl->vkGetImageSubresourceLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, image, pSubresource, pLayout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateImageView(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkImageViewCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkImageView* pView) { |
| mImpl->vkCreateImageView(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pView); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyImageView(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkImageView imageView, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyImageView(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| imageView, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateShaderModule(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkShaderModuleCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkShaderModule* pShaderModule) { |
| mImpl->vkCreateShaderModule(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pShaderModule); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyShaderModule(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkShaderModule shaderModule, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyShaderModule(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| shaderModule, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreatePipelineCache( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkPipelineCache* pPipelineCache) { |
| mImpl->vkCreatePipelineCache(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, pPipelineCache); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyPipelineCache(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkPipelineCache pipelineCache, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyPipelineCache(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| pipelineCache, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetPipelineCacheData(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkPipelineCache pipelineCache, |
| size_t* pDataSize, void* pData) { |
| mImpl->vkGetPipelineCacheData(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pipelineCache, pDataSize, pData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkMergePipelineCaches( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { |
| mImpl->vkMergePipelineCaches(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, dstCache, srcCacheCount, pSrcCaches); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateGraphicsPipelines( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkPipelineCache pipelineCache, uint32_t createInfoCount, |
| const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) { |
| mImpl->vkCreateGraphicsPipelines(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pipelineCache, createInfoCount, |
| pCreateInfos, pAllocator, pPipelines); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateComputePipelines( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkPipelineCache pipelineCache, uint32_t createInfoCount, |
| const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, |
| VkPipeline* pPipelines) { |
| mImpl->vkCreateComputePipelines(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pipelineCache, createInfoCount, |
| pCreateInfos, pAllocator, pPipelines); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyPipeline(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkPipeline pipeline, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyPipeline(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| pipeline, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreatePipelineLayout( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkPipelineLayout* pPipelineLayout) { |
| mImpl->vkCreatePipelineLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, pPipelineLayout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyPipelineLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkPipelineLayout pipelineLayout, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyPipelineLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| pipelineLayout, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateSampler(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSamplerCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSampler* pSampler) { |
| mImpl->vkCreateSampler(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pSampler); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroySampler(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkSampler sampler, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroySampler(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, sampler, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateDescriptorSetLayout( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkDescriptorSetLayout* pSetLayout) { |
| mImpl->vkCreateDescriptorSetLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, pSetLayout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyDescriptorSetLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorSetLayout descriptorSetLayout, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDescriptorSetLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, descriptorSetLayout, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateDescriptorPool( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkDescriptorPool* pDescriptorPool) { |
| mImpl->vkCreateDescriptorPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, pDescriptorPool); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyDescriptorPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorPool descriptorPool, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDescriptorPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| descriptorPool, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkResetDescriptorPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkDescriptorPool descriptorPool, |
| VkDescriptorPoolResetFlags flags) { |
| mImpl->vkResetDescriptorPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, descriptorPool, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkAllocateDescriptorSets( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { |
| mImpl->vkAllocateDescriptorSets(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pAllocateInfo, pDescriptorSets); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkFreeDescriptorSets(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkDescriptorPool descriptorPool, |
| uint32_t descriptorSetCount, |
| const VkDescriptorSet* pDescriptorSets) { |
| mImpl->vkFreeDescriptorSets(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, descriptorPool, descriptorSetCount, pDescriptorSets); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkUpdateDescriptorSets( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, |
| uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { |
| mImpl->vkUpdateDescriptorSets(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, |
| pDescriptorCopies); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateFramebuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkFramebufferCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkFramebuffer* pFramebuffer) { |
| mImpl->vkCreateFramebuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pFramebuffer); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyFramebuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkFramebuffer framebuffer, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyFramebuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| framebuffer, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateRenderPass(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkRenderPassCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) { |
| mImpl->vkCreateRenderPass(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pRenderPass); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyRenderPass(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkRenderPass renderPass, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyRenderPass(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| renderPass, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkGetRenderAreaGranularity(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkRenderPass renderPass, |
| VkExtent2D* pGranularity) { |
| mImpl->vkGetRenderAreaGranularity(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| renderPass, pGranularity); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCreateCommandPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCommandPoolCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkCommandPool* pCommandPool) { |
| mImpl->vkCreateCommandPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pCommandPool); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkDestroyCommandPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkCommandPool commandPool, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyCommandPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| commandPool, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkResetCommandPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkCommandPool commandPool, |
| VkCommandPoolResetFlags flags) { |
| mImpl->vkResetCommandPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, commandPool, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkAllocateCommandBuffers( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { |
| mImpl->vkAllocateCommandBuffers(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pAllocateInfo, pCommandBuffers); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkFreeCommandBuffers(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) { |
| mImpl->vkFreeCommandBuffers(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| commandPool, commandBufferCount, pCommandBuffers); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkBeginCommandBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo) { |
| mImpl->vkBeginCommandBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| commandBuffer, pBeginInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkEndCommandBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkCommandBuffer commandBuffer) { |
| mImpl->vkEndCommandBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| commandBuffer); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkResetCommandBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags) { |
| mImpl->vkResetCommandBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| commandBuffer, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBindPipeline(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, |
| VkPipeline pipeline) { |
| mImpl->vkCmdBindPipeline(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pipelineBindPoint, pipeline); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetViewport(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstViewport, |
| uint32_t viewportCount, const VkViewport* pViewports) { |
| mImpl->vkCmdSetViewport(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| firstViewport, viewportCount, pViewports); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetScissor(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstScissor, |
| uint32_t scissorCount, const VkRect2D* pScissors) { |
| mImpl->vkCmdSetScissor(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| firstScissor, scissorCount, pScissors); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetLineWidth(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, float lineWidth) { |
| mImpl->vkCmdSetLineWidth(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| lineWidth); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetDepthBias(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| float depthBiasConstantFactor, float depthBiasClamp, |
| float depthBiasSlopeFactor) { |
| mImpl->vkCmdSetDepthBias(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetBlendConstants(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const float blendConstants[4]) { |
| mImpl->vkCmdSetBlendConstants(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, blendConstants); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetDepthBounds(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, float minDepthBounds, |
| float maxDepthBounds) { |
| mImpl->vkCmdSetDepthBounds(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| minDepthBounds, maxDepthBounds); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetStencilCompareMask( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, uint32_t compareMask) { |
| mImpl->vkCmdSetStencilCompareMask(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, faceMask, compareMask); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetStencilWriteMask(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, uint32_t writeMask) { |
| mImpl->vkCmdSetStencilWriteMask(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, faceMask, writeMask); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetStencilReference(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, uint32_t reference) { |
| mImpl->vkCmdSetStencilReference(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, faceMask, reference); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBindDescriptorSets( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, |
| uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, |
| uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { |
| mImpl->vkCmdBindDescriptorSets( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, pipelineBindPoint, |
| layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBindIndexBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, |
| VkDeviceSize offset, VkIndexType indexType) { |
| mImpl->vkCmdBindIndexBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset, indexType); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBindVertexBuffers(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t firstBinding, |
| uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets) { |
| mImpl->vkCmdBindVertexBuffers(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdDraw(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t vertexCount, |
| uint32_t instanceCount, uint32_t firstVertex, |
| uint32_t firstInstance) { |
| mImpl->vkCmdDraw(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| vertexCount, instanceCount, firstVertex, firstInstance); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdDrawIndexed(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t indexCount, |
| uint32_t instanceCount, uint32_t firstIndex, |
| int32_t vertexOffset, uint32_t firstInstance) { |
| mImpl->vkCmdDrawIndexed(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdDrawIndirect(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, |
| VkDeviceSize offset, uint32_t drawCount, |
| uint32_t stride) { |
| mImpl->vkCmdDrawIndirect(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| buffer, offset, drawCount, stride); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdDrawIndexedIndirect( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { |
| mImpl->vkCmdDrawIndexedIndirect(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset, drawCount, stride); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdDispatch(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t groupCountX, |
| uint32_t groupCountY, uint32_t groupCountZ) { |
| mImpl->vkCmdDispatch(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| groupCountX, groupCountY, groupCountZ); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdDispatchIndirect(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer buffer, |
| VkDeviceSize offset) { |
| mImpl->vkCmdDispatchIndirect(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdCopyBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer srcBuffer, |
| VkBuffer dstBuffer, uint32_t regionCount, |
| const VkBufferCopy* pRegions) { |
| mImpl->vkCmdCopyBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| srcBuffer, dstBuffer, regionCount, pRegions); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdCopyImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage srcImage, |
| VkImageLayout srcImageLayout, VkImage dstImage, |
| VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkImageCopy* pRegions) { |
| mImpl->vkCmdCopyImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, |
| pRegions); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBlitImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage srcImage, |
| VkImageLayout srcImageLayout, VkImage dstImage, |
| VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkImageBlit* pRegions, VkFilter filter) { |
| mImpl->vkCmdBlitImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, |
| filter); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdCopyBufferToImage( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) { |
| mImpl->vkCmdCopyBufferToImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, |
| pRegions); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdCopyImageToBuffer( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, |
| const VkBufferImageCopy* pRegions) { |
| mImpl->vkCmdCopyImageToBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, |
| pRegions); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdUpdateBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, VkDeviceSize dataSize, |
| const void* pData) { |
| mImpl->vkCmdUpdateBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| dstBuffer, dstOffset, dataSize, pData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdFillBuffer(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { |
| mImpl->vkCmdFillBuffer(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| dstBuffer, dstOffset, size, data); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdClearColorImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage image, |
| VkImageLayout imageLayout, |
| const VkClearColorValue* pColor, uint32_t rangeCount, |
| const VkImageSubresourceRange* pRanges) { |
| mImpl->vkCmdClearColorImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdClearDepthStencilImage( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, |
| uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { |
| mImpl->vkCmdClearDepthStencilImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, image, imageLayout, pDepthStencil, rangeCount, |
| pRanges); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdClearAttachments( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, |
| const VkClearRect* pRects) { |
| mImpl->vkCmdClearAttachments(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, attachmentCount, pAttachments, rectCount, pRects); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdResolveImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkImage srcImage, |
| VkImageLayout srcImageLayout, VkImage dstImage, |
| VkImageLayout dstImageLayout, uint32_t regionCount, |
| const VkImageResolve* pRegions) { |
| mImpl->vkCmdResolveImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, |
| pRegions); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdSetEvent(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags stageMask) { |
| mImpl->vkCmdSetEvent(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| event, stageMask); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdResetEvent(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags stageMask) { |
| mImpl->vkCmdResetEvent(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| event, stageMask); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdWaitEvents( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, 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) { |
| mImpl->vkCmdWaitEvents(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, |
| pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, |
| imageMemoryBarrierCount, pImageMemoryBarriers); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdPipelineBarrier( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, 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) { |
| mImpl->vkCmdPipelineBarrier(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, srcStageMask, dstStageMask, dependencyFlags, |
| memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, |
| pBufferMemoryBarriers, imageMemoryBarrierCount, |
| pImageMemoryBarriers); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBeginQuery(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t query, VkQueryControlFlags flags) { |
| mImpl->vkCmdBeginQuery(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| queryPool, query, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdEndQuery(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t query) { |
| mImpl->vkCmdEndQuery(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| queryPool, query); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdResetQueryPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkQueryPool queryPool, |
| uint32_t firstQuery, uint32_t queryCount) { |
| mImpl->vkCmdResetQueryPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| queryPool, firstQuery, queryCount); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdWriteTimestamp(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlagBits pipelineStage, |
| VkQueryPool queryPool, uint32_t query) { |
| mImpl->vkCmdWriteTimestamp(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pipelineStage, queryPool, query); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdCopyQueryPoolResults( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, |
| VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { |
| mImpl->vkCmdCopyQueryPoolResults(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, |
| dstOffset, stride, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdPushConstants(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkPipelineLayout layout, |
| VkShaderStageFlags stageFlags, uint32_t offset, |
| uint32_t size, const void* pValues) { |
| mImpl->vkCmdPushConstants(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| layout, stageFlags, offset, size, pValues); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdBeginRenderPass(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, |
| VkSubpassContents contents) { |
| mImpl->vkCmdBeginRenderPass(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pRenderPassBegin, contents); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdNextSubpass(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkSubpassContents contents) { |
| mImpl->vkCmdNextSubpass(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| contents); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdEndRenderPass(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) { |
| mImpl->vkCmdEndRenderPass(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer); |
| } |
| #endif |
| #ifdef VK_VERSION_1_0 |
| void VkDecoderSnapshot::vkCmdExecuteCommands(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) { |
| mImpl->vkCmdExecuteCommands(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, commandBufferCount, pCommandBuffers); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkEnumerateInstanceVersion(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| uint32_t* pApiVersion) { |
| mImpl->vkEnumerateInstanceVersion(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, pApiVersion); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkBindBufferMemory2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) { |
| mImpl->vkBindBufferMemory2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, bindInfoCount, pBindInfos); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkBindImageMemory2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) { |
| mImpl->vkBindImageMemory2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, bindInfoCount, pBindInfos); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetDeviceGroupPeerMemoryFeatures( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, uint32_t heapIndex, |
| uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, |
| VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) { |
| mImpl->vkGetDeviceGroupPeerMemoryFeatures(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, heapIndex, localDeviceIndex, |
| remoteDeviceIndex, pPeerMemoryFeatures); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkCmdSetDeviceMask(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t deviceMask) { |
| mImpl->vkCmdSetDeviceMask(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| deviceMask); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkCmdDispatchBase(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t baseGroupX, |
| uint32_t baseGroupY, uint32_t baseGroupZ, |
| uint32_t groupCountX, uint32_t groupCountY, |
| uint32_t groupCountZ) { |
| mImpl->vkCmdDispatchBase(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, |
| groupCountZ); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkEnumeratePhysicalDeviceGroups( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, |
| VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) { |
| mImpl->vkEnumeratePhysicalDeviceGroups(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, instance, pPhysicalDeviceGroupCount, |
| pPhysicalDeviceGroupProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetImageMemoryRequirements2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetImageMemoryRequirements2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetBufferMemoryRequirements2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, |
| VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetBufferMemoryRequirements2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetImageSparseMemoryRequirements2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { |
| mImpl->vkGetImageSparseMemoryRequirements2( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, |
| pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceFeatures2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2* pFeatures) { |
| mImpl->vkGetPhysicalDeviceFeatures2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| physicalDevice, pFeatures); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceProperties2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2* pProperties) { |
| mImpl->vkGetPhysicalDeviceProperties2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| physicalDevice, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceFormatProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkFormat format, VkFormatProperties2* pFormatProperties) { |
| mImpl->vkGetPhysicalDeviceFormatProperties2(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, physicalDevice, format, |
| pFormatProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceImageFormatProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, |
| VkImageFormatProperties2* pImageFormatProperties) { |
| mImpl->vkGetPhysicalDeviceImageFormatProperties2( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, physicalDevice, |
| pImageFormatInfo, pImageFormatProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceQueueFamilyProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { |
| mImpl->vkGetPhysicalDeviceQueueFamilyProperties2( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, |
| pQueueFamilyPropertyCount, pQueueFamilyProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceMemoryProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { |
| mImpl->vkGetPhysicalDeviceMemoryProperties2( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pMemoryProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceSparseImageFormatProperties2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties2* pProperties) { |
| mImpl->vkGetPhysicalDeviceSparseImageFormatProperties2( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pFormatInfo, |
| pPropertyCount, pProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkTrimCommandPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) { |
| mImpl->vkTrimCommandPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| commandPool, flags); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetDeviceQueue2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, |
| VkQueue* pQueue) { |
| mImpl->vkGetDeviceQueue2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| pQueueInfo, pQueue); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkCreateSamplerYcbcrConversion( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) { |
| mImpl->vkCreateSamplerYcbcrConversion(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, |
| pYcbcrConversion); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkDestroySamplerYcbcrConversion(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroySamplerYcbcrConversion(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, ycbcrConversion, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkCreateDescriptorUpdateTemplate( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { |
| mImpl->vkCreateDescriptorUpdateTemplate(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, |
| pDescriptorUpdateTemplate); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkDestroyDescriptorUpdateTemplate( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDescriptorUpdateTemplate(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, descriptorUpdateTemplate, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplate( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) { |
| mImpl->vkUpdateDescriptorSetWithTemplate(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, descriptorSet, descriptorUpdateTemplate, |
| pData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceExternalBufferProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, |
| VkExternalBufferProperties* pExternalBufferProperties) { |
| mImpl->vkGetPhysicalDeviceExternalBufferProperties( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pExternalBufferInfo, |
| pExternalBufferProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceExternalFenceProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, |
| VkExternalFenceProperties* pExternalFenceProperties) { |
| mImpl->vkGetPhysicalDeviceExternalFenceProperties(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, physicalDevice, |
| pExternalFenceInfo, pExternalFenceProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceExternalSemaphoreProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { |
| mImpl->vkGetPhysicalDeviceExternalSemaphoreProperties( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, |
| pExternalSemaphoreInfo, pExternalSemaphoreProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_1 |
| void VkDecoderSnapshot::vkGetDescriptorSetLayoutSupport( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { |
| mImpl->vkGetDescriptorSetLayoutSupport(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pCreateInfo, pSupport); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkCmdDrawIndirectCount( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, uint32_t stride) { |
| mImpl->vkCmdDrawIndirectCount(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset, countBuffer, countBufferOffset, |
| maxDrawCount, stride); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkCmdDrawIndexedIndirectCount( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, uint32_t stride) { |
| mImpl->vkCmdDrawIndexedIndirectCount(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset, countBuffer, |
| countBufferOffset, maxDrawCount, stride); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkCreateRenderPass2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) { |
| mImpl->vkCreateRenderPass2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pRenderPass); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkCmdBeginRenderPass2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { |
| mImpl->vkCmdBeginRenderPass2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pRenderPassBegin, pSubpassBeginInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkCmdNextSubpass2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) { |
| mImpl->vkCmdNextSubpass2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pSubpassBeginInfo, pSubpassEndInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkCmdEndRenderPass2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) { |
| mImpl->vkCmdEndRenderPass2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pSubpassEndInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkResetQueryPool(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkQueryPool queryPool, |
| uint32_t firstQuery, uint32_t queryCount) { |
| mImpl->vkResetQueryPool(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| queryPool, firstQuery, queryCount); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkGetSemaphoreCounterValue(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkSemaphore semaphore, |
| uint64_t* pValue) { |
| mImpl->vkGetSemaphoreCounterValue(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, semaphore, pValue); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkWaitSemaphores(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) { |
| mImpl->vkWaitSemaphores(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pWaitInfo, timeout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkSignalSemaphore(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreSignalInfo* pSignalInfo) { |
| mImpl->vkSignalSemaphore(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pSignalInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkGetBufferDeviceAddress(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkDeviceAddress input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) { |
| mImpl->vkGetBufferDeviceAddress(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkGetBufferOpaqueCaptureAddress(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| uint64_t input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) { |
| mImpl->vkGetBufferOpaqueCaptureAddress(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_2 |
| void VkDecoderSnapshot::vkGetDeviceMemoryOpaqueCaptureAddress( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, uint64_t input_result, VkDevice device, |
| const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { |
| mImpl->vkGetDeviceMemoryOpaqueCaptureAddress(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, pInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceToolProperties( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, uint32_t* pToolCount, |
| VkPhysicalDeviceToolProperties* pToolProperties) { |
| mImpl->vkGetPhysicalDeviceToolProperties(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, physicalDevice, pToolCount, |
| pToolProperties); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCreatePrivateDataSlot( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot) { |
| mImpl->vkCreatePrivateDataSlot(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, pPrivateDataSlot); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkDestroyPrivateDataSlot(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyPrivateDataSlot(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| privateDataSlot, pAllocator); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkSetPrivateData(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkObjectType objectType, uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, uint64_t data) { |
| mImpl->vkSetPrivateData(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, objectType, objectHandle, privateDataSlot, data); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkGetPrivateData(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkObjectType objectType, |
| uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, |
| uint64_t* pData) { |
| mImpl->vkGetPrivateData(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| objectType, objectHandle, privateDataSlot, pData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetEvent2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) { |
| mImpl->vkCmdSetEvent2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| event, pDependencyInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdResetEvent2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags2 stageMask) { |
| mImpl->vkCmdResetEvent2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| event, stageMask); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdWaitEvents2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t eventCount, |
| const VkEvent* pEvents, |
| const VkDependencyInfo* pDependencyInfos) { |
| mImpl->vkCmdWaitEvents2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| eventCount, pEvents, pDependencyInfos); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdPipelineBarrier2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) { |
| mImpl->vkCmdPipelineBarrier2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pDependencyInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdWriteTimestamp2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, VkQueryPool queryPool, |
| uint32_t query) { |
| mImpl->vkCmdWriteTimestamp2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, stage, queryPool, query); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkQueueSubmit2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, VkFence fence) { |
| mImpl->vkQueueSubmit2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| queue, submitCount, pSubmits, fence); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdCopyBuffer2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) { |
| mImpl->vkCmdCopyBuffer2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pCopyBufferInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdCopyImage2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageInfo2* pCopyImageInfo) { |
| mImpl->vkCmdCopyImage2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pCopyImageInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdCopyBufferToImage2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { |
| mImpl->vkCmdCopyBufferToImage2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pCopyBufferToImageInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdCopyImageToBuffer2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { |
| mImpl->vkCmdCopyImageToBuffer2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pCopyImageToBufferInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdBlitImage2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkBlitImageInfo2* pBlitImageInfo) { |
| mImpl->vkCmdBlitImage2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pBlitImageInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdResolveImage2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) { |
| mImpl->vkCmdResolveImage2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pResolveImageInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdBeginRendering(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) { |
| mImpl->vkCmdBeginRendering(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pRenderingInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdEndRendering(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) { |
| mImpl->vkCmdEndRendering(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetCullMode(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { |
| mImpl->vkCmdSetCullMode(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| cullMode); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetFrontFace(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkFrontFace frontFace) { |
| mImpl->vkCmdSetFrontFace(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| frontFace); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetPrimitiveTopology(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) { |
| mImpl->vkCmdSetPrimitiveTopology(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, primitiveTopology); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetViewportWithCount( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, const VkViewport* pViewports) { |
| mImpl->vkCmdSetViewportWithCount(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, viewportCount, pViewports); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetScissorWithCount(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, const VkRect2D* pScissors) { |
| mImpl->vkCmdSetScissorWithCount(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, scissorCount, pScissors); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdBindVertexBuffers2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { |
| mImpl->vkCmdBindVertexBuffers2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, |
| pSizes, pStrides); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetDepthTestEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthTestEnable) { |
| mImpl->vkCmdSetDepthTestEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthTestEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetDepthWriteEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthWriteEnable) { |
| mImpl->vkCmdSetDepthWriteEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthWriteEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetDepthCompareOp(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) { |
| mImpl->vkCmdSetDepthCompareOp(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthCompareOp); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetDepthBoundsTestEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) { |
| mImpl->vkCmdSetDepthBoundsTestEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthBoundsTestEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetStencilTestEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 stencilTestEnable) { |
| mImpl->vkCmdSetStencilTestEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, stencilTestEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetStencilOp(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, VkStencilOp failOp, |
| VkStencilOp passOp, VkStencilOp depthFailOp, |
| VkCompareOp compareOp) { |
| mImpl->vkCmdSetStencilOp(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| faceMask, failOp, passOp, depthFailOp, compareOp); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetRasterizerDiscardEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) { |
| mImpl->vkCmdSetRasterizerDiscardEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, rasterizerDiscardEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetDepthBiasEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBiasEnable) { |
| mImpl->vkCmdSetDepthBiasEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthBiasEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkCmdSetPrimitiveRestartEnable(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) { |
| mImpl->vkCmdSetPrimitiveRestartEnable(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, primitiveRestartEnable); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkGetDeviceBufferMemoryRequirements( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetDeviceBufferMemoryRequirements( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkGetDeviceImageMemoryRequirements( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetDeviceImageMemoryRequirements(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_3 |
| void VkDecoderSnapshot::vkGetDeviceImageSparseMemoryRequirements( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { |
| mImpl->vkGetDeviceImageSparseMemoryRequirements( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, |
| pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdSetLineStipple(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, |
| uint16_t lineStipplePattern) { |
| mImpl->vkCmdSetLineStipple(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| lineStippleFactor, lineStipplePattern); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkMapMemory2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkMemoryMapInfo* pMemoryMapInfo, void** ppData) { |
| mImpl->vkMapMemory2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, |
| pMemoryMapInfo, ppData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkUnmapMemory2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkMemoryUnmapInfo* pMemoryUnmapInfo) { |
| mImpl->vkUnmapMemory2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pMemoryUnmapInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdBindIndexBuffer2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { |
| mImpl->vkCmdBindIndexBuffer2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset, size, indexType); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkGetRenderingAreaGranularity(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkRenderingAreaInfo* pRenderingAreaInfo, |
| VkExtent2D* pGranularity) { |
| mImpl->vkGetRenderingAreaGranularity(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pRenderingAreaInfo, pGranularity); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkGetDeviceImageSubresourceLayout(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageSubresourceInfo* pInfo, |
| VkSubresourceLayout2* pLayout) { |
| mImpl->vkGetDeviceImageSubresourceLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pInfo, pLayout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkGetImageSubresourceLayout2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, VkImage image, |
| const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { |
| mImpl->vkGetImageSubresourceLayout2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, image, pSubresource, pLayout); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdPushDescriptorSet( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, |
| uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) { |
| mImpl->vkCmdPushDescriptorSet(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pipelineBindPoint, layout, set, |
| descriptorWriteCount, pDescriptorWrites); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdPushDescriptorSetWithTemplate( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, |
| const void* pData) { |
| mImpl->vkCmdPushDescriptorSetWithTemplate(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, descriptorUpdateTemplate, layout, set, |
| pData); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdSetRenderingAttachmentLocations( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderingAttachmentLocationInfo* pLocationInfo) { |
| mImpl->vkCmdSetRenderingAttachmentLocations(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, commandBuffer, pLocationInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdSetRenderingInputAttachmentIndices( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo) { |
| mImpl->vkCmdSetRenderingInputAttachmentIndices(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, commandBuffer, |
| pInputAttachmentIndexInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdBindDescriptorSets2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo) { |
| mImpl->vkCmdBindDescriptorSets2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pBindDescriptorSetsInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdPushConstants2(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkPushConstantsInfo* pPushConstantsInfo) { |
| mImpl->vkCmdPushConstants2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pPushConstantsInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdPushDescriptorSet2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkPushDescriptorSetInfo* pPushDescriptorSetInfo) { |
| mImpl->vkCmdPushDescriptorSet2(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pPushDescriptorSetInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCmdPushDescriptorSetWithTemplate2( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo) { |
| mImpl->vkCmdPushDescriptorSetWithTemplate2(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, commandBuffer, |
| pPushDescriptorSetWithTemplateInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCopyMemoryToImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { |
| mImpl->vkCopyMemoryToImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCopyMemoryToImageInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCopyImageToMemory(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { |
| mImpl->vkCopyImageToMemory(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCopyImageToMemoryInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkCopyImageToImage(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkCopyImageToImageInfo* pCopyImageToImageInfo) { |
| mImpl->vkCopyImageToImage(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCopyImageToImageInfo); |
| } |
| #endif |
| #ifdef VK_VERSION_1_4 |
| void VkDecoderSnapshot::vkTransitionImageLayout( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { |
| mImpl->vkTransitionImageLayout(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, transitionCount, pTransitions); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkCreateSwapchainKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSwapchainCreateInfoKHR* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkSwapchainKHR* pSwapchain) { |
| mImpl->vkCreateSwapchainKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pCreateInfo, pAllocator, pSwapchain); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkDestroySwapchainKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkSwapchainKHR swapchain, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroySwapchainKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| swapchain, pAllocator); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkGetSwapchainImagesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { |
| mImpl->vkGetSwapchainImagesKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, swapchain, pSwapchainImageCount, |
| pSwapchainImages); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkAcquireNextImageKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkSwapchainKHR swapchain, |
| uint64_t timeout, VkSemaphore semaphore, |
| VkFence fence, uint32_t* pImageIndex) { |
| mImpl->vkAcquireNextImageKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, swapchain, timeout, semaphore, fence, |
| pImageIndex); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkQueuePresentKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, |
| const VkPresentInfoKHR* pPresentInfo) { |
| mImpl->vkQueuePresentKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| queue, pPresentInfo); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkGetDeviceGroupPresentCapabilitiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) { |
| mImpl->vkGetDeviceGroupPresentCapabilitiesKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, |
| pDeviceGroupPresentCapabilities); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkGetDeviceGroupSurfacePresentModesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) { |
| mImpl->vkGetDeviceGroupSurfacePresentModesKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, surface, |
| pModes); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkGetPhysicalDevicePresentRectanglesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { |
| mImpl->vkGetPhysicalDevicePresentRectanglesKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, physicalDevice, |
| surface, pRectCount, pRects); |
| } |
| #endif |
| #ifdef VK_KHR_swapchain |
| void VkDecoderSnapshot::vkAcquireNextImage2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { |
| mImpl->vkAcquireNextImage2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pAcquireInfo, pImageIndex); |
| } |
| #endif |
| #ifdef VK_KHR_dynamic_rendering |
| void VkDecoderSnapshot::vkCmdBeginRenderingKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkRenderingInfo* pRenderingInfo) { |
| mImpl->vkCmdBeginRenderingKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pRenderingInfo); |
| } |
| #endif |
| #ifdef VK_KHR_dynamic_rendering |
| void VkDecoderSnapshot::vkCmdEndRenderingKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) { |
| mImpl->vkCmdEndRenderingKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceFeatures2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2* pFeatures) { |
| mImpl->vkGetPhysicalDeviceFeatures2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| physicalDevice, pFeatures); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2* pProperties) { |
| mImpl->vkGetPhysicalDeviceProperties2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| physicalDevice, pProperties); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceFormatProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkFormat format, VkFormatProperties2* pFormatProperties) { |
| mImpl->vkGetPhysicalDeviceFormatProperties2KHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, physicalDevice, format, |
| pFormatProperties); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceImageFormatProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, |
| VkImageFormatProperties2* pImageFormatProperties) { |
| mImpl->vkGetPhysicalDeviceImageFormatProperties2KHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, physicalDevice, |
| pImageFormatInfo, pImageFormatProperties); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) { |
| mImpl->vkGetPhysicalDeviceQueueFamilyProperties2KHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, |
| pQueueFamilyPropertyCount, pQueueFamilyProperties); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceMemoryProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2* pMemoryProperties) { |
| mImpl->vkGetPhysicalDeviceMemoryProperties2KHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pMemoryProperties); |
| } |
| #endif |
| #ifdef VK_KHR_get_physical_device_properties2 |
| void VkDecoderSnapshot::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, |
| VkSparseImageFormatProperties2* pProperties) { |
| mImpl->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pFormatInfo, |
| pPropertyCount, pProperties); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance1 |
| void VkDecoderSnapshot::vkTrimCommandPoolKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkCommandPool commandPool, |
| VkCommandPoolTrimFlags flags) { |
| mImpl->vkTrimCommandPoolKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| commandPool, flags); |
| } |
| #endif |
| #ifdef VK_KHR_external_memory_capabilities |
| void VkDecoderSnapshot::vkGetPhysicalDeviceExternalBufferPropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, |
| VkExternalBufferProperties* pExternalBufferProperties) { |
| mImpl->vkGetPhysicalDeviceExternalBufferPropertiesKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pExternalBufferInfo, |
| pExternalBufferProperties); |
| } |
| #endif |
| #ifdef VK_KHR_external_semaphore_capabilities |
| void VkDecoderSnapshot::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, |
| VkExternalSemaphoreProperties* pExternalSemaphoreProperties) { |
| mImpl->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, |
| pExternalSemaphoreInfo, pExternalSemaphoreProperties); |
| } |
| #endif |
| #ifdef VK_KHR_external_semaphore_fd |
| void VkDecoderSnapshot::vkImportSemaphoreFdKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) { |
| mImpl->vkImportSemaphoreFdKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pImportSemaphoreFdInfo); |
| } |
| #endif |
| #ifdef VK_KHR_external_semaphore_fd |
| void VkDecoderSnapshot::vkGetSemaphoreFdKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) { |
| mImpl->vkGetSemaphoreFdKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pGetFdInfo, pFd); |
| } |
| #endif |
| #ifdef VK_KHR_descriptor_update_template |
| void VkDecoderSnapshot::vkCreateDescriptorUpdateTemplateKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) { |
| mImpl->vkCreateDescriptorUpdateTemplateKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, pCreateInfo, |
| pAllocator, pDescriptorUpdateTemplate); |
| } |
| #endif |
| #ifdef VK_KHR_descriptor_update_template |
| void VkDecoderSnapshot::vkDestroyDescriptorUpdateTemplateKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDescriptorUpdateTemplateKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, device, descriptorUpdateTemplate, |
| pAllocator); |
| } |
| #endif |
| #ifdef VK_KHR_descriptor_update_template |
| void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplateKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, |
| const void* pData) { |
| mImpl->vkUpdateDescriptorSetWithTemplateKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, device, descriptorSet, |
| descriptorUpdateTemplate, pData); |
| } |
| #endif |
| #ifdef VK_KHR_create_renderpass2 |
| void VkDecoderSnapshot::vkCreateRenderPass2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkRenderPass* pRenderPass) { |
| mImpl->vkCreateRenderPass2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, pRenderPass); |
| } |
| #endif |
| #ifdef VK_KHR_create_renderpass2 |
| void VkDecoderSnapshot::vkCmdBeginRenderPass2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) { |
| mImpl->vkCmdBeginRenderPass2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pRenderPassBegin, pSubpassBeginInfo); |
| } |
| #endif |
| #ifdef VK_KHR_create_renderpass2 |
| void VkDecoderSnapshot::vkCmdNextSubpass2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkSubpassBeginInfo* pSubpassBeginInfo, |
| const VkSubpassEndInfo* pSubpassEndInfo) { |
| mImpl->vkCmdNextSubpass2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); |
| } |
| #endif |
| #ifdef VK_KHR_create_renderpass2 |
| void VkDecoderSnapshot::vkCmdEndRenderPass2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkSubpassEndInfo* pSubpassEndInfo) { |
| mImpl->vkCmdEndRenderPass2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pSubpassEndInfo); |
| } |
| #endif |
| #ifdef VK_KHR_external_fence_capabilities |
| void VkDecoderSnapshot::vkGetPhysicalDeviceExternalFencePropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkPhysicalDevice physicalDevice, |
| const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, |
| VkExternalFenceProperties* pExternalFenceProperties) { |
| mImpl->vkGetPhysicalDeviceExternalFencePropertiesKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, physicalDevice, pExternalFenceInfo, |
| pExternalFenceProperties); |
| } |
| #endif |
| #ifdef VK_KHR_external_fence_fd |
| void VkDecoderSnapshot::vkImportFenceFdKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkImportFenceFdInfoKHR* pImportFenceFdInfo) { |
| mImpl->vkImportFenceFdKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pImportFenceFdInfo); |
| } |
| #endif |
| #ifdef VK_KHR_external_fence_fd |
| void VkDecoderSnapshot::vkGetFenceFdKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) { |
| mImpl->vkGetFenceFdKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, pGetFdInfo, pFd); |
| } |
| #endif |
| #ifdef VK_KHR_get_memory_requirements2 |
| void VkDecoderSnapshot::vkGetImageMemoryRequirements2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetImageMemoryRequirements2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_KHR_get_memory_requirements2 |
| void VkDecoderSnapshot::vkGetBufferMemoryRequirements2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetBufferMemoryRequirements2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_KHR_get_memory_requirements2 |
| void VkDecoderSnapshot::vkGetImageSparseMemoryRequirements2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { |
| mImpl->vkGetImageSparseMemoryRequirements2KHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, |
| pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_KHR_sampler_ycbcr_conversion |
| void VkDecoderSnapshot::vkCreateSamplerYcbcrConversionKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkSamplerYcbcrConversion* pYcbcrConversion) { |
| mImpl->vkCreateSamplerYcbcrConversionKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, |
| pYcbcrConversion); |
| } |
| #endif |
| #ifdef VK_KHR_sampler_ycbcr_conversion |
| void VkDecoderSnapshot::vkDestroySamplerYcbcrConversionKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroySamplerYcbcrConversionKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, ycbcrConversion, pAllocator); |
| } |
| #endif |
| #ifdef VK_KHR_bind_memory2 |
| void VkDecoderSnapshot::vkBindBufferMemory2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, uint32_t bindInfoCount, |
| const VkBindBufferMemoryInfo* pBindInfos) { |
| mImpl->vkBindBufferMemory2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, bindInfoCount, pBindInfos); |
| } |
| #endif |
| #ifdef VK_KHR_bind_memory2 |
| void VkDecoderSnapshot::vkBindImageMemory2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, uint32_t bindInfoCount, |
| const VkBindImageMemoryInfo* pBindInfos) { |
| mImpl->vkBindImageMemory2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, bindInfoCount, pBindInfos); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance3 |
| void VkDecoderSnapshot::vkGetDescriptorSetLayoutSupportKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { |
| mImpl->vkGetDescriptorSetLayoutSupportKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pCreateInfo, pSupport); |
| } |
| #endif |
| #ifdef VK_KHR_buffer_device_address |
| void VkDecoderSnapshot::vkGetBufferDeviceAddressKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkDeviceAddress input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) { |
| mImpl->vkGetBufferDeviceAddressKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pInfo); |
| } |
| #endif |
| #ifdef VK_KHR_buffer_device_address |
| void VkDecoderSnapshot::vkGetBufferOpaqueCaptureAddressKHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| uint64_t input_result, VkDevice device, |
| const VkBufferDeviceAddressInfo* pInfo) { |
| mImpl->vkGetBufferOpaqueCaptureAddressKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pInfo); |
| } |
| #endif |
| #ifdef VK_KHR_buffer_device_address |
| void VkDecoderSnapshot::vkGetDeviceMemoryOpaqueCaptureAddressKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, uint64_t input_result, VkDevice device, |
| const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) { |
| mImpl->vkGetDeviceMemoryOpaqueCaptureAddressKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, pInfo); |
| } |
| #endif |
| #ifdef VK_KHR_pipeline_executable_properties |
| void VkDecoderSnapshot::vkGetPipelineExecutablePropertiesKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, |
| VkPipelineExecutablePropertiesKHR* pProperties) { |
| mImpl->vkGetPipelineExecutablePropertiesKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, |
| pPipelineInfo, pExecutableCount, pProperties); |
| } |
| #endif |
| #ifdef VK_KHR_pipeline_executable_properties |
| void VkDecoderSnapshot::vkGetPipelineExecutableStatisticsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, |
| VkPipelineExecutableStatisticKHR* pStatistics) { |
| mImpl->vkGetPipelineExecutableStatisticsKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, |
| pExecutableInfo, pStatisticCount, pStatistics); |
| } |
| #endif |
| #ifdef VK_KHR_pipeline_executable_properties |
| void VkDecoderSnapshot::vkGetPipelineExecutableInternalRepresentationsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, |
| VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { |
| mImpl->vkGetPipelineExecutableInternalRepresentationsKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, |
| pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); |
| } |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void VkDecoderSnapshot::vkCmdSetEvent2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| const VkDependencyInfo* pDependencyInfo) { |
| mImpl->vkCmdSetEvent2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| event, pDependencyInfo); |
| } |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void VkDecoderSnapshot::vkCmdResetEvent2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkEvent event, |
| VkPipelineStageFlags2 stageMask) { |
| mImpl->vkCmdResetEvent2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| event, stageMask); |
| } |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void VkDecoderSnapshot::vkCmdWaitEvents2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, uint32_t eventCount, |
| const VkEvent* pEvents, |
| const VkDependencyInfo* pDependencyInfos) { |
| mImpl->vkCmdWaitEvents2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| eventCount, pEvents, pDependencyInfos); |
| } |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void VkDecoderSnapshot::vkCmdPipelineBarrier2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDependencyInfo* pDependencyInfo) { |
| mImpl->vkCmdPipelineBarrier2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pDependencyInfo); |
| } |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void VkDecoderSnapshot::vkCmdWriteTimestamp2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { |
| mImpl->vkCmdWriteTimestamp2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, stage, queryPool, query); |
| } |
| #endif |
| #ifdef VK_KHR_synchronization2 |
| void VkDecoderSnapshot::vkQueueSubmit2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkQueue queue, |
| uint32_t submitCount, const VkSubmitInfo2* pSubmits, |
| VkFence fence) { |
| mImpl->vkQueueSubmit2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| queue, submitCount, pSubmits, fence); |
| } |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void VkDecoderSnapshot::vkCmdCopyBuffer2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyBufferInfo2* pCopyBufferInfo) { |
| mImpl->vkCmdCopyBuffer2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pCopyBufferInfo); |
| } |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void VkDecoderSnapshot::vkCmdCopyImage2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkCopyImageInfo2* pCopyImageInfo) { |
| mImpl->vkCmdCopyImage2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pCopyImageInfo); |
| } |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void VkDecoderSnapshot::vkCmdCopyBufferToImage2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { |
| mImpl->vkCmdCopyBufferToImage2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pCopyBufferToImageInfo); |
| } |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void VkDecoderSnapshot::vkCmdCopyImageToBuffer2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { |
| mImpl->vkCmdCopyImageToBuffer2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pCopyImageToBufferInfo); |
| } |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void VkDecoderSnapshot::vkCmdBlitImage2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkBlitImageInfo2* pBlitImageInfo) { |
| mImpl->vkCmdBlitImage2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| pBlitImageInfo); |
| } |
| #endif |
| #ifdef VK_KHR_copy_commands2 |
| void VkDecoderSnapshot::vkCmdResolveImage2KHR(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkResolveImageInfo2* pResolveImageInfo) { |
| mImpl->vkCmdResolveImage2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pResolveImageInfo); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance4 |
| void VkDecoderSnapshot::vkGetDeviceBufferMemoryRequirementsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetDeviceBufferMemoryRequirementsKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance4 |
| void VkDecoderSnapshot::vkGetDeviceImageMemoryRequirementsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { |
| mImpl->vkGetDeviceImageMemoryRequirementsKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance4 |
| void VkDecoderSnapshot::vkGetDeviceImageSparseMemoryRequirementsKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, |
| VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { |
| mImpl->vkGetDeviceImageSparseMemoryRequirementsKHR( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, pInfo, |
| pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance5 |
| void VkDecoderSnapshot::vkCmdBindIndexBuffer2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) { |
| mImpl->vkCmdBindIndexBuffer2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, buffer, offset, size, indexType); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance5 |
| void VkDecoderSnapshot::vkGetRenderingAreaGranularityKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity) { |
| mImpl->vkGetRenderingAreaGranularityKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pRenderingAreaInfo, pGranularity); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance5 |
| void VkDecoderSnapshot::vkGetDeviceImageSubresourceLayoutKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout) { |
| mImpl->vkGetDeviceImageSubresourceLayoutKHR(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, device, pInfo, pLayout); |
| } |
| #endif |
| #ifdef VK_KHR_maintenance5 |
| void VkDecoderSnapshot::vkGetImageSubresourceLayout2KHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, VkImage image, |
| const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { |
| mImpl->vkGetImageSubresourceLayout2KHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, image, pSubresource, pLayout); |
| } |
| #endif |
| #ifdef VK_KHR_line_rasterization |
| void VkDecoderSnapshot::vkCmdSetLineStippleKHR( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, uint16_t lineStipplePattern) { |
| mImpl->vkCmdSetLineStippleKHR(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, lineStippleFactor, lineStipplePattern); |
| } |
| #endif |
| #ifdef VK_ANDROID_native_buffer |
| void VkDecoderSnapshot::vkGetSwapchainGrallocUsageANDROID( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage) { |
| mImpl->vkGetSwapchainGrallocUsageANDROID(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, format, imageUsage, |
| grallocUsage); |
| } |
| #endif |
| #ifdef VK_ANDROID_native_buffer |
| void VkDecoderSnapshot::vkAcquireImageANDROID(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkImage image, int nativeFenceFd, |
| VkSemaphore semaphore, VkFence fence) { |
| mImpl->vkAcquireImageANDROID(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, image, nativeFenceFd, semaphore, fence); |
| } |
| #endif |
| #ifdef VK_ANDROID_native_buffer |
| void VkDecoderSnapshot::vkQueueSignalReleaseImageANDROID( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkQueue queue, |
| uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, |
| int* pNativeFenceFd) { |
| mImpl->vkQueueSignalReleaseImageANDROID(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, queue, waitSemaphoreCount, |
| pWaitSemaphores, image, pNativeFenceFd); |
| } |
| #endif |
| #ifdef VK_ANDROID_native_buffer |
| void VkDecoderSnapshot::vkGetSwapchainGrallocUsage2ANDROID( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkFormat format, VkImageUsageFlags imageUsage, |
| VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, |
| uint64_t* grallocProducerUsage) { |
| mImpl->vkGetSwapchainGrallocUsage2ANDROID( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, format, |
| imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage); |
| } |
| #endif |
| #ifdef VK_EXT_debug_report |
| void VkDecoderSnapshot::vkCreateDebugReportCallbackEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) { |
| mImpl->vkCreateDebugReportCallbackEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, instance, pCreateInfo, pAllocator, |
| pCallback); |
| } |
| #endif |
| #ifdef VK_EXT_debug_report |
| void VkDecoderSnapshot::vkDestroyDebugReportCallbackEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkInstance instance, |
| VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDebugReportCallbackEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| instance, callback, pAllocator); |
| } |
| #endif |
| #ifdef VK_EXT_debug_report |
| void VkDecoderSnapshot::vkDebugReportMessageEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkInstance instance, |
| VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, |
| size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) { |
| mImpl->vkDebugReportMessageEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, instance, |
| flags, objectType, object, location, messageCode, pLayerPrefix, |
| pMessage); |
| } |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void VkDecoderSnapshot::vkCmdBindTransformFeedbackBuffersEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) { |
| mImpl->vkCmdBindTransformFeedbackBuffersEXT(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, commandBuffer, firstBinding, |
| bindingCount, pBuffers, pOffsets, pSizes); |
| } |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void VkDecoderSnapshot::vkCmdBeginTransformFeedbackEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) { |
| mImpl->vkCmdBeginTransformFeedbackEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, firstCounterBuffer, counterBufferCount, |
| pCounterBuffers, pCounterBufferOffsets); |
| } |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void VkDecoderSnapshot::vkCmdEndTransformFeedbackEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, |
| const VkDeviceSize* pCounterBufferOffsets) { |
| mImpl->vkCmdEndTransformFeedbackEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, firstCounterBuffer, counterBufferCount, |
| pCounterBuffers, pCounterBufferOffsets); |
| } |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void VkDecoderSnapshot::vkCmdBeginQueryIndexedEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { |
| mImpl->vkCmdBeginQueryIndexedEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, queryPool, query, flags, index); |
| } |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void VkDecoderSnapshot::vkCmdEndQueryIndexedEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| VkQueryPool queryPool, uint32_t query, uint32_t index) { |
| mImpl->vkCmdEndQueryIndexedEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, queryPool, query, index); |
| } |
| #endif |
| #ifdef VK_EXT_transform_feedback |
| void VkDecoderSnapshot::vkCmdDrawIndirectByteCountEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, |
| VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) { |
| mImpl->vkCmdDrawIndirectByteCountEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, instanceCount, firstInstance, counterBuffer, |
| counterBufferOffset, counterOffset, vertexStride); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkSetDebugUtilsObjectNameEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkDebugUtilsObjectNameInfoEXT* pNameInfo) { |
| mImpl->vkSetDebugUtilsObjectNameEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pNameInfo); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkSetDebugUtilsObjectTagEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, |
| const VkDebugUtilsObjectTagInfoEXT* pTagInfo) { |
| mImpl->vkSetDebugUtilsObjectTagEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pTagInfo); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkQueueBeginDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo) { |
| mImpl->vkQueueBeginDebugUtilsLabelEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| queue, pLabelInfo); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkQueueEndDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue) { |
| mImpl->vkQueueEndDebugUtilsLabelEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| queue); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkQueueInsertDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| const VkDebugUtilsLabelEXT* pLabelInfo) { |
| mImpl->vkQueueInsertDebugUtilsLabelEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| queue, pLabelInfo); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkCmdBeginDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) { |
| mImpl->vkCmdBeginDebugUtilsLabelEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pLabelInfo); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkCmdEndDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) { |
| mImpl->vkCmdEndDebugUtilsLabelEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkCmdInsertDebugUtilsLabelEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| const VkDebugUtilsLabelEXT* pLabelInfo) { |
| mImpl->vkCmdInsertDebugUtilsLabelEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pLabelInfo); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkCreateDebugUtilsMessengerEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) { |
| mImpl->vkCreateDebugUtilsMessengerEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, instance, pCreateInfo, pAllocator, |
| pMessenger); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkDestroyDebugUtilsMessengerEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkInstance instance, |
| VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyDebugUtilsMessengerEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| instance, messenger, pAllocator); |
| } |
| #endif |
| #ifdef VK_EXT_debug_utils |
| void VkDecoderSnapshot::vkSubmitDebugUtilsMessageEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkInstance instance, |
| VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, |
| VkDebugUtilsMessageTypeFlagsEXT messageTypes, |
| const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) { |
| mImpl->vkSubmitDebugUtilsMessageEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| instance, messageSeverity, messageTypes, pCallbackData); |
| } |
| #endif |
| #ifdef VK_EXT_image_drm_format_modifier |
| void VkDecoderSnapshot::vkGetImageDrmFormatModifierPropertiesEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) { |
| mImpl->vkGetImageDrmFormatModifierPropertiesEXT(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, image, |
| pProperties); |
| } |
| #endif |
| #ifdef VK_EXT_external_memory_host |
| void VkDecoderSnapshot::vkGetMemoryHostPointerPropertiesEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, |
| VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) { |
| mImpl->vkGetMemoryHostPointerPropertiesEXT(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, handleType, |
| pHostPointer, pMemoryHostPointerProperties); |
| } |
| #endif |
| #ifdef VK_EXT_tooling_info |
| void VkDecoderSnapshot::vkGetPhysicalDeviceToolPropertiesEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, |
| VkPhysicalDevice physicalDevice, uint32_t* pToolCount, |
| VkPhysicalDeviceToolProperties* pToolProperties) { |
| mImpl->vkGetPhysicalDeviceToolPropertiesEXT(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, physicalDevice, |
| pToolCount, pToolProperties); |
| } |
| #endif |
| #ifdef VK_EXT_line_rasterization |
| void VkDecoderSnapshot::vkCmdSetLineStippleEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t lineStippleFactor, uint16_t lineStipplePattern) { |
| mImpl->vkCmdSetLineStippleEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, lineStippleFactor, lineStipplePattern); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetCullModeEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkCullModeFlags cullMode) { |
| mImpl->vkCmdSetCullModeEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| cullMode); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetFrontFaceEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkFrontFace frontFace) { |
| mImpl->vkCmdSetFrontFaceEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, frontFace); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetPrimitiveTopologyEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkPrimitiveTopology primitiveTopology) { |
| mImpl->vkCmdSetPrimitiveTopologyEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, primitiveTopology); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetViewportWithCountEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t viewportCount, const VkViewport* pViewports) { |
| mImpl->vkCmdSetViewportWithCountEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, viewportCount, pViewports); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetScissorWithCountEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t scissorCount, const VkRect2D* pScissors) { |
| mImpl->vkCmdSetScissorWithCountEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, scissorCount, pScissors); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdBindVertexBuffers2EXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, |
| const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { |
| mImpl->vkCmdBindVertexBuffers2EXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, |
| pSizes, pStrides); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetDepthTestEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthTestEnable) { |
| mImpl->vkCmdSetDepthTestEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthTestEnable); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetDepthWriteEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthWriteEnable) { |
| mImpl->vkCmdSetDepthWriteEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthWriteEnable); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetDepthCompareOpEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkCompareOp depthCompareOp) { |
| mImpl->vkCmdSetDepthCompareOpEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthCompareOp); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetDepthBoundsTestEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBoundsTestEnable) { |
| mImpl->vkCmdSetDepthBoundsTestEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthBoundsTestEnable); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetStencilTestEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 stencilTestEnable) { |
| mImpl->vkCmdSetStencilTestEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, stencilTestEnable); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state |
| void VkDecoderSnapshot::vkCmdSetStencilOpEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkStencilFaceFlags faceMask, VkStencilOp failOp, |
| VkStencilOp passOp, VkStencilOp depthFailOp, |
| VkCompareOp compareOp) { |
| mImpl->vkCmdSetStencilOpEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); |
| } |
| #endif |
| #ifdef VK_EXT_host_image_copy |
| void VkDecoderSnapshot::vkCopyMemoryToImageEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo) { |
| mImpl->vkCopyMemoryToImageEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCopyMemoryToImageInfo); |
| } |
| #endif |
| #ifdef VK_EXT_host_image_copy |
| void VkDecoderSnapshot::vkCopyImageToMemoryEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo) { |
| mImpl->vkCopyImageToMemoryEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCopyImageToMemoryInfo); |
| } |
| #endif |
| #ifdef VK_EXT_host_image_copy |
| void VkDecoderSnapshot::vkCopyImageToImageEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, |
| const VkCopyImageToImageInfo* pCopyImageToImageInfo) { |
| mImpl->vkCopyImageToImageEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCopyImageToImageInfo); |
| } |
| #endif |
| #ifdef VK_EXT_host_image_copy |
| void VkDecoderSnapshot::vkTransitionImageLayoutEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions) { |
| mImpl->vkTransitionImageLayoutEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, transitionCount, pTransitions); |
| } |
| #endif |
| #ifdef VK_EXT_host_image_copy |
| void VkDecoderSnapshot::vkGetImageSubresourceLayout2EXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, VkImage image, |
| const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout) { |
| mImpl->vkGetImageSubresourceLayout2EXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, image, pSubresource, pLayout); |
| } |
| #endif |
| #ifdef VK_EXT_swapchain_maintenance1 |
| void VkDecoderSnapshot::vkReleaseSwapchainImagesEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) { |
| mImpl->vkReleaseSwapchainImagesEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pReleaseInfo); |
| } |
| #endif |
| #ifdef VK_EXT_private_data |
| void VkDecoderSnapshot::vkCreatePrivateDataSlotEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkPrivateDataSlot* pPrivateDataSlot) { |
| mImpl->vkCreatePrivateDataSlotEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, pCreateInfo, pAllocator, |
| pPrivateDataSlot); |
| } |
| #endif |
| #ifdef VK_EXT_private_data |
| void VkDecoderSnapshot::vkDestroyPrivateDataSlotEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkPrivateDataSlot privateDataSlot, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkDestroyPrivateDataSlotEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, privateDataSlot, pAllocator); |
| } |
| #endif |
| #ifdef VK_EXT_private_data |
| void VkDecoderSnapshot::vkSetPrivateDataEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkObjectType objectType, uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, uint64_t data) { |
| mImpl->vkSetPrivateDataEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, objectType, objectHandle, privateDataSlot, data); |
| } |
| #endif |
| #ifdef VK_EXT_private_data |
| void VkDecoderSnapshot::vkGetPrivateDataEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkDevice device, VkObjectType objectType, |
| uint64_t objectHandle, |
| VkPrivateDataSlot privateDataSlot, uint64_t* pData) { |
| mImpl->vkGetPrivateDataEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, |
| objectType, objectHandle, privateDataSlot, pData); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state2 |
| void VkDecoderSnapshot::vkCmdSetPatchControlPointsEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| uint32_t patchControlPoints) { |
| mImpl->vkCmdSetPatchControlPointsEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, patchControlPoints); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state2 |
| void VkDecoderSnapshot::vkCmdSetRasterizerDiscardEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 rasterizerDiscardEnable) { |
| mImpl->vkCmdSetRasterizerDiscardEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, rasterizerDiscardEnable); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state2 |
| void VkDecoderSnapshot::vkCmdSetDepthBiasEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 depthBiasEnable) { |
| mImpl->vkCmdSetDepthBiasEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, depthBiasEnable); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state2 |
| void VkDecoderSnapshot::vkCmdSetLogicOpEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, VkLogicOp logicOp) { |
| mImpl->vkCmdSetLogicOpEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, commandBuffer, |
| logicOp); |
| } |
| #endif |
| #ifdef VK_EXT_extended_dynamic_state2 |
| void VkDecoderSnapshot::vkCmdSetPrimitiveRestartEnableEXT(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkBool32 primitiveRestartEnable) { |
| mImpl->vkCmdSetPrimitiveRestartEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, primitiveRestartEnable); |
| } |
| #endif |
| #ifdef VK_EXT_color_write_enable |
| void VkDecoderSnapshot::vkCmdSetColorWriteEnableEXT( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { |
| mImpl->vkCmdSetColorWriteEnableEXT(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, attachmentCount, pColorWriteEnables); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkMapMemoryIntoAddressSpaceGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkDeviceMemory memory, uint64_t* pAddress) { |
| mImpl->vkMapMemoryIntoAddressSpaceGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, memory, pAddress); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplateSizedGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, 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) { |
| mImpl->vkUpdateDescriptorSetWithTemplateSizedGOOGLE( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, descriptorSet, |
| descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, |
| pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, |
| pBufferInfos, pBufferViews); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkBeginCommandBufferAsyncGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| const VkCommandBufferBeginInfo* pBeginInfo) { |
| mImpl->vkBeginCommandBufferAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, pBeginInfo); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkEndCommandBufferAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer) { |
| mImpl->vkEndCommandBufferAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkResetCommandBufferAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, |
| VkCommandBuffer commandBuffer, |
| VkCommandBufferResetFlags flags) { |
| mImpl->vkResetCommandBufferAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, flags); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkCommandBufferHostSyncGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkCommandBuffer commandBuffer, |
| uint32_t needHostSync, uint32_t sequenceNumber) { |
| mImpl->vkCommandBufferHostSyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| commandBuffer, needHostSync, sequenceNumber); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkCreateImageWithRequirementsGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, |
| VkMemoryRequirements* pMemoryRequirements) { |
| mImpl->vkCreateImageWithRequirementsGOOGLE(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, input_result, device, pCreateInfo, |
| pAllocator, pImage, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkCreateBufferWithRequirementsGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, |
| VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) { |
| mImpl->vkCreateBufferWithRequirementsGOOGLE( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, device, pCreateInfo, |
| pAllocator, pBuffer, pMemoryRequirements); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkGetMemoryHostAddressInfoGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkResult input_result, VkDevice device, |
| VkDeviceMemory memory, uint64_t* pAddress, uint64_t* pSize, uint64_t* pHostmemId) { |
| mImpl->vkGetMemoryHostAddressInfoGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, memory, pAddress, pSize, |
| pHostmemId); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkFreeMemorySyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkResult input_result, |
| VkDevice device, VkDeviceMemory memory, |
| const VkAllocationCallbacks* pAllocator) { |
| mImpl->vkFreeMemorySyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| input_result, device, memory, pAllocator); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueHostSyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| uint32_t needHostSync, uint32_t sequenceNumber) { |
| mImpl->vkQueueHostSyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, queue, |
| needHostSync, sequenceNumber); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueSubmitAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| uint32_t submitCount, const VkSubmitInfo* pSubmits, |
| VkFence fence) { |
| mImpl->vkQueueSubmitAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, queue, |
| submitCount, pSubmits, fence); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueWaitIdleAsyncGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue) { |
| mImpl->vkQueueWaitIdleAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, queue); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueBindSparseAsyncGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkQueue queue, uint32_t bindInfoCount, |
| const VkBindSparseInfo* pBindInfo, VkFence fence) { |
| mImpl->vkQueueBindSparseAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| queue, bindInfoCount, pBindInfo, fence); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkGetLinearImageLayoutGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkDevice device, |
| VkFormat format, VkDeviceSize* pOffset, |
| VkDeviceSize* pRowPitchAlignment) { |
| mImpl->vkGetLinearImageLayoutGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, format, pOffset, pRowPitchAlignment); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkGetLinearImageLayout2GOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| const VkImageCreateInfo* pCreateInfo, VkDeviceSize* pOffset, VkDeviceSize* pRowPitchAlignment) { |
| mImpl->vkGetLinearImageLayout2GOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, pCreateInfo, pOffset, pRowPitchAlignment); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueFlushCommandsGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| VkCommandBuffer commandBuffer, |
| VkDeviceSize dataSize, const void* pData) { |
| mImpl->vkQueueFlushCommandsGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, queue, |
| commandBuffer, dataSize, pData); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueCommitDescriptorSetUpdatesGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkQueue queue, |
| uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools, |
| uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts, |
| const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool, |
| const uint32_t* pDescriptorSetPendingAllocation, |
| const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount, |
| const VkWriteDescriptorSet* pPendingDescriptorWrites) { |
| mImpl->vkQueueCommitDescriptorSetUpdatesGOOGLE( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, queue, descriptorPoolCount, |
| pDescriptorPools, descriptorSetCount, pSetLayouts, pDescriptorSetPoolIds, |
| pDescriptorSetWhichPool, pDescriptorSetPendingAllocation, pDescriptorWriteStartingIndices, |
| pendingDescriptorWriteCount, pPendingDescriptorWrites); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkCollectDescriptorPoolIdsGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkDevice device, |
| VkDescriptorPool descriptorPool, uint32_t* pPoolIdCount, uint64_t* pPoolIds) { |
| mImpl->vkCollectDescriptorPoolIdsGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, |
| device, descriptorPool, pPoolIdCount, pPoolIds); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueSignalReleaseImageANDROIDAsyncGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkQueue queue, |
| uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image) { |
| mImpl->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, queue, waitSemaphoreCount, |
| pWaitSemaphores, image); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueFlushCommandsFromAuxMemoryGOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, VkQueue queue, |
| VkCommandBuffer commandBuffer, VkDeviceMemory deviceMemory, VkDeviceSize dataOffset, |
| VkDeviceSize dataSize) { |
| mImpl->vkQueueFlushCommandsFromAuxMemoryGOOGLE(pool, apiCallHandle, apiCallPacket, |
| apiCallPacketSize, queue, commandBuffer, |
| deviceMemory, dataOffset, dataSize); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkGetBlobGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkDeviceMemory memory) { |
| mImpl->vkGetBlobGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, memory); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplateSized2GOOGLE( |
| gfxstream::base::BumpPool* pool, VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, 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) { |
| mImpl->vkUpdateDescriptorSetWithTemplateSized2GOOGLE( |
| pool, apiCallHandle, apiCallPacket, apiCallPacketSize, device, descriptorSet, |
| descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, |
| inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, |
| pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkQueueSubmitAsync2GOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, |
| size_t apiCallPacketSize, VkQueue queue, |
| uint32_t submitCount, |
| const VkSubmitInfo2* pSubmits, VkFence fence) { |
| mImpl->vkQueueSubmitAsync2GOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, queue, |
| submitCount, pSubmits, fence); |
| } |
| #endif |
| #ifdef VK_GOOGLE_gfxstream |
| void VkDecoderSnapshot::vkGetSemaphoreGOOGLE(gfxstream::base::BumpPool* pool, |
| VkSnapshotApiCallHandle apiCallHandle, |
| const uint8_t* apiCallPacket, size_t apiCallPacketSize, |
| VkResult input_result, VkDevice device, |
| VkSemaphore semaphore, uint64_t syncId) { |
| mImpl->vkGetSemaphoreGOOGLE(pool, apiCallHandle, apiCallPacket, apiCallPacketSize, input_result, |
| device, semaphore, syncId); |
| } |
| #endif |
| |
| } // namespace vk |
| } // namespace gfxstream |
