fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 07:28:11 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

venus: update venus-protocol headers to use accessors

Browse source 
Switch to the newly added vn_instance_submit_command accessors.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/10437>
This commit is contained in:
Chia-I Wu 2021-04-22 11:21:24 -07:00
parent 3c8255f602
commit b1f25da0b4
28 changed files with 2269 additions and 2080 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/virtio/venus-protocol/vn_protocol_driver.h
View file

@ -1,4 +1,4 @@
/* This file is generated by venus-protocol git-0f26f4b9. */
/* This file is generated by venus-protocol git-62efb3c8. */
/*
* Copyright 2020 Google LLC

184
src/virtio/venus-protocol/vn_protocol_driver_buffer.h
View file

@ -1086,15 +1086,15 @@ static inline void vn_submit_vkGetBufferMemoryRequirements(struct vn_instance *v
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements_reply(device, buffer, pMemoryRequirements) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetBufferMemoryRequirements(&submit->command, cmd_flags, device, buffer, pMemoryRequirements);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements_reply(device, buffer, pMemoryRequirements) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetBufferMemoryRequirements(enc, cmd_flags, device, buffer, pMemoryRequirements);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkBindBufferMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
@ -1107,15 +1107,15 @@ static inline void vn_submit_vkBindBufferMemory(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory_reply(device, buffer, memory, memoryOffset) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkBindBufferMemory(&submit->command, cmd_flags, device, buffer, memory, memoryOffset);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory_reply(device, buffer, memory, memoryOffset) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkBindBufferMemory(enc, cmd_flags, device, buffer, memory, memoryOffset);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer, struct vn_instance_submit_command *submit)
@ -1128,15 +1128,15 @@ static inline void vn_submit_vkCreateBuffer(struct vn_instance *vn_instance, VkC
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBuffer_reply(device, pCreateInfo, pAllocator, pBuffer) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateBuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pBuffer);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBuffer_reply(device, pCreateInfo, pAllocator, pBuffer) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateBuffer(enc, cmd_flags, device, pCreateInfo, pAllocator, pBuffer);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyBuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -1149,15 +1149,15 @@ static inline void vn_submit_vkDestroyBuffer(struct vn_instance *vn_instance, Vk
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBuffer_reply(device, buffer, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyBuffer(&submit->command, cmd_flags, device, buffer, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBuffer_reply(device, buffer, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyBuffer(enc, cmd_flags, device, buffer, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkBindBufferMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
@ -1170,15 +1170,15 @@ static inline void vn_submit_vkBindBufferMemory2(struct vn_instance *vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkBindBufferMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindBufferMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkBindBufferMemory2(enc, cmd_flags, device, bindInfoCount, pBindInfos);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
@ -1191,15 +1191,15 @@ static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance *
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetBufferMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetBufferMemoryRequirements2(enc, cmd_flags, device, pInfo, pMemoryRequirements);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit)
@ -1212,15 +1212,15 @@ static inline void vn_submit_vkGetBufferOpaqueCaptureAddress(struct vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(device, pInfo) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetBufferOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferOpaqueCaptureAddress_reply(device, pInfo) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetBufferOpaqueCaptureAddress(enc, cmd_flags, device, pInfo);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetBufferDeviceAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferDeviceAddressInfo* pInfo, struct vn_instance_submit_command *submit)
@ -1233,24 +1233,25 @@ static inline void vn_submit_vkGetBufferDeviceAddress(struct vn_instance *vn_ins
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferDeviceAddress_reply(device, pInfo) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetBufferDeviceAddress(&submit->command, cmd_flags, device, pInfo);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetBufferDeviceAddress_reply(device, pInfo) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetBufferDeviceAddress(enc, cmd_flags, device, pInfo);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_call_vkGetBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetBufferMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pMemoryRequirements, &submit);
if (submit.reply_bo) {
vn_decode_vkGetBufferMemoryRequirements_reply(&submit.reply, device, buffer, pMemoryRequirements);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetBufferMemoryRequirements_reply(dec, device, buffer, pMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1264,9 +1265,10 @@ static inline VkResult vn_call_vkBindBufferMemory(struct vn_instance *vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkBindBufferMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, memory, memoryOffset, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkBindBufferMemory_reply(&submit.reply, device, buffer, memory, memoryOffset);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkBindBufferMemory_reply(dec, device, buffer, memory, memoryOffset);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1283,9 +1285,10 @@ static inline VkResult vn_call_vkCreateBuffer(struct vn_instance *vn_instance, V
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pBuffer, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateBuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pBuffer);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateBuffer_reply(dec, device, pCreateInfo, pAllocator, pBuffer);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1302,9 +1305,10 @@ static inline void vn_call_vkDestroyBuffer(struct vn_instance *vn_instance, VkDe
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyBuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, buffer, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyBuffer_reply(&submit.reply, device, buffer, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyBuffer_reply(dec, device, buffer, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1318,9 +1322,10 @@ static inline VkResult vn_call_vkBindBufferMemory2(struct vn_instance *vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkBindBufferMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkBindBufferMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkBindBufferMemory2_reply(dec, device, bindInfoCount, pBindInfos);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1337,9 +1342,10 @@ static inline void vn_call_vkGetBufferMemoryRequirements2(struct vn_instance *vn
{
struct vn_instance_submit_command submit;
vn_submit_vkGetBufferMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
if (submit.reply_bo) {
vn_decode_vkGetBufferMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetBufferMemoryRequirements2_reply(dec, device, pInfo, pMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1353,9 +1359,10 @@ static inline uint64_t vn_call_vkGetBufferOpaqueCaptureAddress(struct vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkGetBufferOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
if (submit.reply_bo) {
const uint64_t ret = vn_decode_vkGetBufferOpaqueCaptureAddress_reply(&submit.reply, device, pInfo);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const uint64_t ret = vn_decode_vkGetBufferOpaqueCaptureAddress_reply(dec, device, pInfo);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1372,9 +1379,10 @@ static inline VkDeviceAddress vn_call_vkGetBufferDeviceAddress(struct vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkGetBufferDeviceAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
if (submit.reply_bo) {
const VkDeviceAddress ret = vn_decode_vkGetBufferDeviceAddress_reply(&submit.reply, device, pInfo);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkDeviceAddress ret = vn_decode_vkGetBufferDeviceAddress_reply(dec, device, pInfo);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

46
src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h
View file

@ -206,15 +206,15 @@ static inline void vn_submit_vkCreateBufferView(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateBufferView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateBufferView(enc, cmd_flags, device, pCreateInfo, pAllocator, pView);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -227,24 +227,25 @@ static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyBufferView(&submit->command, cmd_flags, device, bufferView, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyBufferView(enc, cmd_flags, device, bufferView, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateBufferView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateBufferView_reply(dec, device, pCreateInfo, pAllocator, pView);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -261,9 +262,10 @@ static inline void vn_call_vkDestroyBufferView(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bufferView, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyBufferView_reply(&submit.reply, device, bufferView, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyBufferView_reply(dec, device, bufferView, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

1426
src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h
View file

File diff suppressed because it is too large Load diff

92
src/virtio/venus-protocol/vn_protocol_driver_command_pool.h
View file

@ -302,15 +302,15 @@ static inline void vn_submit_vkCreateCommandPool(struct vn_instance *vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateCommandPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateCommandPool(enc, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -323,15 +323,15 @@ static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyCommandPool(&submit->command, cmd_flags, device, commandPool, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyCommandPool(enc, cmd_flags, device, commandPool, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, struct vn_instance_submit_command *submit)
@ -344,15 +344,15 @@ static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkResetCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkResetCommandPool(enc, cmd_flags, device, commandPool, flags);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, struct vn_instance_submit_command *submit)
@ -365,24 +365,25 @@ static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkTrimCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkTrimCommandPool(enc, cmd_flags, device, commandPool, flags);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pCommandPool, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateCommandPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pCommandPool);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateCommandPool_reply(dec, device, pCreateInfo, pAllocator, pCommandPool);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -399,9 +400,10 @@ static inline void vn_call_vkDestroyCommandPool(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyCommandPool_reply(&submit.reply, device, commandPool, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyCommandPool_reply(dec, device, commandPool, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -415,9 +417,10 @@ static inline VkResult vn_call_vkResetCommandPool(struct vn_instance *vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkResetCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkResetCommandPool_reply(&submit.reply, device, commandPool, flags);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkResetCommandPool_reply(dec, device, commandPool, flags);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -434,9 +437,10 @@ static inline void vn_call_vkTrimCommandPool(struct vn_instance *vn_instance, Vk
{
struct vn_instance_submit_command submit;
vn_submit_vkTrimCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
if (submit.reply_bo) {
vn_decode_vkTrimCommandPool_reply(&submit.reply, device, commandPool, flags);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkTrimCommandPool_reply(dec, device, commandPool, flags);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

69
src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h
View file

@ -288,15 +288,15 @@ static inline void vn_submit_vkCreateDescriptorPool(struct vn_instance *vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateDescriptorPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateDescriptorPool(enc, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -309,15 +309,15 @@ static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_inst
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyDescriptorPool(enc, cmd_flags, device, descriptorPool, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, struct vn_instance_submit_command *submit)
@ -330,24 +330,25 @@ static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkResetDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, flags);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkResetDescriptorPool(enc, cmd_flags, device, descriptorPool, flags);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorPool);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(dec, device, pCreateInfo, pAllocator, pDescriptorPool);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -364,9 +365,10 @@ static inline void vn_call_vkDestroyDescriptorPool(struct vn_instance *vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyDescriptorPool_reply(&submit.reply, device, descriptorPool, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyDescriptorPool_reply(dec, device, descriptorPool, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -380,9 +382,10 @@ static inline VkResult vn_call_vkResetDescriptorPool(struct vn_instance *vn_inst
{
struct vn_instance_submit_command submit;
vn_submit_vkResetDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, flags, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkResetDescriptorPool_reply(&submit.reply, device, descriptorPool, flags);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkResetDescriptorPool_reply(dec, device, descriptorPool, flags);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

69
src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h
View file

@ -634,15 +634,15 @@ static inline void vn_submit_vkAllocateDescriptorSets(struct vn_instance *vn_ins
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateDescriptorSets_reply(device, pAllocateInfo, pDescriptorSets) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkAllocateDescriptorSets(&submit->command, cmd_flags, device, pAllocateInfo, pDescriptorSets);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateDescriptorSets_reply(device, pAllocateInfo, pDescriptorSets) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkAllocateDescriptorSets(enc, cmd_flags, device, pAllocateInfo, pDescriptorSets);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
@ -655,15 +655,15 @@ static inline void vn_submit_vkFreeDescriptorSets(struct vn_instance *vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeDescriptorSets_reply(device, descriptorPool, descriptorSetCount, pDescriptorSets) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkFreeDescriptorSets(&submit->command, cmd_flags, device, descriptorPool, descriptorSetCount, pDescriptorSets);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeDescriptorSets_reply(device, descriptorPool, descriptorSetCount, pDescriptorSets) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkFreeDescriptorSets(enc, cmd_flags, device, descriptorPool, descriptorSetCount, pDescriptorSets);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies, struct vn_instance_submit_command *submit)
@ -676,24 +676,25 @@ static inline void vn_submit_vkUpdateDescriptorSets(struct vn_instance *vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUpdateDescriptorSets_reply(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkUpdateDescriptorSets(&submit->command, cmd_flags, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUpdateDescriptorSets_reply(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkUpdateDescriptorSets(enc, cmd_flags, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
{
struct vn_instance_submit_command submit;
vn_submit_vkAllocateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pDescriptorSets, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkAllocateDescriptorSets_reply(&submit.reply, device, pAllocateInfo, pDescriptorSets);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkAllocateDescriptorSets_reply(dec, device, pAllocateInfo, pDescriptorSets);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -710,9 +711,10 @@ static inline VkResult vn_call_vkFreeDescriptorSets(struct vn_instance *vn_insta
{
struct vn_instance_submit_command submit;
vn_submit_vkFreeDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkFreeDescriptorSets_reply(&submit.reply, device, descriptorPool, descriptorSetCount, pDescriptorSets);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkFreeDescriptorSets_reply(dec, device, descriptorPool, descriptorSetCount, pDescriptorSets);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -729,9 +731,10 @@ static inline void vn_call_vkUpdateDescriptorSets(struct vn_instance *vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkUpdateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
if (submit.reply_bo) {
vn_decode_vkUpdateDescriptorSets_reply(&submit.reply, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkUpdateDescriptorSets_reply(dec, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

69
src/virtio/venus-protocol/vn_protocol_driver_descriptor_set_layout.h
View file

@ -695,15 +695,15 @@ static inline void vn_submit_vkCreateDescriptorSetLayout(struct vn_instance *vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorSetLayout_reply(device, pCreateInfo, pAllocator, pSetLayout) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateDescriptorSetLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSetLayout);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorSetLayout_reply(device, pCreateInfo, pAllocator, pSetLayout) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateDescriptorSetLayout(enc, cmd_flags, device, pCreateInfo, pAllocator, pSetLayout);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -716,15 +716,15 @@ static inline void vn_submit_vkDestroyDescriptorSetLayout(struct vn_instance *vn
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorSetLayout_reply(device, descriptorSetLayout, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyDescriptorSetLayout(&submit->command, cmd_flags, device, descriptorSetLayout, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorSetLayout_reply(device, descriptorSetLayout, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyDescriptorSetLayout(enc, cmd_flags, device, descriptorSetLayout, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, struct vn_instance_submit_command *submit)
@ -737,24 +737,25 @@ static inline void vn_submit_vkGetDescriptorSetLayoutSupport(struct vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(device, pCreateInfo, pSupport) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetDescriptorSetLayoutSupport(&submit->command, cmd_flags, device, pCreateInfo, pSupport);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(device, pCreateInfo, pSupport) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDescriptorSetLayoutSupport(enc, cmd_flags, device, pCreateInfo, pSupport);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSetLayout, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateDescriptorSetLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pSetLayout);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateDescriptorSetLayout_reply(dec, device, pCreateInfo, pAllocator, pSetLayout);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -771,9 +772,10 @@ static inline void vn_call_vkDestroyDescriptorSetLayout(struct vn_instance *vn_i
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorSetLayout, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyDescriptorSetLayout_reply(&submit.reply, device, descriptorSetLayout, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyDescriptorSetLayout_reply(dec, device, descriptorSetLayout, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -787,9 +789,10 @@ static inline void vn_call_vkGetDescriptorSetLayoutSupport(struct vn_instance *v
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pSupport, &submit);
if (submit.reply_bo) {
vn_decode_vkGetDescriptorSetLayoutSupport_reply(&submit.reply, device, pCreateInfo, pSupport);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDescriptorSetLayoutSupport_reply(dec, device, pCreateInfo, pSupport);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

46
src/virtio/venus-protocol/vn_protocol_driver_descriptor_update_template.h
View file

@ -250,15 +250,15 @@ static inline void vn_submit_vkCreateDescriptorUpdateTemplate(struct vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateDescriptorUpdateTemplate(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateDescriptorUpdateTemplate(enc, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -271,24 +271,25 @@ static inline void vn_submit_vkDestroyDescriptorUpdateTemplate(struct vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(device, descriptorUpdateTemplate, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyDescriptorUpdateTemplate(&submit->command, cmd_flags, device, descriptorUpdateTemplate, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(device, descriptorUpdateTemplate, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyDescriptorUpdateTemplate(enc, cmd_flags, device, descriptorUpdateTemplate, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateDescriptorUpdateTemplate_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateDescriptorUpdateTemplate_reply(dec, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -305,9 +306,10 @@ static inline void vn_call_vkDestroyDescriptorUpdateTemplate(struct vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorUpdateTemplate, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyDescriptorUpdateTemplate_reply(&submit.reply, device, descriptorUpdateTemplate, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyDescriptorUpdateTemplate_reply(dec, device, descriptorUpdateTemplate, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

621
src/virtio/venus-protocol/vn_protocol_driver_device.h
View file

@ -12572,15 +12572,15 @@ static inline void vn_submit_vkEnumeratePhysicalDevices(struct vn_instance *vn_i
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumeratePhysicalDevices(&submit->command, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDevices_reply(instance, pPhysicalDeviceCount, pPhysicalDevices) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumeratePhysicalDevices(enc, cmd_flags, instance, pPhysicalDeviceCount, pPhysicalDevices);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties, struct vn_instance_submit_command *submit)
@ -12593,15 +12593,15 @@ static inline void vn_submit_vkGetPhysicalDeviceProperties(struct vn_instance *v
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceProperties(&submit->command, cmd_flags, physicalDevice, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties_reply(physicalDevice, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceProperties(enc, cmd_flags, physicalDevice, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
@ -12614,15 +12614,15 @@ static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties, struct vn_instance_submit_command *submit)
@ -12635,15 +12635,15 @@ static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties(struct vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceMemoryProperties(&submit->command, cmd_flags, physicalDevice, pMemoryProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties_reply(physicalDevice, pMemoryProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceMemoryProperties(enc, cmd_flags, physicalDevice, pMemoryProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures, struct vn_instance_submit_command *submit)
@ -12656,15 +12656,15 @@ static inline void vn_submit_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceFeatures(&submit->command, cmd_flags, physicalDevice, pFeatures);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures_reply(physicalDevice, pFeatures) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceFeatures(enc, cmd_flags, physicalDevice, pFeatures);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties, struct vn_instance_submit_command *submit)
@ -12677,15 +12677,15 @@ static inline void vn_submit_vkGetPhysicalDeviceFormatProperties(struct vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceFormatProperties(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties_reply(physicalDevice, format, pFormatProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceFormatProperties(enc, cmd_flags, physicalDevice, format, pFormatProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties, struct vn_instance_submit_command *submit)
@ -12698,15 +12698,15 @@ static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties(struct vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties_reply(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, struct vn_instance_submit_command *submit)
@ -12719,15 +12719,15 @@ static inline void vn_submit_vkCreateDevice(struct vn_instance *vn_instance, VkC
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateDevice(&submit->command, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDevice_reply(physicalDevice, pCreateInfo, pAllocator, pDevice) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateDevice(enc, cmd_flags, physicalDevice, pCreateInfo, pAllocator, pDevice);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -12740,15 +12740,15 @@ static inline void vn_submit_vkDestroyDevice(struct vn_instance *vn_instance, Vk
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyDevice(&submit->command, cmd_flags, device, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDevice_reply(device, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyDevice(enc, cmd_flags, device, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
@ -12761,15 +12761,15 @@ static inline void vn_submit_vkEnumerateDeviceLayerProperties(struct vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumerateDeviceLayerProperties(&submit->command, cmd_flags, physicalDevice, pPropertyCount, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceLayerProperties_reply(physicalDevice, pPropertyCount, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumerateDeviceLayerProperties(enc, cmd_flags, physicalDevice, pPropertyCount, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
@ -12782,15 +12782,15 @@ static inline void vn_submit_vkEnumerateDeviceExtensionProperties(struct vn_inst
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumerateDeviceExtensionProperties(&submit->command, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateDeviceExtensionProperties_reply(physicalDevice, pLayerName, pPropertyCount, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumerateDeviceExtensionProperties(enc, cmd_flags, physicalDevice, pLayerName, pPropertyCount, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, struct vn_instance_submit_command *submit)
@ -12803,15 +12803,15 @@ static inline void vn_submit_vkGetDeviceQueue(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetDeviceQueue(&submit->command, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue_reply(device, queueFamilyIndex, queueIndex, pQueue) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceQueue(enc, cmd_flags, device, queueFamilyIndex, queueIndex, pQueue);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, struct vn_instance_submit_command *submit)
@ -12824,15 +12824,15 @@ static inline void vn_submit_vkDeviceWaitIdle(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDeviceWaitIdle(&submit->command, cmd_flags, device);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDeviceWaitIdle_reply(device) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDeviceWaitIdle(enc, cmd_flags, device);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties, struct vn_instance_submit_command *submit)
@ -12845,15 +12845,15 @@ static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(stru
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(&submit->command, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties_reply(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties(enc, cmd_flags, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures, struct vn_instance_submit_command *submit)
@ -12866,15 +12866,15 @@ static inline void vn_submit_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceFeatures2(&submit->command, cmd_flags, physicalDevice, pFeatures);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFeatures2_reply(physicalDevice, pFeatures) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceFeatures2(enc, cmd_flags, physicalDevice, pFeatures);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties, struct vn_instance_submit_command *submit)
@ -12887,15 +12887,15 @@ static inline void vn_submit_vkGetPhysicalDeviceProperties2(struct vn_instance *
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceProperties2(&submit->command, cmd_flags, physicalDevice, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceProperties2_reply(physicalDevice, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceProperties2(enc, cmd_flags, physicalDevice, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties, struct vn_instance_submit_command *submit)
@ -12908,15 +12908,15 @@ static inline void vn_submit_vkGetPhysicalDeviceFormatProperties2(struct vn_inst
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceFormatProperties2(&submit->command, cmd_flags, physicalDevice, format, pFormatProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceFormatProperties2_reply(physicalDevice, format, pFormatProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceFormatProperties2(enc, cmd_flags, physicalDevice, format, pFormatProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties, struct vn_instance_submit_command *submit)
@ -12929,15 +12929,15 @@ static inline void vn_submit_vkGetPhysicalDeviceImageFormatProperties2(struct vn
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceImageFormatProperties2_reply(physicalDevice, pImageFormatInfo, pImageFormatProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceImageFormatProperties2(enc, cmd_flags, physicalDevice, pImageFormatInfo, pImageFormatProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties, struct vn_instance_submit_command *submit)
@ -12950,15 +12950,15 @@ static inline void vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(&submit->command, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceQueueFamilyProperties2_reply(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceQueueFamilyProperties2(enc, cmd_flags, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties, struct vn_instance_submit_command *submit)
@ -12971,15 +12971,15 @@ static inline void vn_submit_vkGetPhysicalDeviceMemoryProperties2(struct vn_inst
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceMemoryProperties2(&submit->command, cmd_flags, physicalDevice, pMemoryProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceMemoryProperties2_reply(physicalDevice, pMemoryProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceMemoryProperties2(enc, cmd_flags, physicalDevice, pMemoryProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties, struct vn_instance_submit_command *submit)
@ -12992,15 +12992,15 @@ static inline void vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(str
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(&submit->command, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(physicalDevice, pFormatInfo, pPropertyCount, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceSparseImageFormatProperties2(enc, cmd_flags, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties, struct vn_instance_submit_command *submit)
@ -13013,15 +13013,15 @@ static inline void vn_submit_vkGetPhysicalDeviceExternalBufferProperties(struct
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceExternalBufferProperties(&submit->command, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalBufferProperties_reply(physicalDevice, pExternalBufferInfo, pExternalBufferProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceExternalBufferProperties(enc, cmd_flags, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties, struct vn_instance_submit_command *submit)
@ -13034,15 +13034,15 @@ static inline void vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(stru
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(&submit->command, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceExternalSemaphoreProperties(enc, cmd_flags, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties, struct vn_instance_submit_command *submit)
@ -13055,15 +13055,15 @@ static inline void vn_submit_vkGetPhysicalDeviceExternalFenceProperties(struct v
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPhysicalDeviceExternalFenceProperties(&submit->command, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPhysicalDeviceExternalFenceProperties_reply(physicalDevice, pExternalFenceInfo, pExternalFenceProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPhysicalDeviceExternalFenceProperties(enc, cmd_flags, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties, struct vn_instance_submit_command *submit)
@ -13076,15 +13076,15 @@ static inline void vn_submit_vkEnumeratePhysicalDeviceGroups(struct vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumeratePhysicalDeviceGroups(&submit->command, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumeratePhysicalDeviceGroups_reply(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumeratePhysicalDeviceGroups(enc, cmd_flags, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures, struct vn_instance_submit_command *submit)
@ -13097,15 +13097,15 @@ static inline void vn_submit_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetDeviceGroupPeerMemoryFeatures(&submit->command, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceGroupPeerMemoryFeatures_reply(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceGroupPeerMemoryFeatures(enc, cmd_flags, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue, struct vn_instance_submit_command *submit)
@ -13118,24 +13118,25 @@ static inline void vn_submit_vkGetDeviceQueue2(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetDeviceQueue2(&submit->command, cmd_flags, device, pQueueInfo, pQueue);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceQueue2_reply(device, pQueueInfo, pQueue) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceQueue2(enc, cmd_flags, device, pQueueInfo, pQueue);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkEnumeratePhysicalDevices(struct vn_instance *vn_instance, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices)
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumeratePhysicalDevices(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceCount, pPhysicalDevices, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(&submit.reply, instance, pPhysicalDeviceCount, pPhysicalDevices);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumeratePhysicalDevices_reply(dec, instance, pPhysicalDeviceCount, pPhysicalDevices);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13152,9 +13153,10 @@ static inline void vn_call_vkGetPhysicalDeviceProperties(struct vn_instance *vn_
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceProperties_reply(&submit.reply, physicalDevice, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceProperties_reply(dec, physicalDevice, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13168,9 +13170,10 @@ static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties(struct vn_in
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13184,9 +13187,10 @@ static inline void vn_call_vkGetPhysicalDeviceMemoryProperties(struct vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceMemoryProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(&submit.reply, physicalDevice, pMemoryProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceMemoryProperties_reply(dec, physicalDevice, pMemoryProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13200,9 +13204,10 @@ static inline void vn_call_vkGetPhysicalDeviceFeatures(struct vn_instance *vn_in
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceFeatures_reply(&submit.reply, physicalDevice, pFeatures);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceFeatures_reply(dec, physicalDevice, pFeatures);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13216,9 +13221,10 @@ static inline void vn_call_vkGetPhysicalDeviceFormatProperties(struct vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceFormatProperties_reply(&submit.reply, physicalDevice, format, pFormatProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceFormatProperties_reply(dec, physicalDevice, format, pFormatProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13232,9 +13238,10 @@ static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties(struct v
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties_reply(dec, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13251,9 +13258,10 @@ static inline VkResult vn_call_vkCreateDevice(struct vn_instance *vn_instance, V
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pCreateInfo, pAllocator, pDevice, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateDevice_reply(&submit.reply, physicalDevice, pCreateInfo, pAllocator, pDevice);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateDevice_reply(dec, physicalDevice, pCreateInfo, pAllocator, pDevice);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13270,9 +13278,10 @@ static inline void vn_call_vkDestroyDevice(struct vn_instance *vn_instance, VkDe
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyDevice(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyDevice_reply(&submit.reply, device, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyDevice_reply(dec, device, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13286,9 +13295,10 @@ static inline VkResult vn_call_vkEnumerateDeviceLayerProperties(struct vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumerateDeviceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pPropertyCount, pProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(&submit.reply, physicalDevice, pPropertyCount, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumerateDeviceLayerProperties_reply(dec, physicalDevice, pPropertyCount, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13305,9 +13315,10 @@ static inline VkResult vn_call_vkEnumerateDeviceExtensionProperties(struct vn_in
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumerateDeviceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pLayerName, pPropertyCount, pProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(&submit.reply, physicalDevice, pLayerName, pPropertyCount, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumerateDeviceExtensionProperties_reply(dec, physicalDevice, pLayerName, pPropertyCount, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13324,9 +13335,10 @@ static inline void vn_call_vkGetDeviceQueue(struct vn_instance *vn_instance, VkD
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceQueue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queueFamilyIndex, queueIndex, pQueue, &submit);
if (submit.reply_bo) {
vn_decode_vkGetDeviceQueue_reply(&submit.reply, device, queueFamilyIndex, queueIndex, pQueue);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceQueue_reply(dec, device, queueFamilyIndex, queueIndex, pQueue);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13340,9 +13352,10 @@ static inline VkResult vn_call_vkDeviceWaitIdle(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkDeviceWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(&submit.reply, device);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkDeviceWaitIdle_reply(dec, device);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13359,9 +13372,10 @@ static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties(struct
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(&submit.reply, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties_reply(dec, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13375,9 +13389,10 @@ static inline void vn_call_vkGetPhysicalDeviceFeatures2(struct vn_instance *vn_i
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceFeatures2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFeatures, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceFeatures2_reply(&submit.reply, physicalDevice, pFeatures);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceFeatures2_reply(dec, physicalDevice, pFeatures);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13391,9 +13406,10 @@ static inline void vn_call_vkGetPhysicalDeviceProperties2(struct vn_instance *vn
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceProperties2_reply(&submit.reply, physicalDevice, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceProperties2_reply(dec, physicalDevice, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13407,9 +13423,10 @@ static inline void vn_call_vkGetPhysicalDeviceFormatProperties2(struct vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, format, pFormatProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(&submit.reply, physicalDevice, format, pFormatProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceFormatProperties2_reply(dec, physicalDevice, format, pFormatProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13423,9 +13440,10 @@ static inline VkResult vn_call_vkGetPhysicalDeviceImageFormatProperties2(struct
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pImageFormatInfo, pImageFormatProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(&submit.reply, physicalDevice, pImageFormatInfo, pImageFormatProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetPhysicalDeviceImageFormatProperties2_reply(dec, physicalDevice, pImageFormatInfo, pImageFormatProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13442,9 +13460,10 @@ static inline void vn_call_vkGetPhysicalDeviceQueueFamilyProperties2(struct vn_i
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceQueueFamilyProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(&submit.reply, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceQueueFamilyProperties2_reply(dec, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13458,9 +13477,10 @@ static inline void vn_call_vkGetPhysicalDeviceMemoryProperties2(struct vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceMemoryProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pMemoryProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(&submit.reply, physicalDevice, pMemoryProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceMemoryProperties2_reply(dec, physicalDevice, pMemoryProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13474,9 +13494,10 @@ static inline void vn_call_vkGetPhysicalDeviceSparseImageFormatProperties2(struc
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceSparseImageFormatProperties2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pFormatInfo, pPropertyCount, pProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(&submit.reply, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceSparseImageFormatProperties2_reply(dec, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13490,9 +13511,10 @@ static inline void vn_call_vkGetPhysicalDeviceExternalBufferProperties(struct vn
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceExternalBufferProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalBufferInfo, pExternalBufferProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(&submit.reply, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceExternalBufferProperties_reply(dec, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13506,9 +13528,10 @@ static inline void vn_call_vkGetPhysicalDeviceExternalSemaphoreProperties(struct
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceExternalSemaphoreProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(&submit.reply, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceExternalSemaphoreProperties_reply(dec, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13522,9 +13545,10 @@ static inline void vn_call_vkGetPhysicalDeviceExternalFenceProperties(struct vn_
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPhysicalDeviceExternalFenceProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, physicalDevice, pExternalFenceInfo, pExternalFenceProperties, &submit);
if (submit.reply_bo) {
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(&submit.reply, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPhysicalDeviceExternalFenceProperties_reply(dec, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13538,9 +13562,10 @@ static inline VkResult vn_call_vkEnumeratePhysicalDeviceGroups(struct vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumeratePhysicalDeviceGroups(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(&submit.reply, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumeratePhysicalDeviceGroups_reply(dec, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -13557,9 +13582,10 @@ static inline void vn_call_vkGetDeviceGroupPeerMemoryFeatures(struct vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceGroupPeerMemoryFeatures(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures, &submit);
if (submit.reply_bo) {
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(&submit.reply, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceGroupPeerMemoryFeatures_reply(dec, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -13573,9 +13599,10 @@ static inline void vn_call_vkGetDeviceQueue2(struct vn_instance *vn_instance, Vk
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceQueue2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pQueueInfo, pQueue, &submit);
if (submit.reply_bo) {
vn_decode_vkGetDeviceQueue2_reply(&submit.reply, device, pQueueInfo, pQueue);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceQueue2_reply(dec, device, pQueueInfo, pQueue);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

161
src/virtio/venus-protocol/vn_protocol_driver_device_memory.h
View file

@ -1005,15 +1005,15 @@ static inline void vn_submit_vkAllocateMemory(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateMemory_reply(device, pAllocateInfo, pAllocator, pMemory) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkAllocateMemory(&submit->command, cmd_flags, device, pAllocateInfo, pAllocator, pMemory);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateMemory_reply(device, pAllocateInfo, pAllocator, pMemory) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkAllocateMemory(enc, cmd_flags, device, pAllocateInfo, pAllocator, pMemory);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkFreeMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -1026,15 +1026,15 @@ static inline void vn_submit_vkFreeMemory(struct vn_instance *vn_instance, VkCom
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeMemory_reply(device, memory, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkFreeMemory(&submit->command, cmd_flags, device, memory, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeMemory_reply(device, memory, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkFreeMemory(enc, cmd_flags, device, memory, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkUnmapMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, struct vn_instance_submit_command *submit)
@ -1047,15 +1047,15 @@ static inline void vn_submit_vkUnmapMemory(struct vn_instance *vn_instance, VkCo
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUnmapMemory_reply(device, memory) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkUnmapMemory(&submit->command, cmd_flags, device, memory);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUnmapMemory_reply(device, memory) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkUnmapMemory(enc, cmd_flags, device, memory);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkFlushMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit)
@ -1068,15 +1068,15 @@ static inline void vn_submit_vkFlushMappedMemoryRanges(struct vn_instance *vn_in
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFlushMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkFlushMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFlushMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkFlushMappedMemoryRanges(enc, cmd_flags, device, memoryRangeCount, pMemoryRanges);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkInvalidateMappedMemoryRanges(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges, struct vn_instance_submit_command *submit)
@ -1089,15 +1089,15 @@ static inline void vn_submit_vkInvalidateMappedMemoryRanges(struct vn_instance *
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkInvalidateMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkInvalidateMappedMemoryRanges(&submit->command, cmd_flags, device, memoryRangeCount, pMemoryRanges);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkInvalidateMappedMemoryRanges_reply(device, memoryRangeCount, pMemoryRanges) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkInvalidateMappedMemoryRanges(enc, cmd_flags, device, memoryRangeCount, pMemoryRanges);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDeviceMemoryCommitment(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes, struct vn_instance_submit_command *submit)
@ -1110,15 +1110,15 @@ static inline void vn_submit_vkGetDeviceMemoryCommitment(struct vn_instance *vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryCommitment_reply(device, memory, pCommittedMemoryInBytes) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetDeviceMemoryCommitment(&submit->command, cmd_flags, device, memory, pCommittedMemoryInBytes);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryCommitment_reply(device, memory, pCommittedMemoryInBytes) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceMemoryCommitment(enc, cmd_flags, device, memory, pCommittedMemoryInBytes);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo, struct vn_instance_submit_command *submit)
@ -1131,24 +1131,25 @@ static inline void vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_ins
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(device, pInfo) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(&submit->command, cmd_flags, device, pInfo);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceMemoryOpaqueCaptureAddress_reply(device, pInfo) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceMemoryOpaqueCaptureAddress(enc, cmd_flags, device, pInfo);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkAllocateMemory(struct vn_instance *vn_instance, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
{
struct vn_instance_submit_command submit;
vn_submit_vkAllocateMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pAllocator, pMemory, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkAllocateMemory_reply(&submit.reply, device, pAllocateInfo, pAllocator, pMemory);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkAllocateMemory_reply(dec, device, pAllocateInfo, pAllocator, pMemory);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1165,9 +1166,10 @@ static inline void vn_call_vkFreeMemory(struct vn_instance *vn_instance, VkDevic
{
struct vn_instance_submit_command submit;
vn_submit_vkFreeMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkFreeMemory_reply(&submit.reply, device, memory, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkFreeMemory_reply(dec, device, memory, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1181,9 +1183,10 @@ static inline void vn_call_vkUnmapMemory(struct vn_instance *vn_instance, VkDevi
{
struct vn_instance_submit_command submit;
vn_submit_vkUnmapMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, &submit);
if (submit.reply_bo) {
vn_decode_vkUnmapMemory_reply(&submit.reply, device, memory);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkUnmapMemory_reply(dec, device, memory);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1197,9 +1200,10 @@ static inline VkResult vn_call_vkFlushMappedMemoryRanges(struct vn_instance *vn_
{
struct vn_instance_submit_command submit;
vn_submit_vkFlushMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkFlushMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkFlushMappedMemoryRanges_reply(dec, device, memoryRangeCount, pMemoryRanges);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1216,9 +1220,10 @@ static inline VkResult vn_call_vkInvalidateMappedMemoryRanges(struct vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkInvalidateMappedMemoryRanges(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memoryRangeCount, pMemoryRanges, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkInvalidateMappedMemoryRanges_reply(&submit.reply, device, memoryRangeCount, pMemoryRanges);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkInvalidateMappedMemoryRanges_reply(dec, device, memoryRangeCount, pMemoryRanges);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1235,9 +1240,10 @@ static inline void vn_call_vkGetDeviceMemoryCommitment(struct vn_instance *vn_in
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceMemoryCommitment(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, memory, pCommittedMemoryInBytes, &submit);
if (submit.reply_bo) {
vn_decode_vkGetDeviceMemoryCommitment_reply(&submit.reply, device, memory, pCommittedMemoryInBytes);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceMemoryCommitment_reply(dec, device, memory, pCommittedMemoryInBytes);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1251,9 +1257,10 @@ static inline uint64_t vn_call_vkGetDeviceMemoryOpaqueCaptureAddress(struct vn_i
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceMemoryOpaqueCaptureAddress(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, &submit);
if (submit.reply_bo) {
const uint64_t ret = vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(&submit.reply, device, pInfo);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const uint64_t ret = vn_decode_vkGetDeviceMemoryOpaqueCaptureAddress_reply(dec, device, pInfo);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

115
src/virtio/venus-protocol/vn_protocol_driver_event.h
View file

@ -348,15 +348,15 @@ static inline void vn_submit_vkCreateEvent(struct vn_instance *vn_instance, VkCo
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateEvent_reply(device, pCreateInfo, pAllocator, pEvent) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateEvent(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pEvent);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateEvent_reply(device, pCreateInfo, pAllocator, pEvent) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateEvent(enc, cmd_flags, device, pCreateInfo, pAllocator, pEvent);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -369,15 +369,15 @@ static inline void vn_submit_vkDestroyEvent(struct vn_instance *vn_instance, VkC
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyEvent_reply(device, event, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyEvent(&submit->command, cmd_flags, device, event, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyEvent_reply(device, event, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyEvent(enc, cmd_flags, device, event, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetEventStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
@ -390,15 +390,15 @@ static inline void vn_submit_vkGetEventStatus(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetEventStatus_reply(device, event) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetEventStatus(&submit->command, cmd_flags, device, event);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetEventStatus_reply(device, event) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetEventStatus(enc, cmd_flags, device, event);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
@ -411,15 +411,15 @@ static inline void vn_submit_vkSetEvent(struct vn_instance *vn_instance, VkComma
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetEvent_reply(device, event) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkSetEvent(&submit->command, cmd_flags, device, event);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetEvent_reply(device, event) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkSetEvent(enc, cmd_flags, device, event);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
@ -432,24 +432,25 @@ static inline void vn_submit_vkResetEvent(struct vn_instance *vn_instance, VkCom
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetEvent_reply(device, event) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkResetEvent(&submit->command, cmd_flags, device, event);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetEvent_reply(device, event) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkResetEvent(enc, cmd_flags, device, event);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pEvent, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateEvent_reply(&submit.reply, device, pCreateInfo, pAllocator, pEvent);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateEvent_reply(dec, device, pCreateInfo, pAllocator, pEvent);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -466,9 +467,10 @@ static inline void vn_call_vkDestroyEvent(struct vn_instance *vn_instance, VkDev
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyEvent_reply(&submit.reply, device, event, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyEvent_reply(dec, device, event, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -482,9 +484,10 @@ static inline VkResult vn_call_vkGetEventStatus(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkGetEventStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetEventStatus_reply(&submit.reply, device, event);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetEventStatus_reply(dec, device, event);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -501,9 +504,10 @@ static inline VkResult vn_call_vkSetEvent(struct vn_instance *vn_instance, VkDev
{
struct vn_instance_submit_command submit;
vn_submit_vkSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkSetEvent_reply(&submit.reply, device, event);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkSetEvent_reply(dec, device, event);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -520,9 +524,10 @@ static inline VkResult vn_call_vkResetEvent(struct vn_instance *vn_instance, VkD
{
struct vn_instance_submit_command submit;
vn_submit_vkResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkResetEvent_reply(&submit.reply, device, event);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkResetEvent_reply(dec, device, event);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

115
src/virtio/venus-protocol/vn_protocol_driver_fence.h
View file

@ -474,15 +474,15 @@ static inline void vn_submit_vkCreateFence(struct vn_instance *vn_instance, VkCo
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFence_reply(device, pCreateInfo, pAllocator, pFence) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateFence(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFence);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFence_reply(device, pCreateInfo, pAllocator, pFence) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateFence(enc, cmd_flags, device, pCreateInfo, pAllocator, pFence);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -495,15 +495,15 @@ static inline void vn_submit_vkDestroyFence(struct vn_instance *vn_instance, VkC
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFence_reply(device, fence, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyFence(&submit->command, cmd_flags, device, fence, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFence_reply(device, fence, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyFence(enc, cmd_flags, device, fence, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkResetFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, struct vn_instance_submit_command *submit)
@ -516,15 +516,15 @@ static inline void vn_submit_vkResetFences(struct vn_instance *vn_instance, VkCo
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFences_reply(device, fenceCount, pFences) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkResetFences(&submit->command, cmd_flags, device, fenceCount, pFences);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFences_reply(device, fenceCount, pFences) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkResetFences(enc, cmd_flags, device, fenceCount, pFences);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetFenceStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit)
@ -537,15 +537,15 @@ static inline void vn_submit_vkGetFenceStatus(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetFenceStatus_reply(device, fence) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetFenceStatus(&submit->command, cmd_flags, device, fence);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetFenceStatus_reply(device, fence) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetFenceStatus(enc, cmd_flags, device, fence);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, struct vn_instance_submit_command *submit)
@ -558,24 +558,25 @@ static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, Vk
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitForFences_reply(device, fenceCount, pFences, waitAll, timeout) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkWaitForFences(&submit->command, cmd_flags, device, fenceCount, pFences, waitAll, timeout);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitForFences_reply(device, fenceCount, pFences, waitAll, timeout) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkWaitForFences(enc, cmd_flags, device, fenceCount, pFences, waitAll, timeout);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFence, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateFence_reply(&submit.reply, device, pCreateInfo, pAllocator, pFence);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateFence_reply(dec, device, pCreateInfo, pAllocator, pFence);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -592,9 +593,10 @@ static inline void vn_call_vkDestroyFence(struct vn_instance *vn_instance, VkDev
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyFence_reply(&submit.reply, device, fence, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyFence_reply(dec, device, fence, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -608,9 +610,10 @@ static inline VkResult vn_call_vkResetFences(struct vn_instance *vn_instance, Vk
{
struct vn_instance_submit_command submit;
vn_submit_vkResetFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkResetFences_reply(&submit.reply, device, fenceCount, pFences);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkResetFences_reply(dec, device, fenceCount, pFences);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -627,9 +630,10 @@ static inline VkResult vn_call_vkGetFenceStatus(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkGetFenceStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetFenceStatus_reply(&submit.reply, device, fence);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetFenceStatus_reply(dec, device, fence);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -646,9 +650,10 @@ static inline VkResult vn_call_vkWaitForFences(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkWaitForFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, waitAll, timeout, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkWaitForFences_reply(&submit.reply, device, fenceCount, pFences, waitAll, timeout);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkWaitForFences_reply(dec, device, fenceCount, pFences, waitAll, timeout);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

46
src/virtio/venus-protocol/vn_protocol_driver_framebuffer.h
View file

@ -397,15 +397,15 @@ static inline void vn_submit_vkCreateFramebuffer(struct vn_instance *vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFramebuffer_reply(device, pCreateInfo, pAllocator, pFramebuffer) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateFramebuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFramebuffer);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFramebuffer_reply(device, pCreateInfo, pAllocator, pFramebuffer) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateFramebuffer(enc, cmd_flags, device, pCreateInfo, pAllocator, pFramebuffer);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -418,24 +418,25 @@ static inline void vn_submit_vkDestroyFramebuffer(struct vn_instance *vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFramebuffer_reply(device, framebuffer, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyFramebuffer(&submit->command, cmd_flags, device, framebuffer, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFramebuffer_reply(device, framebuffer, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyFramebuffer(enc, cmd_flags, device, framebuffer, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateFramebuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pFramebuffer);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateFramebuffer_reply(dec, device, pCreateInfo, pAllocator, pFramebuffer);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -452,9 +453,10 @@ static inline void vn_call_vkDestroyFramebuffer(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, framebuffer, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyFramebuffer_reply(&submit.reply, device, framebuffer, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyFramebuffer_reply(dec, device, framebuffer, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

230
src/virtio/venus-protocol/vn_protocol_driver_image.h
View file

@ -1911,15 +1911,15 @@ static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_instance *vn
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetImageMemoryRequirements(&submit->command, cmd_flags, device, image, pMemoryRequirements);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements_reply(device, image, pMemoryRequirements) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageMemoryRequirements(enc, cmd_flags, device, image, pMemoryRequirements);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset, struct vn_instance_submit_command *submit)
@ -1932,15 +1932,15 @@ static inline void vn_submit_vkBindImageMemory(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkBindImageMemory(&submit->command, cmd_flags, device, image, memory, memoryOffset);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory_reply(device, image, memory, memoryOffset) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkBindImageMemory(enc, cmd_flags, device, image, memory, memoryOffset);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
@ -1953,15 +1953,15 @@ static inline void vn_submit_vkGetImageSparseMemoryRequirements(struct vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetImageSparseMemoryRequirements(&submit->command, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements_reply(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageSparseMemoryRequirements(enc, cmd_flags, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage, struct vn_instance_submit_command *submit)
@ -1974,15 +1974,15 @@ static inline void vn_submit_vkCreateImage(struct vn_instance *vn_instance, VkCo
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateImage(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pImage);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImage_reply(device, pCreateInfo, pAllocator, pImage) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateImage(enc, cmd_flags, device, pCreateInfo, pAllocator, pImage);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -1995,15 +1995,15 @@ static inline void vn_submit_vkDestroyImage(struct vn_instance *vn_instance, VkC
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyImage(&submit->command, cmd_flags, device, image, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImage_reply(device, image, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyImage(enc, cmd_flags, device, image, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout, struct vn_instance_submit_command *submit)
@ -2016,15 +2016,15 @@ static inline void vn_submit_vkGetImageSubresourceLayout(struct vn_instance *vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetImageSubresourceLayout(&submit->command, cmd_flags, device, image, pSubresource, pLayout);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSubresourceLayout_reply(device, image, pSubresource, pLayout) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageSubresourceLayout(enc, cmd_flags, device, image, pSubresource, pLayout);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos, struct vn_instance_submit_command *submit)
@ -2037,15 +2037,15 @@ static inline void vn_submit_vkBindImageMemory2(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkBindImageMemory2(&submit->command, cmd_flags, device, bindInfoCount, pBindInfos);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkBindImageMemory2_reply(device, bindInfoCount, pBindInfos) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkBindImageMemory2(enc, cmd_flags, device, bindInfoCount, pBindInfos);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
@ -2058,15 +2058,15 @@ static inline void vn_submit_vkGetImageMemoryRequirements2(struct vn_instance *v
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetImageMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pMemoryRequirements);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageMemoryRequirements2_reply(device, pInfo, pMemoryRequirements) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageMemoryRequirements2(enc, cmd_flags, device, pInfo, pMemoryRequirements);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
@ -2079,15 +2079,15 @@ static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetImageSparseMemoryRequirements2(&submit->command, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageSparseMemoryRequirements2_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageSparseMemoryRequirements2(enc, cmd_flags, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties, struct vn_instance_submit_command *submit)
@ -2100,24 +2100,25 @@ static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(&submit->command, cmd_flags, device, image, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT_reply(device, image, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageDrmFormatModifierPropertiesEXT(enc, cmd_flags, device, image, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_call_vkGetImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pMemoryRequirements, &submit);
if (submit.reply_bo) {
vn_decode_vkGetImageMemoryRequirements_reply(&submit.reply, device, image, pMemoryRequirements);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetImageMemoryRequirements_reply(dec, device, image, pMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -2131,9 +2132,10 @@ static inline VkResult vn_call_vkBindImageMemory(struct vn_instance *vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkBindImageMemory(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, memory, memoryOffset, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkBindImageMemory_reply(&submit.reply, device, image, memory, memoryOffset);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkBindImageMemory_reply(dec, device, image, memory, memoryOffset);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -2150,9 +2152,10 @@ static inline void vn_call_vkGetImageSparseMemoryRequirements(struct vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkGetImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
if (submit.reply_bo) {
vn_decode_vkGetImageSparseMemoryRequirements_reply(&submit.reply, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetImageSparseMemoryRequirements_reply(dec, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -2166,9 +2169,10 @@ static inline VkResult vn_call_vkCreateImage(struct vn_instance *vn_instance, Vk
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pImage, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateImage_reply(&submit.reply, device, pCreateInfo, pAllocator, pImage);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateImage_reply(dec, device, pCreateInfo, pAllocator, pImage);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -2185,9 +2189,10 @@ static inline void vn_call_vkDestroyImage(struct vn_instance *vn_instance, VkDev
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyImage(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyImage_reply(&submit.reply, device, image, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyImage_reply(dec, device, image, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -2201,9 +2206,10 @@ static inline void vn_call_vkGetImageSubresourceLayout(struct vn_instance *vn_in
{
struct vn_instance_submit_command submit;
vn_submit_vkGetImageSubresourceLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
if (submit.reply_bo) {
vn_decode_vkGetImageSubresourceLayout_reply(&submit.reply, device, image, pSubresource, pLayout);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetImageSubresourceLayout_reply(dec, device, image, pSubresource, pLayout);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -2217,9 +2223,10 @@ static inline VkResult vn_call_vkBindImageMemory2(struct vn_instance *vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkBindImageMemory2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bindInfoCount, pBindInfos, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkBindImageMemory2_reply(&submit.reply, device, bindInfoCount, pBindInfos);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkBindImageMemory2_reply(dec, device, bindInfoCount, pBindInfos);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -2236,9 +2243,10 @@ static inline void vn_call_vkGetImageMemoryRequirements2(struct vn_instance *vn_
{
struct vn_instance_submit_command submit;
vn_submit_vkGetImageMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
if (submit.reply_bo) {
vn_decode_vkGetImageMemoryRequirements2_reply(&submit.reply, device, pInfo, pMemoryRequirements);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetImageMemoryRequirements2_reply(dec, device, pInfo, pMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -2252,9 +2260,10 @@ static inline void vn_call_vkGetImageSparseMemoryRequirements2(struct vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
if (submit.reply_bo) {
vn_decode_vkGetImageSparseMemoryRequirements2_reply(&submit.reply, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetImageSparseMemoryRequirements2_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -2268,9 +2277,10 @@ static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct v
{
struct vn_instance_submit_command submit;
vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(&submit.reply, device, image, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(dec, device, image, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

46
src/virtio/venus-protocol/vn_protocol_driver_image_view.h
View file

@ -306,15 +306,15 @@ static inline void vn_submit_vkCreateImageView(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImageView_reply(device, pCreateInfo, pAllocator, pView) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateImageView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImageView_reply(device, pCreateInfo, pAllocator, pView) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateImageView(enc, cmd_flags, device, pCreateInfo, pAllocator, pView);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -327,24 +327,25 @@ static inline void vn_submit_vkDestroyImageView(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImageView_reply(device, imageView, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyImageView(&submit->command, cmd_flags, device, imageView, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImageView_reply(device, imageView, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyImageView(enc, cmd_flags, device, imageView, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateImageView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateImageView_reply(dec, device, pCreateInfo, pAllocator, pView);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -361,9 +362,10 @@ static inline void vn_call_vkDestroyImageView(struct vn_instance *vn_instance, V
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, imageView, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyImageView_reply(&submit.reply, device, imageView, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyImageView_reply(dec, device, imageView, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

115
src/virtio/venus-protocol/vn_protocol_driver_instance.h
View file

@ -566,15 +566,15 @@ static inline void vn_submit_vkCreateInstance(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateInstance_reply(pCreateInfo, pAllocator, pInstance) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateInstance(&submit->command, cmd_flags, pCreateInfo, pAllocator, pInstance);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateInstance_reply(pCreateInfo, pAllocator, pInstance) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateInstance(enc, cmd_flags, pCreateInfo, pAllocator, pInstance);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -587,15 +587,15 @@ static inline void vn_submit_vkDestroyInstance(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyInstance_reply(instance, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyInstance(&submit->command, cmd_flags, instance, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyInstance_reply(instance, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyInstance(enc, cmd_flags, instance, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion, struct vn_instance_submit_command *submit)
@ -608,15 +608,15 @@ static inline void vn_submit_vkEnumerateInstanceVersion(struct vn_instance *vn_i
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceVersion_reply(pApiVersion) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumerateInstanceVersion(&submit->command, cmd_flags, pApiVersion);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceVersion_reply(pApiVersion) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumerateInstanceVersion(enc, cmd_flags, pApiVersion);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
@ -629,15 +629,15 @@ static inline void vn_submit_vkEnumerateInstanceLayerProperties(struct vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceLayerProperties_reply(pPropertyCount, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumerateInstanceLayerProperties(&submit->command, cmd_flags, pPropertyCount, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceLayerProperties_reply(pPropertyCount, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumerateInstanceLayerProperties(enc, cmd_flags, pPropertyCount, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
@ -650,24 +650,25 @@ static inline void vn_submit_vkEnumerateInstanceExtensionProperties(struct vn_in
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(pLayerName, pPropertyCount, pProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkEnumerateInstanceExtensionProperties(&submit->command, cmd_flags, pLayerName, pPropertyCount, pProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(pLayerName, pPropertyCount, pProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkEnumerateInstanceExtensionProperties(enc, cmd_flags, pLayerName, pPropertyCount, pProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pCreateInfo, pAllocator, pInstance, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateInstance_reply(&submit.reply, pCreateInfo, pAllocator, pInstance);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateInstance_reply(dec, pCreateInfo, pAllocator, pInstance);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -684,9 +685,10 @@ static inline void vn_call_vkDestroyInstance(struct vn_instance *vn_instance, Vk
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyInstance_reply(&submit.reply, instance, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyInstance_reply(dec, instance, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -700,9 +702,10 @@ static inline VkResult vn_call_vkEnumerateInstanceVersion(struct vn_instance *vn
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumerateInstanceVersion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pApiVersion, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumerateInstanceVersion_reply(&submit.reply, pApiVersion);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumerateInstanceVersion_reply(dec, pApiVersion);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -719,9 +722,10 @@ static inline VkResult vn_call_vkEnumerateInstanceLayerProperties(struct vn_inst
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pPropertyCount, pProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumerateInstanceLayerProperties_reply(&submit.reply, pPropertyCount, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumerateInstanceLayerProperties_reply(dec, pPropertyCount, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -738,9 +742,10 @@ static inline VkResult vn_call_vkEnumerateInstanceExtensionProperties(struct vn_
{
struct vn_instance_submit_command submit;
vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pLayerName, pPropertyCount, pProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkEnumerateInstanceExtensionProperties_reply(&submit.reply, pLayerName, pPropertyCount, pProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkEnumerateInstanceExtensionProperties_reply(dec, pLayerName, pPropertyCount, pProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

69
src/virtio/venus-protocol/vn_protocol_driver_pipeline.h
View file

@ -1528,15 +1528,15 @@ static inline void vn_submit_vkCreateGraphicsPipelines(struct vn_instance *vn_in
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateGraphicsPipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateGraphicsPipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateGraphicsPipelines(enc, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateComputePipelines(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, struct vn_instance_submit_command *submit)
@ -1549,15 +1549,15 @@ static inline void vn_submit_vkCreateComputePipelines(struct vn_instance *vn_ins
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateComputePipelines(&submit->command, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateComputePipelines_reply(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateComputePipelines(enc, cmd_flags, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyPipeline(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -1570,24 +1570,25 @@ static inline void vn_submit_vkDestroyPipeline(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyPipeline(&submit->command, cmd_flags, device, pipeline, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipeline_reply(device, pipeline, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyPipeline(enc, cmd_flags, device, pipeline, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateGraphicsPipelines(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateGraphicsPipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateGraphicsPipelines_reply(dec, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1604,9 +1605,10 @@ static inline VkResult vn_call_vkCreateComputePipelines(struct vn_instance *vn_i
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateComputePipelines(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateComputePipelines_reply(&submit.reply, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateComputePipelines_reply(dec, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1623,9 +1625,10 @@ static inline void vn_call_vkDestroyPipeline(struct vn_instance *vn_instance, Vk
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyPipeline(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipeline, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyPipeline_reply(&submit.reply, device, pipeline, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyPipeline_reply(dec, device, pipeline, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

92
src/virtio/venus-protocol/vn_protocol_driver_pipeline_cache.h
View file

@ -360,15 +360,15 @@ static inline void vn_submit_vkCreatePipelineCache(struct vn_instance *vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineCache_reply(device, pCreateInfo, pAllocator, pPipelineCache) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreatePipelineCache(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineCache);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineCache_reply(device, pCreateInfo, pAllocator, pPipelineCache) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreatePipelineCache(enc, cmd_flags, device, pCreateInfo, pAllocator, pPipelineCache);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -381,15 +381,15 @@ static inline void vn_submit_vkDestroyPipelineCache(struct vn_instance *vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineCache_reply(device, pipelineCache, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyPipelineCache(&submit->command, cmd_flags, device, pipelineCache, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineCache_reply(device, pipelineCache, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyPipelineCache(enc, cmd_flags, device, pipelineCache, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, struct vn_instance_submit_command *submit)
@ -402,15 +402,15 @@ static inline void vn_submit_vkGetPipelineCacheData(struct vn_instance *vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPipelineCacheData_reply(device, pipelineCache, pDataSize, pData) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetPipelineCacheData(&submit->command, cmd_flags, device, pipelineCache, pDataSize, pData);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPipelineCacheData_reply(device, pipelineCache, pDataSize, pData) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPipelineCacheData(enc, cmd_flags, device, pipelineCache, pDataSize, pData);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkMergePipelineCaches(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, struct vn_instance_submit_command *submit)
@ -423,24 +423,25 @@ static inline void vn_submit_vkMergePipelineCaches(struct vn_instance *vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkMergePipelineCaches_reply(device, dstCache, srcCacheCount, pSrcCaches) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkMergePipelineCaches(&submit->command, cmd_flags, device, dstCache, srcCacheCount, pSrcCaches);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkMergePipelineCaches_reply(device, dstCache, srcCacheCount, pSrcCaches) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkMergePipelineCaches(enc, cmd_flags, device, dstCache, srcCacheCount, pSrcCaches);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreatePipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreatePipelineCache_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineCache);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreatePipelineCache_reply(dec, device, pCreateInfo, pAllocator, pPipelineCache);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -457,9 +458,10 @@ static inline void vn_call_vkDestroyPipelineCache(struct vn_instance *vn_instanc
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyPipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyPipelineCache_reply(&submit.reply, device, pipelineCache, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyPipelineCache_reply(dec, device, pipelineCache, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -473,9 +475,10 @@ static inline VkResult vn_call_vkGetPipelineCacheData(struct vn_instance *vn_ins
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPipelineCacheData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pDataSize, pData, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetPipelineCacheData_reply(&submit.reply, device, pipelineCache, pDataSize, pData);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetPipelineCacheData_reply(dec, device, pipelineCache, pDataSize, pData);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -492,9 +495,10 @@ static inline VkResult vn_call_vkMergePipelineCaches(struct vn_instance *vn_inst
{
struct vn_instance_submit_command submit;
vn_submit_vkMergePipelineCaches(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, dstCache, srcCacheCount, pSrcCaches, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkMergePipelineCaches_reply(&submit.reply, device, dstCache, srcCacheCount, pSrcCaches);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkMergePipelineCaches_reply(dec, device, dstCache, srcCacheCount, pSrcCaches);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

46
src/virtio/venus-protocol/vn_protocol_driver_pipeline_layout.h
View file

@ -250,15 +250,15 @@ static inline void vn_submit_vkCreatePipelineLayout(struct vn_instance *vn_insta
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineLayout_reply(device, pCreateInfo, pAllocator, pPipelineLayout) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreatePipelineLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineLayout);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineLayout_reply(device, pCreateInfo, pAllocator, pPipelineLayout) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreatePipelineLayout(enc, cmd_flags, device, pCreateInfo, pAllocator, pPipelineLayout);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -271,24 +271,25 @@ static inline void vn_submit_vkDestroyPipelineLayout(struct vn_instance *vn_inst
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineLayout_reply(device, pipelineLayout, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyPipelineLayout(&submit->command, cmd_flags, device, pipelineLayout, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineLayout_reply(device, pipelineLayout, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyPipelineLayout(enc, cmd_flags, device, pipelineLayout, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreatePipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreatePipelineLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineLayout);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreatePipelineLayout_reply(dec, device, pCreateInfo, pAllocator, pPipelineLayout);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -305,9 +306,10 @@ static inline void vn_call_vkDestroyPipelineLayout(struct vn_instance *vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyPipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineLayout, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyPipelineLayout_reply(&submit.reply, device, pipelineLayout, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyPipelineLayout_reply(dec, device, pipelineLayout, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

92
src/virtio/venus-protocol/vn_protocol_driver_query_pool.h
View file

@ -341,15 +341,15 @@ static inline void vn_submit_vkCreateQueryPool(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateQueryPool_reply(device, pCreateInfo, pAllocator, pQueryPool) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateQueryPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pQueryPool);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateQueryPool_reply(device, pCreateInfo, pAllocator, pQueryPool) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateQueryPool(enc, cmd_flags, device, pCreateInfo, pAllocator, pQueryPool);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -362,15 +362,15 @@ static inline void vn_submit_vkDestroyQueryPool(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyQueryPool_reply(device, queryPool, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyQueryPool(&submit->command, cmd_flags, device, queryPool, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyQueryPool_reply(device, queryPool, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyQueryPool(enc, cmd_flags, device, queryPool, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit)
@ -383,15 +383,15 @@ static inline void vn_submit_vkGetQueryPoolResults(struct vn_instance *vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetQueryPoolResults_reply(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetQueryPoolResults(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetQueryPoolResults_reply(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetQueryPoolResults(enc, cmd_flags, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit)
@ -404,24 +404,25 @@ static inline void vn_submit_vkResetQueryPool(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetQueryPool_reply(device, queryPool, firstQuery, queryCount) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkResetQueryPool(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetQueryPool_reply(device, queryPool, firstQuery, queryCount) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkResetQueryPool(enc, cmd_flags, device, queryPool, firstQuery, queryCount);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pQueryPool, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateQueryPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pQueryPool);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateQueryPool_reply(dec, device, pCreateInfo, pAllocator, pQueryPool);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -438,9 +439,10 @@ static inline void vn_call_vkDestroyQueryPool(struct vn_instance *vn_instance, V
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyQueryPool_reply(&submit.reply, device, queryPool, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyQueryPool_reply(dec, device, queryPool, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -454,9 +456,10 @@ static inline VkResult vn_call_vkGetQueryPoolResults(struct vn_instance *vn_inst
{
struct vn_instance_submit_command submit;
vn_submit_vkGetQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetQueryPoolResults_reply(&submit.reply, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetQueryPoolResults_reply(dec, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -473,9 +476,10 @@ static inline void vn_call_vkResetQueryPool(struct vn_instance *vn_instance, VkD
{
struct vn_instance_submit_command submit;
vn_submit_vkResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, &submit);
if (submit.reply_bo) {
vn_decode_vkResetQueryPool_reply(&submit.reply, device, queryPool, firstQuery, queryCount);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkResetQueryPool_reply(dec, device, queryPool, firstQuery, queryCount);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

69
src/virtio/venus-protocol/vn_protocol_driver_queue.h
View file

@ -979,15 +979,15 @@ static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCo
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit_reply(queue, submitCount, pSubmits, fence) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkQueueSubmit(&submit->command, cmd_flags, queue, submitCount, pSubmits, fence);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit_reply(queue, submitCount, pSubmits, fence) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkQueueSubmit(enc, cmd_flags, queue, submitCount, pSubmits, fence);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkQueueWaitIdle(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, struct vn_instance_submit_command *submit)
@ -1000,15 +1000,15 @@ static inline void vn_submit_vkQueueWaitIdle(struct vn_instance *vn_instance, Vk
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueWaitIdle_reply(queue) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkQueueWaitIdle(&submit->command, cmd_flags, queue);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueWaitIdle_reply(queue) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkQueueWaitIdle(enc, cmd_flags, queue);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence, struct vn_instance_submit_command *submit)
@ -1021,24 +1021,25 @@ static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueBindSparse_reply(queue, bindInfoCount, pBindInfo, fence) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkQueueBindSparse(&submit->command, cmd_flags, queue, bindInfoCount, pBindInfo, fence);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueBindSparse_reply(queue, bindInfoCount, pBindInfo, fence) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkQueueBindSparse(enc, cmd_flags, queue, bindInfoCount, pBindInfo, fence);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
{
struct vn_instance_submit_command submit;
vn_submit_vkQueueSubmit(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkQueueSubmit_reply(&submit.reply, queue, submitCount, pSubmits, fence);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkQueueSubmit_reply(dec, queue, submitCount, pSubmits, fence);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1055,9 +1056,10 @@ static inline VkResult vn_call_vkQueueWaitIdle(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkQueueWaitIdle(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkQueueWaitIdle_reply(&submit.reply, queue);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkQueueWaitIdle_reply(dec, queue);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1074,9 +1076,10 @@ static inline VkResult vn_call_vkQueueBindSparse(struct vn_instance *vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkQueueBindSparse(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, bindInfoCount, pBindInfo, fence, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkQueueBindSparse_reply(&submit.reply, queue, bindInfoCount, pBindInfo, fence);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkQueueBindSparse_reply(dec, queue, bindInfoCount, pBindInfo, fence);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

92
src/virtio/venus-protocol/vn_protocol_driver_render_pass.h
View file

@ -1459,15 +1459,15 @@ static inline void vn_submit_vkCreateRenderPass(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateRenderPass(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateRenderPass(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -1480,15 +1480,15 @@ static inline void vn_submit_vkDestroyRenderPass(struct vn_instance *vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyRenderPass(&submit->command, cmd_flags, device, renderPass, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRenderPass_reply(device, renderPass, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyRenderPass(enc, cmd_flags, device, renderPass, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity, struct vn_instance_submit_command *submit)
@ -1501,15 +1501,15 @@ static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_instance *vn_i
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetRenderAreaGranularity(&submit->command, cmd_flags, device, renderPass, pGranularity);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetRenderAreaGranularity_reply(device, renderPass, pGranularity) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetRenderAreaGranularity(enc, cmd_flags, device, renderPass, pGranularity);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_instance_submit_command *submit)
@ -1522,24 +1522,25 @@ static inline void vn_submit_vkCreateRenderPass2(struct vn_instance *vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateRenderPass2(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRenderPass2_reply(device, pCreateInfo, pAllocator, pRenderPass) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateRenderPass2(enc, cmd_flags, device, pCreateInfo, pAllocator, pRenderPass);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateRenderPass(struct vn_instance *vn_instance, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateRenderPass_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateRenderPass_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -1556,9 +1557,10 @@ static inline void vn_call_vkDestroyRenderPass(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyRenderPass(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyRenderPass_reply(&submit.reply, device, renderPass, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyRenderPass_reply(dec, device, renderPass, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1572,9 +1574,10 @@ static inline void vn_call_vkGetRenderAreaGranularity(struct vn_instance *vn_ins
{
struct vn_instance_submit_command submit;
vn_submit_vkGetRenderAreaGranularity(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, renderPass, pGranularity, &submit);
if (submit.reply_bo) {
vn_decode_vkGetRenderAreaGranularity_reply(&submit.reply, device, renderPass, pGranularity);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetRenderAreaGranularity_reply(dec, device, renderPass, pGranularity);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -1588,9 +1591,10 @@ static inline VkResult vn_call_vkCreateRenderPass2(struct vn_instance *vn_instan
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateRenderPass2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pRenderPass, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateRenderPass2_reply(&submit.reply, device, pCreateInfo, pAllocator, pRenderPass);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateRenderPass2_reply(dec, device, pCreateInfo, pAllocator, pRenderPass);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

46
src/virtio/venus-protocol/vn_protocol_driver_sampler.h
View file

@ -326,15 +326,15 @@ static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, Vk
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateSampler(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSampler);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateSampler(enc, cmd_flags, device, pCreateInfo, pAllocator, pSampler);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -347,24 +347,25 @@ static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroySampler(&submit->command, cmd_flags, device, sampler, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroySampler(enc, cmd_flags, device, sampler, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateSampler_reply(&submit.reply, device, pCreateInfo, pAllocator, pSampler);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateSampler_reply(dec, device, pCreateInfo, pAllocator, pSampler);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -381,9 +382,10 @@ static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkD
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroySampler_reply(&submit.reply, device, sampler, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroySampler_reply(dec, device, sampler, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

46
src/virtio/venus-protocol/vn_protocol_driver_sampler_ycbcr_conversion.h
View file

@ -212,15 +212,15 @@ static inline void vn_submit_vkCreateSamplerYcbcrConversion(struct vn_instance *
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSamplerYcbcrConversion_reply(device, pCreateInfo, pAllocator, pYcbcrConversion) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateSamplerYcbcrConversion(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pYcbcrConversion);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSamplerYcbcrConversion_reply(device, pCreateInfo, pAllocator, pYcbcrConversion) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateSamplerYcbcrConversion(enc, cmd_flags, device, pCreateInfo, pAllocator, pYcbcrConversion);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -233,24 +233,25 @@ static inline void vn_submit_vkDestroySamplerYcbcrConversion(struct vn_instance
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySamplerYcbcrConversion_reply(device, ycbcrConversion, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroySamplerYcbcrConversion(&submit->command, cmd_flags, device, ycbcrConversion, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySamplerYcbcrConversion_reply(device, ycbcrConversion, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroySamplerYcbcrConversion(enc, cmd_flags, device, ycbcrConversion, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateSamplerYcbcrConversion_reply(&submit.reply, device, pCreateInfo, pAllocator, pYcbcrConversion);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateSamplerYcbcrConversion_reply(dec, device, pCreateInfo, pAllocator, pYcbcrConversion);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -267,9 +268,10 @@ static inline void vn_call_vkDestroySamplerYcbcrConversion(struct vn_instance *v
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, ycbcrConversion, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroySamplerYcbcrConversion_reply(&submit.reply, device, ycbcrConversion, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroySamplerYcbcrConversion_reply(dec, device, ycbcrConversion, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

115
src/virtio/venus-protocol/vn_protocol_driver_semaphore.h
View file

@ -630,15 +630,15 @@ static inline void vn_submit_vkCreateSemaphore(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateSemaphore(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateSemaphore(enc, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -651,15 +651,15 @@ static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroySemaphore(&submit->command, cmd_flags, device, semaphore, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroySemaphore(enc, cmd_flags, device, semaphore, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, struct vn_instance_submit_command *submit)
@ -672,15 +672,15 @@ static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_i
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetSemaphoreCounterValue(&submit->command, cmd_flags, device, semaphore, pValue);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetSemaphoreCounterValue(enc, cmd_flags, device, semaphore, pValue);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, struct vn_instance_submit_command *submit)
@ -693,15 +693,15 @@ static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkWaitSemaphores(&submit->command, cmd_flags, device, pWaitInfo, timeout);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkWaitSemaphores(enc, cmd_flags, device, pWaitInfo, timeout);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, struct vn_instance_submit_command *submit)
@ -714,24 +714,25 @@ static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkSignalSemaphore(&submit->command, cmd_flags, device, pSignalInfo);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkSignalSemaphore(enc, cmd_flags, device, pSignalInfo);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSemaphore, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateSemaphore_reply(&submit.reply, device, pCreateInfo, pAllocator, pSemaphore);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateSemaphore_reply(dec, device, pCreateInfo, pAllocator, pSemaphore);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -748,9 +749,10 @@ static inline void vn_call_vkDestroySemaphore(struct vn_instance *vn_instance, V
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroySemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroySemaphore_reply(&submit.reply, device, semaphore, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroySemaphore_reply(dec, device, semaphore, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -764,9 +766,10 @@ static inline VkResult vn_call_vkGetSemaphoreCounterValue(struct vn_instance *vn
{
struct vn_instance_submit_command submit;
vn_submit_vkGetSemaphoreCounterValue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pValue, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(&submit.reply, device, semaphore, pValue);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(dec, device, semaphore, pValue);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -783,9 +786,10 @@ static inline VkResult vn_call_vkWaitSemaphores(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkWaitSemaphores(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pWaitInfo, timeout, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkWaitSemaphores_reply(&submit.reply, device, pWaitInfo, timeout);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkWaitSemaphores_reply(dec, device, pWaitInfo, timeout);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -802,9 +806,10 @@ static inline VkResult vn_call_vkSignalSemaphore(struct vn_instance *vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkSignalSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pSignalInfo, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkSignalSemaphore_reply(&submit.reply, device, pSignalInfo);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkSignalSemaphore_reply(dec, device, pSignalInfo);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;

46
src/virtio/venus-protocol/vn_protocol_driver_shader_module.h
View file

@ -212,15 +212,15 @@ static inline void vn_submit_vkCreateShaderModule(struct vn_instance *vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateShaderModule_reply(device, pCreateInfo, pAllocator, pShaderModule) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateShaderModule(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pShaderModule);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateShaderModule_reply(device, pCreateInfo, pAllocator, pShaderModule) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateShaderModule(enc, cmd_flags, device, pCreateInfo, pAllocator, pShaderModule);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
@ -233,24 +233,25 @@ static inline void vn_submit_vkDestroyShaderModule(struct vn_instance *vn_instan
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyShaderModule_reply(device, shaderModule, pAllocator) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyShaderModule(&submit->command, cmd_flags, device, shaderModule, pAllocator);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyShaderModule_reply(device, shaderModule, pAllocator) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyShaderModule(enc, cmd_flags, device, shaderModule, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pShaderModule, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkCreateShaderModule_reply(&submit.reply, device, pCreateInfo, pAllocator, pShaderModule);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreateShaderModule_reply(dec, device, pCreateInfo, pAllocator, pShaderModule);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
@ -267,9 +268,10 @@ static inline void vn_call_vkDestroyShaderModule(struct vn_instance *vn_instance
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, shaderModule, pAllocator, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyShaderModule_reply(&submit.reply, device, shaderModule, pAllocator);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyShaderModule_reply(dec, device, shaderModule, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}

184
src/virtio/venus-protocol/vn_protocol_driver_transport.h
View file

@ -665,15 +665,15 @@ static inline void vn_submit_vkSetReplyCommandStreamMESA(struct vn_instance *vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetReplyCommandStreamMESA_reply(pStream) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkSetReplyCommandStreamMESA(&submit->command, cmd_flags, pStream);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetReplyCommandStreamMESA_reply(pStream) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkSetReplyCommandStreamMESA(enc, cmd_flags, pStream);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, size_t position, struct vn_instance_submit_command *submit)
@ -686,15 +686,15 @@ static inline void vn_submit_vkSeekReplyCommandStreamMESA(struct vn_instance *vn
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSeekReplyCommandStreamMESA_reply(position) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkSeekReplyCommandStreamMESA(&submit->command, cmd_flags, position);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSeekReplyCommandStreamMESA_reply(position) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkSeekReplyCommandStreamMESA(enc, cmd_flags, position);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags, struct vn_instance_submit_command *submit)
@ -707,15 +707,15 @@ static inline void vn_submit_vkExecuteCommandStreamsMESA(struct vn_instance *vn_
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkExecuteCommandStreamsMESA_reply(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkExecuteCommandStreamsMESA(&submit->command, cmd_flags, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkExecuteCommandStreamsMESA_reply(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkExecuteCommandStreamsMESA(enc, cmd_flags, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo, struct vn_instance_submit_command *submit)
@ -728,15 +728,15 @@ static inline void vn_submit_vkCreateRingMESA(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRingMESA_reply(ring, pCreateInfo) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkCreateRingMESA(&submit->command, cmd_flags, ring, pCreateInfo);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRingMESA_reply(ring, pCreateInfo) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreateRingMESA(enc, cmd_flags, ring, pCreateInfo);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, struct vn_instance_submit_command *submit)
@ -749,15 +749,15 @@ static inline void vn_submit_vkDestroyRingMESA(struct vn_instance *vn_instance,
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRingMESA_reply(ring) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkDestroyRingMESA(&submit->command, cmd_flags, ring);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRingMESA_reply(ring) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyRingMESA(enc, cmd_flags, ring);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkNotifyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags, struct vn_instance_submit_command *submit)
@ -770,15 +770,15 @@ static inline void vn_submit_vkNotifyRingMESA(struct vn_instance *vn_instance, V
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkNotifyRingMESA_reply(ring, seqno, flags) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkNotifyRingMESA(&submit->command, cmd_flags, ring, seqno, flags);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkNotifyRingMESA_reply(ring, seqno, flags) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkNotifyRingMESA(enc, cmd_flags, ring, seqno, flags);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value, struct vn_instance_submit_command *submit)
@ -791,15 +791,15 @@ static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWriteRingExtraMESA_reply(ring, offset, value) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkWriteRingExtraMESA(&submit->command, cmd_flags, ring, offset, value);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWriteRingExtraMESA_reply(ring, offset, value) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkWriteRingExtraMESA(enc, cmd_flags, ring, offset, value);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetMemoryResourcePropertiesMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t resourceId, VkMemoryResourcePropertiesMESA* pMemoryResourceProperties, struct vn_instance_submit_command *submit)
@ -812,24 +812,25 @@ static inline void vn_submit_vkGetMemoryResourcePropertiesMESA(struct vn_instanc
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetMemoryResourcePropertiesMESA_reply(device, resourceId, pMemoryResourceProperties) : 0;
submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
if (cmd_size)
vn_encode_vkGetMemoryResourcePropertiesMESA(&submit->command, cmd_flags, device, resourceId, pMemoryResourceProperties);
submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetMemoryResourcePropertiesMESA_reply(device, resourceId, pMemoryResourceProperties) : 0;
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetMemoryResourcePropertiesMESA(enc, cmd_flags, device, resourceId, pMemoryResourceProperties);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_call_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
{
struct vn_instance_submit_command submit;
vn_submit_vkSetReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pStream, &submit);
if (submit.reply_bo) {
vn_decode_vkSetReplyCommandStreamMESA_reply(&submit.reply, pStream);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkSetReplyCommandStreamMESA_reply(dec, pStream);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -843,9 +844,10 @@ static inline void vn_call_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_i
{
struct vn_instance_submit_command submit;
vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, position, &submit);
if (submit.reply_bo) {
vn_decode_vkSeekReplyCommandStreamMESA_reply(&submit.reply, position);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkSeekReplyCommandStreamMESA_reply(dec, position);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -859,9 +861,10 @@ static inline void vn_call_vkExecuteCommandStreamsMESA(struct vn_instance *vn_in
{
struct vn_instance_submit_command submit;
vn_submit_vkExecuteCommandStreamsMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
if (submit.reply_bo) {
vn_decode_vkExecuteCommandStreamsMESA_reply(&submit.reply, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkExecuteCommandStreamsMESA_reply(dec, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -875,9 +878,10 @@ static inline void vn_call_vkCreateRingMESA(struct vn_instance *vn_instance, uin
{
struct vn_instance_submit_command submit;
vn_submit_vkCreateRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, pCreateInfo, &submit);
if (submit.reply_bo) {
vn_decode_vkCreateRingMESA_reply(&submit.reply, ring, pCreateInfo);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkCreateRingMESA_reply(dec, ring, pCreateInfo);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -891,9 +895,10 @@ static inline void vn_call_vkDestroyRingMESA(struct vn_instance *vn_instance, ui
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, &submit);
if (submit.reply_bo) {
vn_decode_vkDestroyRingMESA_reply(&submit.reply, ring);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyRingMESA_reply(dec, ring);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -907,9 +912,10 @@ static inline void vn_call_vkNotifyRingMESA(struct vn_instance *vn_instance, uin
{
struct vn_instance_submit_command submit;
vn_submit_vkNotifyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, flags, &submit);
if (submit.reply_bo) {
vn_decode_vkNotifyRingMESA_reply(&submit.reply, ring, seqno, flags);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkNotifyRingMESA_reply(dec, ring, seqno, flags);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -923,9 +929,10 @@ static inline void vn_call_vkWriteRingExtraMESA(struct vn_instance *vn_instance,
{
struct vn_instance_submit_command submit;
vn_submit_vkWriteRingExtraMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, offset, value, &submit);
if (submit.reply_bo) {
vn_decode_vkWriteRingExtraMESA_reply(&submit.reply, ring, offset, value);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkWriteRingExtraMESA_reply(dec, ring, offset, value);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
@ -939,9 +946,10 @@ static inline VkResult vn_call_vkGetMemoryResourcePropertiesMESA(struct vn_insta
{
struct vn_instance_submit_command submit;
vn_submit_vkGetMemoryResourcePropertiesMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, resourceId, pMemoryResourceProperties, &submit);
if (submit.reply_bo) {
const VkResult ret = vn_decode_vkGetMemoryResourcePropertiesMESA_reply(&submit.reply, device, resourceId, pMemoryResourceProperties);
vn_renderer_bo_unref(submit.reply_bo);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkGetMemoryResourcePropertiesMESA_reply(dec, device, resourceId, pMemoryResourceProperties);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;