296 lines
15 KiB
C++
296 lines
15 KiB
C++
// copyright (c) 2022 the android open source project
|
|
//
|
|
// licensed under the apache license, version 2.0 (the "license");
|
|
// you may not use this file except in compliance with the license.
|
|
// you may obtain a copy of the license at
|
|
//
|
|
// http://www.apache.org/licenses/license-2.0
|
|
//
|
|
// unless required by applicable law or agreed to in writing, software
|
|
// distributed under the license is distributed on an "as is" basis,
|
|
// without warranties or conditions of any kind, either express or implied.
|
|
// see the license for the specific language governing permissions and
|
|
// limitations under the license.
|
|
|
|
#pragma once
|
|
|
|
#include "stream-servers/vulkan/VkDecoderGlobalState.h"
|
|
#include "stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.h"
|
|
#include "vulkan/vulkan.h"
|
|
|
|
namespace gfxstream {
|
|
namespace vk {
|
|
namespace testing {
|
|
|
|
// TODO(gregschlom): This class should be auto-generated
|
|
class VkDecoderTestDispatch {
|
|
public:
|
|
VkDecoderTestDispatch(VulkanDispatch* vk, android::base::BumpPool* bp,
|
|
VkDecoderContext* decoderContext)
|
|
: mVk(vk), mDgs(VkDecoderGlobalState::get()), mBp(bp), mDecoderContext(decoderContext) {}
|
|
|
|
// Vulkan API wrappers - please keep sorted alphabetically
|
|
//
|
|
// These methods call into VkDecoderGlobalState (or VulkanDispatch if the method isn't
|
|
// implemented in VkDecoderGlobalState), while taking care of unboxing the parameters as
|
|
// needed.
|
|
|
|
VkResult vkAllocateCommandBuffers(VkDevice device,
|
|
const VkCommandBufferAllocateInfo* pAllocateInfo,
|
|
VkCommandBuffer* pCommandBuffers) {
|
|
return mDgs->on_vkAllocateCommandBuffers(mBp, device, pAllocateInfo, pCommandBuffers);
|
|
}
|
|
|
|
VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
|
|
const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
|
|
return mDgs->on_vkAllocateMemory(mBp, device, pAllocateInfo, pAllocator, pMemory);
|
|
}
|
|
|
|
VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
|
|
const VkCommandBufferBeginInfo* pBeginInfo) {
|
|
return mDgs->on_vkBeginCommandBuffer(mBp, commandBuffer, pBeginInfo,
|
|
*mDecoderContext);
|
|
}
|
|
|
|
VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
|
|
VkDeviceSize memoryOffset) {
|
|
return mDgs->on_vkBindBufferMemory(mBp, device, unbox_VkBuffer(buffer),
|
|
unbox_VkDeviceMemory(memory), memoryOffset);
|
|
}
|
|
|
|
VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
|
|
VkDeviceSize memoryOffset) {
|
|
return mDgs->on_vkBindImageMemory(mBp, device, unbox_VkImage(image),
|
|
unbox_VkDeviceMemory(memory), memoryOffset);
|
|
}
|
|
|
|
void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkImage dstImage,
|
|
VkImageLayout dstImageLayout, uint32_t regionCount,
|
|
const VkImageBlit* pRegions, VkFilter filter) {
|
|
return mVk->vkCmdBlitImage(unbox_VkCommandBuffer(commandBuffer), unbox_VkImage(srcImage),
|
|
srcImageLayout, unbox_VkImage(dstImage), dstImageLayout,
|
|
regionCount, pRegions, filter);
|
|
}
|
|
void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
|
|
VkImageLayout dstImageLayout, uint32_t regionCount,
|
|
const VkBufferImageCopy* pRegions) {
|
|
mDgs->on_vkCmdCopyBufferToImage(mBp, commandBuffer, unbox_VkBuffer(srcBuffer),
|
|
unbox_VkImage(dstImage), dstImageLayout, regionCount,
|
|
pRegions, *mDecoderContext);
|
|
}
|
|
|
|
void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkImage dstImage,
|
|
VkImageLayout dstImageLayout, uint32_t regionCount,
|
|
const VkImageCopy* pRegions) {
|
|
mDgs->on_vkCmdCopyImage(mBp, commandBuffer, unbox_VkImage(srcImage), srcImageLayout,
|
|
unbox_VkImage(dstImage), dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
void vkCmdPipelineBarrier(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) {
|
|
mDgs->on_vkCmdPipelineBarrier(mBp, commandBuffer, srcStageMask, dstStageMask,
|
|
dependencyFlags, memoryBarrierCount, pMemoryBarriers,
|
|
bufferMemoryBarrierCount, pBufferMemoryBarriers,
|
|
imageMemoryBarrierCount, pImageMemoryBarriers);
|
|
}
|
|
|
|
void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkBuffer dstBuffer,
|
|
uint32_t regionCount, const VkBufferImageCopy* pRegions) {
|
|
mDgs->on_vkCmdCopyImageToBuffer(mBp, commandBuffer, unbox_VkImage(srcImage), srcImageLayout,
|
|
unbox_VkBuffer(dstBuffer), regionCount, pRegions);
|
|
}
|
|
|
|
VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
|
|
return mDgs->on_vkCreateBuffer(mBp, device, pCreateInfo, pAllocator, pBuffer);
|
|
}
|
|
|
|
VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkCommandPool* pCommandPool) {
|
|
return mDgs->on_vkCreateCommandPool(mBp, device, pCreateInfo, pAllocator, pCommandPool);
|
|
}
|
|
|
|
VkResult vkCreateDebugUtilsMessengerEXT(VkInstance instance,
|
|
const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator,
|
|
VkDebugUtilsMessengerEXT* pDebugMessenger) {
|
|
instance = unbox_VkInstance(instance);
|
|
auto func = (PFN_vkCreateDebugUtilsMessengerEXT)mVk->vkGetInstanceProcAddr(
|
|
instance, "vkCreateDebugUtilsMessengerEXT");
|
|
if (func != nullptr) {
|
|
return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
|
|
} else {
|
|
return VK_ERROR_EXTENSION_NOT_PRESENT;
|
|
}
|
|
}
|
|
|
|
VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
|
|
return mDgs->on_vkCreateDevice(mBp, physicalDevice, pCreateInfo, pAllocator, pDevice);
|
|
}
|
|
|
|
VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
|
|
mDgs->transformImpl_VkImageCreateInfo_tohost(pCreateInfo, 1);
|
|
return mDgs->on_vkCreateImage(mBp, device, pCreateInfo, pAllocator, pImage);
|
|
}
|
|
|
|
VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
|
|
return mDgs->on_vkCreateImageView(mBp, device, pCreateInfo, pAllocator, pView);
|
|
}
|
|
|
|
VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
|
|
const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
|
|
return mDgs->on_vkCreateInstance(mBp, pCreateInfo, pAllocator, pInstance);
|
|
}
|
|
|
|
void vkDestroyBuffer(VkDevice device, VkBuffer buffer,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkDestroyBuffer(mBp, device, unbox_VkBuffer(buffer), pAllocator);
|
|
delete_VkBuffer(buffer);
|
|
}
|
|
|
|
void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkDestroyCommandPool(mBp, device, unbox_VkCommandPool(commandPool), pAllocator);
|
|
delete_VkCommandPool(commandPool);
|
|
}
|
|
|
|
void vkDestroyDebugUtilsMessengerEXT(VkInstance instance,
|
|
VkDebugUtilsMessengerEXT debugMessenger,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
instance = unbox_VkInstance(instance);
|
|
auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)mVk->vkGetInstanceProcAddr(
|
|
instance, "vkDestroyDebugUtilsMessengerEXT");
|
|
if (func != nullptr) {
|
|
func(instance, debugMessenger, pAllocator);
|
|
}
|
|
}
|
|
|
|
void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkDestroyDevice(mBp, device, pAllocator);
|
|
}
|
|
|
|
void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkDestroyImage(mBp, device, unbox_VkImage(image), pAllocator);
|
|
delete_VkImage(image);
|
|
}
|
|
|
|
void vkDestroyImageView(VkDevice device, VkImageView imageView,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkDestroyImageView(mBp, device, unbox_VkImageView(imageView), pAllocator);
|
|
delete_VkImageView(imageView);
|
|
}
|
|
|
|
void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkDestroyInstance(mBp, instance, pAllocator);
|
|
}
|
|
|
|
VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
|
|
return mDgs->on_vkEndCommandBuffer(mBp, commandBuffer, *mDecoderContext);
|
|
}
|
|
|
|
VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
|
|
VkLayerProperties* pProperties) {
|
|
return mVk->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
|
|
}
|
|
|
|
VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* physicalDeviceCount,
|
|
VkPhysicalDevice* physicalDevices) {
|
|
return mDgs->on_vkEnumeratePhysicalDevices(mBp, instance, physicalDeviceCount,
|
|
physicalDevices);
|
|
}
|
|
|
|
void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
|
|
uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
|
|
mDgs->on_vkFreeCommandBuffers(mBp, device, unbox_VkCommandPool(commandPool),
|
|
commandBufferCount, pCommandBuffers);
|
|
// Calling delete_VkCommandBuffer is normally done in the decoder, so we have to do it here.
|
|
for (int i = 0; i < commandBufferCount; ++i) {
|
|
delete_VkCommandBuffer(unboxed_to_boxed_VkCommandBuffer(pCommandBuffers[i]));
|
|
}
|
|
}
|
|
|
|
void vkFreeMemory(VkDevice device, VkDeviceMemory memory,
|
|
const VkAllocationCallbacks* pAllocator) {
|
|
mDgs->on_vkFreeMemory(mBp, device, unbox_VkDeviceMemory(memory), pAllocator);
|
|
delete_VkDeviceMemory(memory);
|
|
}
|
|
|
|
void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
|
|
VkMemoryRequirements* pMemoryRequirements) {
|
|
mVk->vkGetBufferMemoryRequirements(unbox_VkDevice(device), unbox_VkBuffer(buffer),
|
|
pMemoryRequirements);
|
|
}
|
|
|
|
void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
|
|
VkQueue* pQueue) {
|
|
mDgs->on_vkGetDeviceQueue(mBp, device, queueFamilyIndex, queueIndex, pQueue);
|
|
}
|
|
|
|
void vkGetImageMemoryRequirements(VkDevice device, VkImage image,
|
|
VkMemoryRequirements* pMemoryRequirements) {
|
|
mDgs->on_vkGetImageMemoryRequirements(mBp, device, unbox_VkImage(image),
|
|
pMemoryRequirements);
|
|
}
|
|
|
|
void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
|
|
VkFormatProperties* pFormatProperties) {
|
|
mDgs->on_vkGetPhysicalDeviceFormatProperties(mBp, physicalDevice, format,
|
|
pFormatProperties);
|
|
}
|
|
void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
|
|
VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
|
|
mDgs->on_vkGetPhysicalDeviceMemoryProperties(mBp, physicalDevice, pMemoryProperties);
|
|
}
|
|
|
|
VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits,
|
|
VkFence fence) {
|
|
return mDgs->on_vkQueueSubmit(mBp, queue, submitCount, pSubmits, fence);
|
|
}
|
|
|
|
VkResult vkQueueWaitIdle(VkQueue queue) { return mDgs->on_vkQueueWaitIdle(mBp, queue); }
|
|
|
|
VkResult vkDeviceWaitIdle(VkDevice device) {
|
|
return mVk->vkDeviceWaitIdle(unbox_VkDevice(device));
|
|
}
|
|
|
|
void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
|
|
uint32_t* pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties* pQueueFamilyProperties) {
|
|
mVk->vkGetPhysicalDeviceQueueFamilyProperties(unbox_VkPhysicalDevice(physicalDevice),
|
|
pQueueFamilyPropertyCount,
|
|
pQueueFamilyProperties);
|
|
}
|
|
|
|
VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
|
|
VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
|
|
return mDgs->on_vkMapMemory(mBp, device, unbox_VkDeviceMemory(memory), offset, size, flags,
|
|
ppData);
|
|
}
|
|
|
|
void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
|
|
mDgs->on_vkUnmapMemory(mBp, device, unbox_VkDeviceMemory(memory));
|
|
}
|
|
|
|
private:
|
|
VulkanDispatch* mVk;
|
|
VkDecoderGlobalState* mDgs;
|
|
android::base::BumpPool* mBp;
|
|
VkDecoderContext* mDecoderContext;
|
|
};
|
|
|
|
} // namespace testing
|
|
} // namespace vk
|
|
} // namespace gfxstream
|