KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

venus: update venus-protocol to 1.3.204 

There should be no visible functional change.  Although an unrelated
change in the codegen replaced vn_info_extension_spec_version by
vn_info_extension_get.  We have to adapt to that.

Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Reviewed-by: Ryan Neph <ryanneph@google.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/14782>
This commit is contained in:
Chia-I Wu 2022-01-27 21:26:28 -08:00 committed by Marge Bot
parent d4b6d03408
commit b41adbf211
18 changed files with 11828 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/virtio/venus-protocol/vn_protocol_driver.h
View File

@ -1,4 +1,4 @@
/* This file is generated by venus-protocol git-825670b9. */
/* This file is generated by venus-protocol git-0048ccc3. */
/*
* Copyright 2020 Google LLC
@ -41,5 +41,6 @@
#include "vn_protocol_driver_pipeline_cache.h"
#include "vn_protocol_driver_command_pool.h"
#include "vn_protocol_driver_command_buffer.h"
#include "vn_protocol_driver_private_data_slot.h"
#endif /* VN_PROTOCOL_DRIVER_H */

271
src/virtio/venus-protocol/vn_protocol_driver_buffer.h
View File

@ -64,6 +64,33 @@ vn_encode_VkExternalMemoryBufferCreateInfo(struct vn_cs_encoder *enc, const VkEx
vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkExternalMemoryBufferCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkExternalMemoryBufferCreateInfo_self(struct vn_cs_decoder *dec, VkExternalMemoryBufferCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkFlags(dec, &val->handleTypes);
}
static inline void
vn_decode_VkExternalMemoryBufferCreateInfo(struct vn_cs_decoder *dec, VkExternalMemoryBufferCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkExternalMemoryBufferCreateInfo_pnext(dec, val->pNext);
vn_decode_VkExternalMemoryBufferCreateInfo_self(dec, val);
}
/* struct VkBufferOpaqueCaptureAddressCreateInfo chain */
static inline size_t
@ -117,6 +144,33 @@ vn_encode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_encoder *enc, cons
vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_self(struct vn_cs_decoder *dec, VkBufferOpaqueCaptureAddressCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_uint64_t(dec, &val->opaqueCaptureAddress);
}
static inline void
vn_decode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_decoder *dec, VkBufferOpaqueCaptureAddressCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(dec, val->pNext);
vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_self(dec, val);
}
/* struct VkBufferCreateInfo chain */
static inline size_t
@ -235,6 +289,67 @@ vn_encode_VkBufferCreateInfo(struct vn_cs_encoder *enc, const VkBufferCreateInfo
vn_encode_VkBufferCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkBufferCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
VkStructureType stype;
if (!vn_decode_simple_pointer(dec))
return;
vn_decode_VkStructureType(dec, &stype);
while (true) {
assert(pnext);
if (pnext->sType == stype)
break;
}
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
vn_decode_VkBufferCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkExternalMemoryBufferCreateInfo_self(dec, (VkExternalMemoryBufferCreateInfo *)pnext);
break;
case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
vn_decode_VkBufferCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_self(dec, (VkBufferOpaqueCaptureAddressCreateInfo *)pnext);
break;
default:
assert(false);
break;
}
}
static inline void
vn_decode_VkBufferCreateInfo_self(struct vn_cs_decoder *dec, VkBufferCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkFlags(dec, &val->flags);
vn_decode_VkDeviceSize(dec, &val->size);
vn_decode_VkFlags(dec, &val->usage);
vn_decode_VkSharingMode(dec, &val->sharingMode);
vn_decode_uint32_t(dec, &val->queueFamilyIndexCount);
if (vn_peek_array_size(dec)) {
const size_t array_size = vn_decode_array_size(dec, val->queueFamilyIndexCount);
vn_decode_uint32_t_array(dec, (uint32_t *)val->pQueueFamilyIndices, array_size);
} else {
vn_decode_array_size_unchecked(dec);
val->pQueueFamilyIndices = NULL;
}
}
static inline void
vn_decode_VkBufferCreateInfo(struct vn_cs_decoder *dec, VkBufferCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkBufferCreateInfo_pnext(dec, val->pNext);
vn_decode_VkBufferCreateInfo_self(dec, val);
}
/* struct VkBindBufferMemoryDeviceGroupInfo chain */
static inline size_t
@ -525,6 +640,62 @@ vn_encode_VkBufferMemoryRequirementsInfo2(struct vn_cs_encoder *enc, const VkBuf
vn_encode_VkBufferMemoryRequirementsInfo2_self(enc, val);
}
/* struct VkDeviceBufferMemoryRequirements chain */
static inline size_t
vn_sizeof_VkDeviceBufferMemoryRequirements_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkDeviceBufferMemoryRequirements_self(const VkDeviceBufferMemoryRequirements *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_simple_pointer(val->pCreateInfo);
if (val->pCreateInfo)
size += vn_sizeof_VkBufferCreateInfo(val->pCreateInfo);
return size;
}
static inline size_t
vn_sizeof_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkDeviceBufferMemoryRequirements_pnext(val->pNext);
size += vn_sizeof_VkDeviceBufferMemoryRequirements_self(val);
return size;
}
static inline void
vn_encode_VkDeviceBufferMemoryRequirements_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkDeviceBufferMemoryRequirements_self(struct vn_cs_encoder *enc, const VkDeviceBufferMemoryRequirements *val)
{
/* skip val->{sType,pNext} */
if (vn_encode_simple_pointer(enc, val->pCreateInfo))
vn_encode_VkBufferCreateInfo(enc, val->pCreateInfo);
}
static inline void
vn_encode_VkDeviceBufferMemoryRequirements(struct vn_cs_encoder *enc, const VkDeviceBufferMemoryRequirements *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS });
vn_encode_VkDeviceBufferMemoryRequirements_pnext(enc, val->pNext);
vn_encode_VkDeviceBufferMemoryRequirements_self(enc, val);
}
/* struct VkBufferDeviceAddressInfo chain */
static inline size_t
@ -970,6 +1141,66 @@ static inline void vn_decode_vkGetBufferMemoryRequirements2_reply(struct vn_cs_d
}
}
static inline size_t vn_sizeof_vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_simple_pointer(pInfo);
if (pInfo)
cmd_size += vn_sizeof_VkDeviceBufferMemoryRequirements(pInfo);
cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
if (pMemoryRequirements)
cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
return cmd_size;
}
static inline void vn_encode_vkGetDeviceBufferMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
if (vn_encode_simple_pointer(enc, pInfo))
vn_encode_VkDeviceBufferMemoryRequirements(enc, pInfo);
if (vn_encode_simple_pointer(enc, pMemoryRequirements))
vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
}
static inline size_t vn_sizeof_vkGetDeviceBufferMemoryRequirements_reply(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip pInfo */
cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
if (pMemoryRequirements)
cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
return cmd_size;
}
static inline void vn_decode_vkGetDeviceBufferMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT);
/* skip device */
/* skip pInfo */
if (vn_decode_simple_pointer(dec)) {
vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
} else {
pMemoryRequirements = NULL;
}
}
static inline size_t vn_sizeof_vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT;
@ -1202,6 +1433,27 @@ static inline void vn_submit_vkGetBufferMemoryRequirements2(struct vn_instance *
}
}
static inline void vn_submit_vkGetDeviceBufferMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceBufferMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceBufferMemoryRequirements(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)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@ -1367,6 +1619,25 @@ static inline void vn_async_vkGetBufferMemoryRequirements2(struct vn_instance *v
vn_submit_vkGetBufferMemoryRequirements2(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
}
static inline void vn_call_vkGetDeviceBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceBufferMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceBufferMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkGetDeviceBufferMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceBufferMemoryRequirements(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
}
static inline uint64_t vn_call_vkGetBufferOpaqueCaptureAddress(struct vn_instance *vn_instance, VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
VN_TRACE_FUNC();

4054
src/virtio/venus-protocol/vn_protocol_driver_command_buffer.h
View File

File diff suppressed because it is too large Load Diff

76
src/virtio/venus-protocol/vn_protocol_driver_defines.h
View File

@ -243,6 +243,80 @@ typedef enum VkCommandTypeEXT {
VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddressKHR_EXT = 176,
VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT = 177,
VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddressKHR_EXT = 177,
VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT = 196,
VK_COMMAND_TYPE_vkGetPhysicalDeviceToolPropertiesEXT_EXT = 196,
VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT = 197,
VK_COMMAND_TYPE_vkCreatePrivateDataSlotEXT_EXT = 197,
VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT = 198,
VK_COMMAND_TYPE_vkDestroyPrivateDataSlotEXT_EXT = 198,
VK_COMMAND_TYPE_vkSetPrivateData_EXT = 199,
VK_COMMAND_TYPE_vkSetPrivateDataEXT_EXT = 199,
VK_COMMAND_TYPE_vkGetPrivateData_EXT = 200,
VK_COMMAND_TYPE_vkGetPrivateDataEXT_EXT = 200,
VK_COMMAND_TYPE_vkCmdSetEvent2_EXT = 201,
VK_COMMAND_TYPE_vkCmdSetEvent2KHR_EXT = 201,
VK_COMMAND_TYPE_vkCmdResetEvent2_EXT = 202,
VK_COMMAND_TYPE_vkCmdResetEvent2KHR_EXT = 202,
VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT = 203,
VK_COMMAND_TYPE_vkCmdWaitEvents2KHR_EXT = 203,
VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT = 204,
VK_COMMAND_TYPE_vkCmdPipelineBarrier2KHR_EXT = 204,
VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT = 205,
VK_COMMAND_TYPE_vkCmdWriteTimestamp2KHR_EXT = 205,
VK_COMMAND_TYPE_vkQueueSubmit2_EXT = 206,
VK_COMMAND_TYPE_vkQueueSubmit2KHR_EXT = 206,
VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT = 207,
VK_COMMAND_TYPE_vkCmdCopyBuffer2KHR_EXT = 207,
VK_COMMAND_TYPE_vkCmdCopyImage2_EXT = 208,
VK_COMMAND_TYPE_vkCmdCopyImage2KHR_EXT = 208,
VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT = 209,
VK_COMMAND_TYPE_vkCmdCopyBufferToImage2KHR_EXT = 209,
VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT = 210,
VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2KHR_EXT = 210,
VK_COMMAND_TYPE_vkCmdBlitImage2_EXT = 211,
VK_COMMAND_TYPE_vkCmdBlitImage2KHR_EXT = 211,
VK_COMMAND_TYPE_vkCmdResolveImage2_EXT = 212,
VK_COMMAND_TYPE_vkCmdResolveImage2KHR_EXT = 212,
VK_COMMAND_TYPE_vkCmdBeginRendering_EXT = 213,
VK_COMMAND_TYPE_vkCmdBeginRenderingKHR_EXT = 213,
VK_COMMAND_TYPE_vkCmdEndRendering_EXT = 214,
VK_COMMAND_TYPE_vkCmdEndRenderingKHR_EXT = 214,
VK_COMMAND_TYPE_vkCmdSetCullMode_EXT = 215,
VK_COMMAND_TYPE_vkCmdSetCullModeEXT_EXT = 215,
VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT = 216,
VK_COMMAND_TYPE_vkCmdSetFrontFaceEXT_EXT = 216,
VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT = 217,
VK_COMMAND_TYPE_vkCmdSetPrimitiveTopologyEXT_EXT = 217,
VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT = 218,
VK_COMMAND_TYPE_vkCmdSetViewportWithCountEXT_EXT = 218,
VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT = 219,
VK_COMMAND_TYPE_vkCmdSetScissorWithCountEXT_EXT = 219,
VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT = 220,
VK_COMMAND_TYPE_vkCmdBindVertexBuffers2EXT_EXT = 220,
VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT = 221,
VK_COMMAND_TYPE_vkCmdSetDepthTestEnableEXT_EXT = 221,
VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT = 222,
VK_COMMAND_TYPE_vkCmdSetDepthWriteEnableEXT_EXT = 222,
VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT = 223,
VK_COMMAND_TYPE_vkCmdSetDepthCompareOpEXT_EXT = 223,
VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT = 224,
VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnableEXT_EXT = 224,
VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT = 225,
VK_COMMAND_TYPE_vkCmdSetStencilTestEnableEXT_EXT = 225,
VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT = 226,
VK_COMMAND_TYPE_vkCmdSetStencilOpEXT_EXT = 226,
VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT = 227,
VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnableEXT_EXT = 227,
VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT = 228,
VK_COMMAND_TYPE_vkCmdSetDepthBiasEnableEXT_EXT = 228,
VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT = 229,
VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnableEXT_EXT = 229,
VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT = 230,
VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirementsKHR_EXT = 230,
VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT = 231,
VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirementsKHR_EXT = 231,
VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT = 232,
VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirementsKHR_EXT = 232,
VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT = 181,
VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT = 182,
VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT = 183,
@ -252,6 +326,8 @@ typedef enum VkCommandTypeEXT {
VK_COMMAND_TYPE_vkGetMemoryFdKHR_EXT = 193,
VK_COMMAND_TYPE_vkGetMemoryFdPropertiesKHR_EXT = 194,
VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT = 187,
VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT = 233,
VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT = 234,
VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT = 178,
VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT = 179,
VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT = 180,

90
src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h
View File

@ -29,12 +29,82 @@ vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPool
vn_encode_uint32_t(enc, &val->descriptorCount);
}
/* struct VkDescriptorPoolInlineUniformBlockCreateInfo chain */
static inline size_t
vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_self(const VkDescriptorPoolInlineUniformBlockCreateInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_uint32_t(&val->maxInlineUniformBlockBindings);
return size;
}
static inline size_t
vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo(const VkDescriptorPoolInlineUniformBlockCreateInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(val->pNext);
size += vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_self(val);
return size;
}
static inline void
vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolInlineUniformBlockCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_encode_uint32_t(enc, &val->maxInlineUniformBlockBindings);
}
static inline void
vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolInlineUniformBlockCreateInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO });
vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext(enc, val->pNext);
vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_self(enc, val);
}
/* struct VkDescriptorPoolCreateInfo chain */
static inline size_t
vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
size_t size = 0;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkDescriptorPoolInlineUniformBlockCreateInfo_self((const VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@ -71,7 +141,23 @@ vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val)
static inline void
vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkDescriptorPoolInlineUniformBlockCreateInfo_self(enc, (const VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}

102
src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h
View File

@ -224,12 +224,94 @@ vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBu
vn_encode_VkDeviceSize(enc, &val->range);
}
/* struct VkWriteDescriptorSetInlineUniformBlock chain */
static inline size_t
vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(const VkWriteDescriptorSetInlineUniformBlock *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_uint32_t(&val->dataSize);
if (val->pData) {
size += vn_sizeof_array_size(val->dataSize);
size += vn_sizeof_blob_array(val->pData, val->dataSize);
} else {
size += vn_sizeof_array_size(0);
}
return size;
}
static inline size_t
vn_sizeof_VkWriteDescriptorSetInlineUniformBlock(const VkWriteDescriptorSetInlineUniformBlock *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_pnext(val->pNext);
size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self(val);
return size;
}
static inline void
vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSetInlineUniformBlock *val)
{
/* skip val->{sType,pNext} */
vn_encode_uint32_t(enc, &val->dataSize);
if (val->pData) {
vn_encode_array_size(enc, val->dataSize);
vn_encode_blob_array(enc, val->pData, val->dataSize);
} else {
vn_encode_array_size(enc, 0);
}
}
static inline void
vn_encode_VkWriteDescriptorSetInlineUniformBlock(struct vn_cs_encoder *enc, const VkWriteDescriptorSetInlineUniformBlock *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK });
vn_encode_VkWriteDescriptorSetInlineUniformBlock_pnext(enc, val->pNext);
vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(enc, val);
}
/* struct VkWriteDescriptorSet chain */
static inline size_t
vn_sizeof_VkWriteDescriptorSet_pnext(const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
size_t size = 0;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkWriteDescriptorSet_pnext(pnext->pNext);
size += vn_sizeof_VkWriteDescriptorSetInlineUniformBlock_self((const VkWriteDescriptorSetInlineUniformBlock *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@ -282,7 +364,23 @@ vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val)
static inline void
vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkWriteDescriptorSet_pnext(enc, pnext->pNext);
vn_encode_VkWriteDescriptorSetInlineUniformBlock_self(enc, (const VkWriteDescriptorSetInlineUniformBlock *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}

5127
src/virtio/venus-protocol/vn_protocol_driver_device.h
View File

File diff suppressed because it is too large Load Diff

23
src/virtio/venus-protocol/vn_protocol_driver_handles.h
View File

@ -631,4 +631,27 @@ vn_decode_VkSamplerYcbcrConversion(struct vn_cs_decoder *dec, VkSamplerYcbcrConv
vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
}
/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) */
static inline size_t
vn_sizeof_VkPrivateDataSlot(const VkPrivateDataSlot *val)
{
return sizeof(uint64_t);
}
static inline void
vn_encode_VkPrivateDataSlot(struct vn_cs_encoder *enc, const VkPrivateDataSlot *val)
{
const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
vn_encode_uint64_t(enc, &id);
}
static inline void
vn_decode_VkPrivateDataSlot(struct vn_cs_decoder *dec, VkPrivateDataSlot *val)
{
uint64_t id;
vn_decode_uint64_t(dec, &id);
vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
}
#endif /* VN_PROTOCOL_DRIVER_HANDLES_H */

464
src/virtio/venus-protocol/vn_protocol_driver_image.h
View File

@ -110,6 +110,33 @@ vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExt
vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_decoder *dec, VkExternalMemoryImageCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkFlags(dec, &val->handleTypes);
}
static inline void
vn_decode_VkExternalMemoryImageCreateInfo(struct vn_cs_decoder *dec, VkExternalMemoryImageCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkExternalMemoryImageCreateInfo_pnext(dec, val->pNext);
vn_decode_VkExternalMemoryImageCreateInfo_self(dec, val);
}
/* struct VkImageDrmFormatModifierListCreateInfoEXT chain */
static inline size_t
@ -175,6 +202,40 @@ vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, c
vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val);
}
static inline void
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierListCreateInfoEXT *val)
{
/* skip val->{sType,pNext} */
vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
if (vn_peek_array_size(dec)) {
const size_t array_size = vn_decode_array_size(dec, val->drmFormatModifierCount);
vn_decode_uint64_t_array(dec, (uint64_t *)val->pDrmFormatModifiers, array_size);
} else {
vn_decode_array_size_unchecked(dec);
val->pDrmFormatModifiers = NULL;
}
}
static inline void
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierListCreateInfoEXT *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
assert(val->sType == stype);
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(dec, val->pNext);
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self(dec, val);
}
/* struct VkSubresourceLayout */
static inline size_t
@ -300,6 +361,42 @@ vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *en
vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val);
}
static inline void
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_decoder *dec, VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
{
/* skip val->{sType,pNext} */
vn_decode_uint64_t(dec, &val->drmFormatModifier);
vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
if (vn_peek_array_size(dec)) {
const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierPlaneCount);
for (uint32_t i = 0; i < iter_count; i++)
vn_decode_VkSubresourceLayout(dec, &((VkSubresourceLayout *)val->pPlaneLayouts)[i]);
} else {
vn_decode_array_size_unchecked(dec);
val->pPlaneLayouts = NULL;
}
}
static inline void
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_decoder *dec, VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT);
assert(val->sType == stype);
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(dec, val->pNext);
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(dec, val);
}
/* struct VkImageCreateInfo chain */
static inline size_t
@ -468,6 +565,86 @@ vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *
vn_encode_VkImageCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkImageCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
VkStructureType stype;
if (!vn_decode_simple_pointer(dec))
return;
vn_decode_VkStructureType(dec, &stype);
while (true) {
assert(pnext);
if (pnext->sType == stype)
break;
}
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkExternalMemoryImageCreateInfo_self(dec, (VkExternalMemoryImageCreateInfo *)pnext);
break;
case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkImageFormatListCreateInfo_self(dec, (VkImageFormatListCreateInfo *)pnext);
break;
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self(dec, (VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
break;
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(dec, (VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
break;
case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
vn_decode_VkImageCreateInfo_pnext(dec, pnext->pNext);
vn_decode_VkImageStencilUsageCreateInfo_self(dec, (VkImageStencilUsageCreateInfo *)pnext);
break;
default:
assert(false);
break;
}
}
static inline void
vn_decode_VkImageCreateInfo_self(struct vn_cs_decoder *dec, VkImageCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkFlags(dec, &val->flags);
vn_decode_VkImageType(dec, &val->imageType);
vn_decode_VkFormat(dec, &val->format);
vn_decode_VkExtent3D(dec, &val->extent);
vn_decode_uint32_t(dec, &val->mipLevels);
vn_decode_uint32_t(dec, &val->arrayLayers);
vn_decode_VkSampleCountFlagBits(dec, &val->samples);
vn_decode_VkImageTiling(dec, &val->tiling);
vn_decode_VkFlags(dec, &val->usage);
vn_decode_VkSharingMode(dec, &val->sharingMode);
vn_decode_uint32_t(dec, &val->queueFamilyIndexCount);
if (vn_peek_array_size(dec)) {
const size_t array_size = vn_decode_array_size(dec, val->queueFamilyIndexCount);
vn_decode_uint32_t_array(dec, (uint32_t *)val->pQueueFamilyIndices, array_size);
} else {
vn_decode_array_size_unchecked(dec);
val->pQueueFamilyIndices = NULL;
}
vn_decode_VkImageLayout(dec, &val->initialLayout);
}
static inline void
vn_decode_VkImageCreateInfo(struct vn_cs_decoder *dec, VkImageCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkImageCreateInfo_pnext(dec, val->pNext);
vn_decode_VkImageCreateInfo_self(dec, val);
}
/* struct VkBindImageMemoryDeviceGroupInfo chain */
static inline size_t
@ -1126,6 +1303,64 @@ vn_encode_VkSparseImageMemoryRequirements2_partial(struct vn_cs_encoder *enc, co
vn_encode_VkSparseImageMemoryRequirements2_self_partial(enc, val);
}
/* struct VkDeviceImageMemoryRequirements chain */
static inline size_t
vn_sizeof_VkDeviceImageMemoryRequirements_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkDeviceImageMemoryRequirements_self(const VkDeviceImageMemoryRequirements *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_simple_pointer(val->pCreateInfo);
if (val->pCreateInfo)
size += vn_sizeof_VkImageCreateInfo(val->pCreateInfo);
size += vn_sizeof_VkImageAspectFlagBits(&val->planeAspect);
return size;
}
static inline size_t
vn_sizeof_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkDeviceImageMemoryRequirements_pnext(val->pNext);
size += vn_sizeof_VkDeviceImageMemoryRequirements_self(val);
return size;
}
static inline void
vn_encode_VkDeviceImageMemoryRequirements_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkDeviceImageMemoryRequirements_self(struct vn_cs_encoder *enc, const VkDeviceImageMemoryRequirements *val)
{
/* skip val->{sType,pNext} */
if (vn_encode_simple_pointer(enc, val->pCreateInfo))
vn_encode_VkImageCreateInfo(enc, val->pCreateInfo);
vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
}
static inline void
vn_encode_VkDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, const VkDeviceImageMemoryRequirements *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS });
vn_encode_VkDeviceImageMemoryRequirements_pnext(enc, val->pNext);
vn_encode_VkDeviceImageMemoryRequirements_self(enc, val);
}
/* struct VkImageDrmFormatModifierPropertiesEXT chain */
static inline size_t
@ -1838,6 +2073,155 @@ static inline void vn_decode_vkGetImageSparseMemoryRequirements2_reply(struct vn
}
}
static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_simple_pointer(pInfo);
if (pInfo)
cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
if (pMemoryRequirements)
cmd_size += vn_sizeof_VkMemoryRequirements2_partial(pMemoryRequirements);
return cmd_size;
}
static inline void vn_encode_vkGetDeviceImageMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
if (vn_encode_simple_pointer(enc, pInfo))
vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
if (vn_encode_simple_pointer(enc, pMemoryRequirements))
vn_encode_VkMemoryRequirements2_partial(enc, pMemoryRequirements);
}
static inline size_t vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip pInfo */
cmd_size += vn_sizeof_simple_pointer(pMemoryRequirements);
if (pMemoryRequirements)
cmd_size += vn_sizeof_VkMemoryRequirements2(pMemoryRequirements);
return cmd_size;
}
static inline void vn_decode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT);
/* skip device */
/* skip pInfo */
if (vn_decode_simple_pointer(dec)) {
vn_decode_VkMemoryRequirements2(dec, pMemoryRequirements);
} else {
pMemoryRequirements = NULL;
}
}
static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_simple_pointer(pInfo);
if (pInfo)
cmd_size += vn_sizeof_VkDeviceImageMemoryRequirements(pInfo);
cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
if (pSparseMemoryRequirementCount)
cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
if (pSparseMemoryRequirements) {
cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2_partial(&pSparseMemoryRequirements[i]);
} else {
cmd_size += vn_sizeof_array_size(0);
}
return cmd_size;
}
static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
if (vn_encode_simple_pointer(enc, pInfo))
vn_encode_VkDeviceImageMemoryRequirements(enc, pInfo);
if (vn_encode_simple_pointer(enc, pSparseMemoryRequirementCount))
vn_encode_uint32_t(enc, pSparseMemoryRequirementCount);
if (pSparseMemoryRequirements) {
vn_encode_array_size(enc, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
vn_encode_VkSparseImageMemoryRequirements2_partial(enc, &pSparseMemoryRequirements[i]);
} else {
vn_encode_array_size(enc, 0);
}
}
static inline size_t vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip pInfo */
cmd_size += vn_sizeof_simple_pointer(pSparseMemoryRequirementCount);
if (pSparseMemoryRequirementCount)
cmd_size += vn_sizeof_uint32_t(pSparseMemoryRequirementCount);
if (pSparseMemoryRequirements) {
cmd_size += vn_sizeof_array_size((pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
for (uint32_t i = 0; i < (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0); i++)
cmd_size += vn_sizeof_VkSparseImageMemoryRequirements2(&pSparseMemoryRequirements[i]);
} else {
cmd_size += vn_sizeof_array_size(0);
}
return cmd_size;
}
static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT);
/* skip device */
/* skip pInfo */
if (vn_decode_simple_pointer(dec)) {
vn_decode_uint32_t(dec, pSparseMemoryRequirementCount);
} else {
pSparseMemoryRequirementCount = NULL;
}
if (vn_peek_array_size(dec)) {
const uint32_t iter_count = vn_decode_array_size(dec, (pSparseMemoryRequirementCount ? *pSparseMemoryRequirementCount : 0));
for (uint32_t i = 0; i < iter_count; i++)
vn_decode_VkSparseImageMemoryRequirements2(dec, &pSparseMemoryRequirements[i]);
} else {
vn_decode_array_size_unchecked(dec);
pSparseMemoryRequirements = NULL;
}
}
static inline size_t vn_sizeof_vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT;
@ -2090,6 +2474,48 @@ static inline void vn_submit_vkGetImageSparseMemoryRequirements2(struct vn_insta
}
}
static inline void vn_submit_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageMemoryRequirements_reply(device, pInfo, pMemoryRequirements) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceImageMemoryRequirements(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_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDeviceImageSparseMemoryRequirements_reply(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceImageSparseMemoryRequirements(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)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@ -2291,6 +2717,44 @@ static inline void vn_async_vkGetImageSparseMemoryRequirements2(struct vn_instan
vn_submit_vkGetImageSparseMemoryRequirements2(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
}
static inline void vn_call_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pMemoryRequirements, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceImageMemoryRequirements_reply(dec, device, pInfo, pMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkGetDeviceImageMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceImageMemoryRequirements(vn_instance, 0, device, pInfo, pMemoryRequirements, &submit);
}
static inline void vn_call_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetDeviceImageSparseMemoryRequirements_reply(dec, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkGetDeviceImageSparseMemoryRequirements(struct vn_instance *vn_instance, VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetDeviceImageSparseMemoryRequirements(vn_instance, 0, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements, &submit);
}
static inline VkResult vn_call_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_instance *vn_instance, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
{
VN_TRACE_FUNC();

216
src/virtio/venus-protocol/vn_protocol_driver_info.h
View File

@ -10,6 +10,13 @@
#include "vn_protocol_driver_defines.h"
struct vn_info_extension {
uint32_t index;
const char *name;
uint32_t spec_version;
};
static inline uint32_t
vn_info_wire_format_version(void)
{
@ -19,137 +26,100 @@ vn_info_wire_format_version(void)
static inline uint32_t
vn_info_vk_xml_version(void)
{
return VK_MAKE_API_VERSION(0, 1, 2, 182);
return VK_MAKE_API_VERSION(0, 1, 3, 204);
}
static inline int
vn_info_extension_compare(const void *a, const void *b)
vn_info_extension_compare(const void *name, const void *ext)
{
return strcmp(a, *(const char **)b);
return strcmp(name, ((const struct vn_info_extension *)ext)->name);
}
static inline uint32_t
vn_info_extension_spec_version(const char *name)
static inline const struct vn_info_extension *
vn_info_extension_get(const char *name)
{
static uint32_t ext_count = 54;
static const char *ext_names[54] = {
"VK_EXT_command_serialization",
"VK_EXT_descriptor_indexing",
"VK_EXT_external_memory_dma_buf",
"VK_EXT_host_query_reset",
"VK_EXT_image_drm_format_modifier",
"VK_EXT_queue_family_foreign",
"VK_EXT_sampler_filter_minmax",
"VK_EXT_scalar_block_layout",
"VK_EXT_separate_stencil_usage",
"VK_EXT_shader_viewport_index_layer",
"VK_EXT_transform_feedback",
"VK_KHR_16bit_storage",
"VK_KHR_8bit_storage",
"VK_KHR_bind_memory2",
"VK_KHR_buffer_device_address",
"VK_KHR_create_renderpass2",
"VK_KHR_dedicated_allocation",
"VK_KHR_depth_stencil_resolve",
"VK_KHR_descriptor_update_template",
"VK_KHR_device_group",
"VK_KHR_device_group_creation",
"VK_KHR_draw_indirect_count",
"VK_KHR_driver_properties",
"VK_KHR_external_fence",
"VK_KHR_external_fence_capabilities",
"VK_KHR_external_memory",
"VK_KHR_external_memory_capabilities",
"VK_KHR_external_memory_fd",
"VK_KHR_external_semaphore",
"VK_KHR_external_semaphore_capabilities",
"VK_KHR_get_memory_requirements2",
"VK_KHR_get_physical_device_properties2",
"VK_KHR_image_format_list",
"VK_KHR_imageless_framebuffer",
"VK_KHR_maintenance1",
"VK_KHR_maintenance2",
"VK_KHR_maintenance3",
"VK_KHR_multiview",
"VK_KHR_relaxed_block_layout",
"VK_KHR_sampler_mirror_clamp_to_edge",
"VK_KHR_sampler_ycbcr_conversion",
"VK_KHR_separate_depth_stencil_layouts",
"VK_KHR_shader_atomic_int64",
"VK_KHR_shader_draw_parameters",
"VK_KHR_shader_float16_int8",
"VK_KHR_shader_float_controls",
"VK_KHR_shader_subgroup_extended_types",
"VK_KHR_spirv_1_4",
"VK_KHR_storage_buffer_storage_class",
"VK_KHR_timeline_semaphore",
"VK_KHR_uniform_buffer_standard_layout",
"VK_KHR_variable_pointers",
"VK_KHR_vulkan_memory_model",
"VK_MESA_venus_protocol",
};
static const uint32_t ext_versions[54] = {
0,
2,
1,
1,
1,
1,
2,
1,
1,
1,
1,
1,
1,
1,
1,
1,
3,
1,
1,
4,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
1,
1,
2,
1,
1,
1,
1,
3,
14,
1,
1,
1,
1,
4,
1,
1,
1,
2,
1,
1,
3,
100000,
};
const char **found;
static const struct vn_info_extension vn_info_extensions[77] = {
{ 0, "VK_EXT_4444_formats", 1 },
{ 1, "VK_EXT_command_serialization", 0 },
{ 2, "VK_EXT_descriptor_indexing", 2 },
{ 3, "VK_EXT_extended_dynamic_state", 1 },
{ 4, "VK_EXT_extended_dynamic_state2", 1 },
{ 5, "VK_EXT_external_memory_dma_buf", 1 },
{ 6, "VK_EXT_host_query_reset", 1 },
{ 7, "VK_EXT_image_drm_format_modifier", 2 },
{ 8, "VK_EXT_image_robustness", 1 },
{ 9, "VK_EXT_inline_uniform_block", 1 },
{ 10, "VK_EXT_pipeline_creation_cache_control", 3 },
{ 11, "VK_EXT_pipeline_creation_feedback", 1 },
{ 12, "VK_EXT_private_data", 1 },
{ 13, "VK_EXT_queue_family_foreign", 1 },
{ 14, "VK_EXT_sampler_filter_minmax", 2 },
{ 15, "VK_EXT_scalar_block_layout", 1 },
{ 16, "VK_EXT_separate_stencil_usage", 1 },
{ 17, "VK_EXT_shader_demote_to_helper_invocation", 1 },
{ 18, "VK_EXT_shader_viewport_index_layer", 1 },
{ 19, "VK_EXT_subgroup_size_control", 2 },
{ 20, "VK_EXT_texel_buffer_alignment", 1 },
{ 21, "VK_EXT_texture_compression_astc_hdr", 1 },
{ 22, "VK_EXT_tooling_info", 1 },
{ 23, "VK_EXT_transform_feedback", 1 },
{ 24, "VK_EXT_ycbcr_2plane_444_formats", 1 },
{ 25, "VK_KHR_16bit_storage", 1 },
{ 26, "VK_KHR_8bit_storage", 1 },
{ 27, "VK_KHR_bind_memory2", 1 },
{ 28, "VK_KHR_buffer_device_address", 1 },
{ 29, "VK_KHR_copy_commands2", 1 },
{ 30, "VK_KHR_create_renderpass2", 1 },
{ 31, "VK_KHR_dedicated_allocation", 3 },
{ 32, "VK_KHR_depth_stencil_resolve", 1 },
{ 33, "VK_KHR_descriptor_update_template", 1 },
{ 34, "VK_KHR_device_group", 4 },
{ 35, "VK_KHR_device_group_creation", 1 },
{ 36, "VK_KHR_draw_indirect_count", 1 },
{ 37, "VK_KHR_driver_properties", 1 },
{ 38, "VK_KHR_dynamic_rendering", 1 },
{ 39, "VK_KHR_external_fence", 1 },
{ 40, "VK_KHR_external_fence_capabilities", 1 },
{ 41, "VK_KHR_external_memory", 1 },
{ 42, "VK_KHR_external_memory_capabilities", 1 },
{ 43, "VK_KHR_external_memory_fd", 1 },
{ 44, "VK_KHR_external_semaphore", 1 },
{ 45, "VK_KHR_external_semaphore_capabilities", 1 },
{ 46, "VK_KHR_format_feature_flags2", 1 },
{ 47, "VK_KHR_get_memory_requirements2", 1 },
{ 48, "VK_KHR_get_physical_device_properties2", 2 },
{ 49, "VK_KHR_image_format_list", 1 },
{ 50, "VK_KHR_imageless_framebuffer", 1 },
{ 51, "VK_KHR_maintenance1", 2 },
{ 52, "VK_KHR_maintenance2", 1 },
{ 53, "VK_KHR_maintenance3", 1 },
{ 54, "VK_KHR_maintenance4", 2 },
{ 55, "VK_KHR_multiview", 1 },
{ 56, "VK_KHR_relaxed_block_layout", 1 },
{ 57, "VK_KHR_sampler_mirror_clamp_to_edge", 3 },
{ 58, "VK_KHR_sampler_ycbcr_conversion", 14 },
{ 59, "VK_KHR_separate_depth_stencil_layouts", 1 },
{ 60, "VK_KHR_shader_atomic_int64", 1 },
{ 61, "VK_KHR_shader_draw_parameters", 1 },
{ 62, "VK_KHR_shader_float16_int8", 1 },
{ 63, "VK_KHR_shader_float_controls", 4 },
{ 64, "VK_KHR_shader_integer_dot_product", 1 },
{ 65, "VK_KHR_shader_non_semantic_info", 1 },
{ 66, "VK_KHR_shader_subgroup_extended_types", 1 },
{ 67, "VK_KHR_shader_terminate_invocation", 1 },
{ 68, "VK_KHR_spirv_1_4", 1 },
{ 69, "VK_KHR_storage_buffer_storage_class", 1 },
{ 70, "VK_KHR_synchronization2", 1 },
{ 71, "VK_KHR_timeline_semaphore", 2 },
{ 72, "VK_KHR_uniform_buffer_standard_layout", 1 },
{ 73, "VK_KHR_variable_pointers", 1 },
{ 74, "VK_KHR_vulkan_memory_model", 3 },
{ 75, "VK_KHR_zero_initialize_workgroup_memory", 1 },
{ 76, "VK_MESA_venus_protocol", 100000 },
};
found = bsearch(name, ext_names, ext_count, sizeof(ext_names[0]),
vn_info_extension_compare);
return found ? ext_versions[found - ext_names] : 0;
return bsearch(name, vn_info_extensions, 77,
sizeof(*vn_info_extensions), vn_info_extension_compare);
}
#endif /* VN_PROTOCOL_DRIVER_INFO_H */

337
src/virtio/venus-protocol/vn_protocol_driver_pipeline.h
View File

@ -75,12 +75,82 @@ vn_encode_VkSpecializationInfo(struct vn_cs_encoder *enc, const VkSpecialization
}
}
/* struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo chain */
static inline size_t
vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_uint32_t(&val->requiredSubgroupSize);
return size;
}
static inline size_t
vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(val->pNext);
size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(val);
return size;
}
static inline void
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_encode_uint32_t(enc, &val->requiredSubgroupSize);
}
static inline void
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(struct vn_cs_encoder *enc, const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO });
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext(enc, val->pNext);
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, val);
}
/* struct VkPipelineShaderStageCreateInfo chain */
static inline size_t
vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
size_t size = 0;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkPipelineShaderStageCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self((const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@ -120,7 +190,23 @@ vn_sizeof_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo
static inline void
vn_encode_VkPipelineShaderStageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkPipelineShaderStageCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self(enc, (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}
@ -1070,12 +1156,196 @@ vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPi
vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val);
}
/* struct VkPipelineCreationFeedback */
static inline size_t
vn_sizeof_VkPipelineCreationFeedback(const VkPipelineCreationFeedback *val)
{
size_t size = 0;
size += vn_sizeof_VkFlags(&val->flags);
size += vn_sizeof_uint64_t(&val->duration);
return size;
}
static inline void
vn_encode_VkPipelineCreationFeedback(struct vn_cs_encoder *enc, const VkPipelineCreationFeedback *val)
{
vn_encode_VkFlags(enc, &val->flags);
vn_encode_uint64_t(enc, &val->duration);
}
/* struct VkPipelineCreationFeedbackCreateInfo chain */
static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(const VkPipelineCreationFeedbackCreateInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_simple_pointer(val->pPipelineCreationFeedback);
if (val->pPipelineCreationFeedback)
size += vn_sizeof_VkPipelineCreationFeedback(val->pPipelineCreationFeedback);
size += vn_sizeof_uint32_t(&val->pipelineStageCreationFeedbackCount);
if (val->pPipelineStageCreationFeedbacks) {
size += vn_sizeof_array_size(val->pipelineStageCreationFeedbackCount);
for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
size += vn_sizeof_VkPipelineCreationFeedback(&val->pPipelineStageCreationFeedbacks[i]);
} else {
size += vn_sizeof_array_size(0);
}
return size;
}
static inline size_t
vn_sizeof_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_pnext(val->pNext);
size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self(val);
return size;
}
static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val)
{
/* skip val->{sType,pNext} */
if (vn_encode_simple_pointer(enc, val->pPipelineCreationFeedback))
vn_encode_VkPipelineCreationFeedback(enc, val->pPipelineCreationFeedback);
vn_encode_uint32_t(enc, &val->pipelineStageCreationFeedbackCount);
if (val->pPipelineStageCreationFeedbacks) {
vn_encode_array_size(enc, val->pipelineStageCreationFeedbackCount);
for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
vn_encode_VkPipelineCreationFeedback(enc, &val->pPipelineStageCreationFeedbacks[i]);
} else {
vn_encode_array_size(enc, 0);
}
}
static inline void
vn_encode_VkPipelineCreationFeedbackCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackCreateInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO });
vn_encode_VkPipelineCreationFeedbackCreateInfo_pnext(enc, val->pNext);
vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, val);
}
/* struct VkPipelineRenderingCreateInfo chain */
static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo_self(const VkPipelineRenderingCreateInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_uint32_t(&val->viewMask);
size += vn_sizeof_uint32_t(&val->colorAttachmentCount);
if (val->pColorAttachmentFormats) {
size += vn_sizeof_array_size(val->colorAttachmentCount);
size += vn_sizeof_VkFormat_array(val->pColorAttachmentFormats, val->colorAttachmentCount);
} else {
size += vn_sizeof_array_size(0);
}
size += vn_sizeof_VkFormat(&val->depthAttachmentFormat);
size += vn_sizeof_VkFormat(&val->stencilAttachmentFormat);
return size;
}
static inline size_t
vn_sizeof_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPipelineRenderingCreateInfo_pnext(val->pNext);
size += vn_sizeof_VkPipelineRenderingCreateInfo_self(val);
return size;
}
static inline void
vn_encode_VkPipelineRenderingCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPipelineRenderingCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_encode_uint32_t(enc, &val->viewMask);
vn_encode_uint32_t(enc, &val->colorAttachmentCount);
if (val->pColorAttachmentFormats) {
vn_encode_array_size(enc, val->colorAttachmentCount);
vn_encode_VkFormat_array(enc, val->pColorAttachmentFormats, val->colorAttachmentCount);
} else {
vn_encode_array_size(enc, 0);
}
vn_encode_VkFormat(enc, &val->depthAttachmentFormat);
vn_encode_VkFormat(enc, &val->stencilAttachmentFormat);
}
static inline void
vn_encode_VkPipelineRenderingCreateInfo(struct vn_cs_encoder *enc, const VkPipelineRenderingCreateInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO });
vn_encode_VkPipelineRenderingCreateInfo_pnext(enc, val->pNext);
vn_encode_VkPipelineRenderingCreateInfo_self(enc, val);
}
/* struct VkGraphicsPipelineCreateInfo chain */
static inline size_t
vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
size_t size = 0;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext);
return size;
case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPipelineRenderingCreateInfo_self((const VkPipelineRenderingCreateInfo *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@ -1143,7 +1413,29 @@ vn_sizeof_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo *val)
static inline void
vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext);
return;
case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPipelineRenderingCreateInfo_self(enc, (const VkPipelineRenderingCreateInfo *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}
@ -1199,7 +1491,24 @@ vn_encode_VkGraphicsPipelineCreateInfo(struct vn_cs_encoder *enc, const VkGraphi
static inline size_t
vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
size_t size = 0;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkComputePipelineCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPipelineCreationFeedbackCreateInfo_self((const VkPipelineCreationFeedbackCreateInfo *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@ -1231,7 +1540,23 @@ vn_sizeof_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo *val)
static inline void
vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkComputePipelineCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPipelineCreationFeedbackCreateInfo_self(enc, (const VkPipelineCreationFeedbackCreateInfo *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}

481
src/virtio/venus-protocol/vn_protocol_driver_private_data_slot.h Normal file
View File

@ -0,0 +1,481 @@
/* This file is generated by venus-protocol. See vn_protocol_driver.h. */
/*
* Copyright 2020 Google LLC
* SPDX-License-Identifier: MIT
*/
#ifndef VN_PROTOCOL_DRIVER_PRIVATE_DATA_SLOT_H
#define VN_PROTOCOL_DRIVER_PRIVATE_DATA_SLOT_H
#include "vn_instance.h"
#include "vn_protocol_driver_structs.h"
/* struct VkPrivateDataSlotCreateInfo chain */
static inline size_t
vn_sizeof_VkPrivateDataSlotCreateInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPrivateDataSlotCreateInfo_self(const VkPrivateDataSlotCreateInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkFlags(&val->flags);
return size;
}
static inline size_t
vn_sizeof_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPrivateDataSlotCreateInfo_pnext(val->pNext);
size += vn_sizeof_VkPrivateDataSlotCreateInfo_self(val);
return size;
}
static inline void
vn_encode_VkPrivateDataSlotCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPrivateDataSlotCreateInfo_self(struct vn_cs_encoder *enc, const VkPrivateDataSlotCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkFlags(enc, &val->flags);
}
static inline void
vn_encode_VkPrivateDataSlotCreateInfo(struct vn_cs_encoder *enc, const VkPrivateDataSlotCreateInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO });
vn_encode_VkPrivateDataSlotCreateInfo_pnext(enc, val->pNext);
vn_encode_VkPrivateDataSlotCreateInfo_self(enc, val);
}
static inline size_t vn_sizeof_vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
if (pCreateInfo)
cmd_size += vn_sizeof_VkPrivateDataSlotCreateInfo(pCreateInfo);
cmd_size += vn_sizeof_simple_pointer(pAllocator);
if (pAllocator)
assert(false);
cmd_size += vn_sizeof_simple_pointer(pPrivateDataSlot);
if (pPrivateDataSlot)
cmd_size += vn_sizeof_VkPrivateDataSlot(pPrivateDataSlot);
return cmd_size;
}
static inline void vn_encode_vkCreatePrivateDataSlot(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
if (vn_encode_simple_pointer(enc, pCreateInfo))
vn_encode_VkPrivateDataSlotCreateInfo(enc, pCreateInfo);
if (vn_encode_simple_pointer(enc, pAllocator))
assert(false);
if (vn_encode_simple_pointer(enc, pPrivateDataSlot))
vn_encode_VkPrivateDataSlot(enc, pPrivateDataSlot);
}
static inline size_t vn_sizeof_vkCreatePrivateDataSlot_reply(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
VkResult ret;
cmd_size += vn_sizeof_VkResult(&ret);
/* skip device */
/* skip pCreateInfo */
/* skip pAllocator */
cmd_size += vn_sizeof_simple_pointer(pPrivateDataSlot);
if (pPrivateDataSlot)
cmd_size += vn_sizeof_VkPrivateDataSlot(pPrivateDataSlot);
return cmd_size;
}
static inline VkResult vn_decode_vkCreatePrivateDataSlot_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT);
VkResult ret;
vn_decode_VkResult(dec, &ret);
/* skip device */
/* skip pCreateInfo */
/* skip pAllocator */
if (vn_decode_simple_pointer(dec)) {
vn_decode_VkPrivateDataSlot(dec, pPrivateDataSlot);
} else {
pPrivateDataSlot = NULL;
}
return ret;
}
static inline size_t vn_sizeof_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_VkPrivateDataSlot(&privateDataSlot);
cmd_size += vn_sizeof_simple_pointer(pAllocator);
if (pAllocator)
assert(false);
return cmd_size;
}
static inline void vn_encode_vkDestroyPrivateDataSlot(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
vn_encode_VkPrivateDataSlot(enc, &privateDataSlot);
if (vn_encode_simple_pointer(enc, pAllocator))
assert(false);
}
static inline size_t vn_sizeof_vkDestroyPrivateDataSlot_reply(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip privateDataSlot */
/* skip pAllocator */
return cmd_size;
}
static inline void vn_decode_vkDestroyPrivateDataSlot_reply(struct vn_cs_decoder *dec, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT);
/* skip device */
/* skip privateDataSlot */
/* skip pAllocator */
}
static inline size_t vn_sizeof_vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetPrivateData_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_VkObjectType(&objectType);
cmd_size += vn_sizeof_uint64_t(&objectHandle);
cmd_size += vn_sizeof_VkPrivateDataSlot(&privateDataSlot);
cmd_size += vn_sizeof_uint64_t(&data);
return cmd_size;
}
static inline void vn_encode_vkSetPrivateData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetPrivateData_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
vn_encode_VkObjectType(enc, &objectType);
vn_encode_uint64_t(enc, &objectHandle);
vn_encode_VkPrivateDataSlot(enc, &privateDataSlot);
vn_encode_uint64_t(enc, &data);
}
static inline size_t vn_sizeof_vkSetPrivateData_reply(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetPrivateData_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
VkResult ret;
cmd_size += vn_sizeof_VkResult(&ret);
/* skip device */
/* skip objectType */
/* skip objectHandle */
/* skip privateDataSlot */
/* skip data */
return cmd_size;
}
static inline VkResult vn_decode_vkSetPrivateData_reply(struct vn_cs_decoder *dec, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkSetPrivateData_EXT);
VkResult ret;
vn_decode_VkResult(dec, &ret);
/* skip device */
/* skip objectType */
/* skip objectHandle */
/* skip privateDataSlot */
/* skip data */
return ret;
}
static inline size_t vn_sizeof_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPrivateData_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkDevice(&device);
cmd_size += vn_sizeof_VkObjectType(&objectType);
cmd_size += vn_sizeof_uint64_t(&objectHandle);
cmd_size += vn_sizeof_VkPrivateDataSlot(&privateDataSlot);
cmd_size += vn_sizeof_simple_pointer(pData); /* out */
return cmd_size;
}
static inline void vn_encode_vkGetPrivateData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPrivateData_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
vn_encode_VkObjectType(enc, &objectType);
vn_encode_uint64_t(enc, &objectHandle);
vn_encode_VkPrivateDataSlot(enc, &privateDataSlot);
vn_encode_simple_pointer(enc, pData); /* out */
}
static inline size_t vn_sizeof_vkGetPrivateData_reply(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPrivateData_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip objectType */
/* skip objectHandle */
/* skip privateDataSlot */
cmd_size += vn_sizeof_simple_pointer(pData);
if (pData)
cmd_size += vn_sizeof_uint64_t(pData);
return cmd_size;
}
static inline void vn_decode_vkGetPrivateData_reply(struct vn_cs_decoder *dec, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetPrivateData_EXT);
/* skip device */
/* skip objectType */
/* skip objectHandle */
/* skip privateDataSlot */
if (vn_decode_simple_pointer(dec)) {
vn_decode_uint64_t(dec, pData);
} else {
pData = NULL;
}
}
static inline void vn_submit_vkCreatePrivateDataSlot(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePrivateDataSlot_reply(device, pCreateInfo, pAllocator, pPrivateDataSlot) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCreatePrivateDataSlot(enc, cmd_flags, device, pCreateInfo, pAllocator, pPrivateDataSlot);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkDestroyPrivateDataSlot(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPrivateDataSlot_reply(device, privateDataSlot, pAllocator) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkDestroyPrivateDataSlot(enc, cmd_flags, device, privateDataSlot, pAllocator);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkSetPrivateData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetPrivateData_reply(device, objectType, objectHandle, privateDataSlot, data) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkSetPrivateData(enc, cmd_flags, device, objectType, objectHandle, privateDataSlot, data);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetPrivateData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPrivateData_reply(device, objectType, objectHandle, privateDataSlot, pData) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetPrivateData(enc, cmd_flags, device, objectType, objectHandle, privateDataSlot, pData);
vn_instance_submit_command(vn_instance, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline VkResult vn_call_vkCreatePrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkCreatePrivateDataSlot(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPrivateDataSlot, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkCreatePrivateDataSlot_reply(dec, device, pCreateInfo, pAllocator, pPrivateDataSlot);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
}
static inline void vn_async_vkCreatePrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
struct vn_instance_submit_command submit;
vn_submit_vkCreatePrivateDataSlot(vn_instance, 0, device, pCreateInfo, pAllocator, pPrivateDataSlot, &submit);
}
static inline void vn_call_vkDestroyPrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkDestroyPrivateDataSlot(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, privateDataSlot, pAllocator, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkDestroyPrivateDataSlot_reply(dec, device, privateDataSlot, pAllocator);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkDestroyPrivateDataSlot(struct vn_instance *vn_instance, VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
struct vn_instance_submit_command submit;
vn_submit_vkDestroyPrivateDataSlot(vn_instance, 0, device, privateDataSlot, pAllocator, &submit);
}
static inline VkResult vn_call_vkSetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkSetPrivateData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, objectType, objectHandle, privateDataSlot, data, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkSetPrivateData_reply(dec, device, objectType, objectHandle, privateDataSlot, data);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
}
static inline void vn_async_vkSetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
struct vn_instance_submit_command submit;
vn_submit_vkSetPrivateData(vn_instance, 0, device, objectType, objectHandle, privateDataSlot, data, &submit);
}
static inline void vn_call_vkGetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkGetPrivateData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, objectType, objectHandle, privateDataSlot, pData, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
vn_decode_vkGetPrivateData_reply(dec, device, objectType, objectHandle, privateDataSlot, pData);
vn_instance_free_command_reply(vn_instance, &submit);
}
}
static inline void vn_async_vkGetPrivateData(struct vn_instance *vn_instance, VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
struct vn_instance_submit_command submit;
vn_submit_vkGetPrivateData(vn_instance, 0, device, objectType, objectHandle, privateDataSlot, pData, &submit);
}
#endif /* VN_PROTOCOL_DRIVER_PRIVATE_DATA_SLOT_H */

328
src/virtio/venus-protocol/vn_protocol_driver_queue.h
View File

@ -783,6 +783,221 @@ vn_encode_VkBindSparseInfo(struct vn_cs_encoder *enc, const VkBindSparseInfo *va
vn_encode_VkBindSparseInfo_self(enc, val);
}
/* struct VkSemaphoreSubmitInfo chain */
static inline size_t
vn_sizeof_VkSemaphoreSubmitInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkSemaphoreSubmitInfo_self(const VkSemaphoreSubmitInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkSemaphore(&val->semaphore);
size += vn_sizeof_uint64_t(&val->value);
size += vn_sizeof_VkFlags64(&val->stageMask);
size += vn_sizeof_uint32_t(&val->deviceIndex);
return size;
}
static inline size_t
vn_sizeof_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkSemaphoreSubmitInfo_pnext(val->pNext);
size += vn_sizeof_VkSemaphoreSubmitInfo_self(val);
return size;
}
static inline void
vn_encode_VkSemaphoreSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkSemaphoreSubmitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSubmitInfo *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkSemaphore(enc, &val->semaphore);
vn_encode_uint64_t(enc, &val->value);
vn_encode_VkFlags64(enc, &val->stageMask);
vn_encode_uint32_t(enc, &val->deviceIndex);
}
static inline void
vn_encode_VkSemaphoreSubmitInfo(struct vn_cs_encoder *enc, const VkSemaphoreSubmitInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO });
vn_encode_VkSemaphoreSubmitInfo_pnext(enc, val->pNext);
vn_encode_VkSemaphoreSubmitInfo_self(enc, val);
}
/* struct VkCommandBufferSubmitInfo chain */
static inline size_t
vn_sizeof_VkCommandBufferSubmitInfo_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkCommandBufferSubmitInfo_self(const VkCommandBufferSubmitInfo *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkCommandBuffer(&val->commandBuffer);
size += vn_sizeof_uint32_t(&val->deviceMask);
return size;
}
static inline size_t
vn_sizeof_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkCommandBufferSubmitInfo_pnext(val->pNext);
size += vn_sizeof_VkCommandBufferSubmitInfo_self(val);
return size;
}
static inline void
vn_encode_VkCommandBufferSubmitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkCommandBufferSubmitInfo_self(struct vn_cs_encoder *enc, const VkCommandBufferSubmitInfo *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkCommandBuffer(enc, &val->commandBuffer);
vn_encode_uint32_t(enc, &val->deviceMask);
}
static inline void
vn_encode_VkCommandBufferSubmitInfo(struct vn_cs_encoder *enc, const VkCommandBufferSubmitInfo *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO });
vn_encode_VkCommandBufferSubmitInfo_pnext(enc, val->pNext);
vn_encode_VkCommandBufferSubmitInfo_self(enc, val);
}
/* struct VkSubmitInfo2 chain */
static inline size_t
vn_sizeof_VkSubmitInfo2_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkSubmitInfo2_self(const VkSubmitInfo2 *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkFlags(&val->flags);
size += vn_sizeof_uint32_t(&val->waitSemaphoreInfoCount);
if (val->pWaitSemaphoreInfos) {
size += vn_sizeof_array_size(val->waitSemaphoreInfoCount);
for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++)
size += vn_sizeof_VkSemaphoreSubmitInfo(&val->pWaitSemaphoreInfos[i]);
} else {
size += vn_sizeof_array_size(0);
}
size += vn_sizeof_uint32_t(&val->commandBufferInfoCount);
if (val->pCommandBufferInfos) {
size += vn_sizeof_array_size(val->commandBufferInfoCount);
for (uint32_t i = 0; i < val->commandBufferInfoCount; i++)
size += vn_sizeof_VkCommandBufferSubmitInfo(&val->pCommandBufferInfos[i]);
} else {
size += vn_sizeof_array_size(0);
}
size += vn_sizeof_uint32_t(&val->signalSemaphoreInfoCount);
if (val->pSignalSemaphoreInfos) {
size += vn_sizeof_array_size(val->signalSemaphoreInfoCount);
for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++)
size += vn_sizeof_VkSemaphoreSubmitInfo(&val->pSignalSemaphoreInfos[i]);
} else {
size += vn_sizeof_array_size(0);
}
return size;
}
static inline size_t
vn_sizeof_VkSubmitInfo2(const VkSubmitInfo2 *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkSubmitInfo2_pnext(val->pNext);
size += vn_sizeof_VkSubmitInfo2_self(val);
return size;
}
static inline void
vn_encode_VkSubmitInfo2_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkSubmitInfo2_self(struct vn_cs_encoder *enc, const VkSubmitInfo2 *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkFlags(enc, &val->flags);
vn_encode_uint32_t(enc, &val->waitSemaphoreInfoCount);
if (val->pWaitSemaphoreInfos) {
vn_encode_array_size(enc, val->waitSemaphoreInfoCount);
for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++)
vn_encode_VkSemaphoreSubmitInfo(enc, &val->pWaitSemaphoreInfos[i]);
} else {
vn_encode_array_size(enc, 0);
}
vn_encode_uint32_t(enc, &val->commandBufferInfoCount);
if (val->pCommandBufferInfos) {
vn_encode_array_size(enc, val->commandBufferInfoCount);
for (uint32_t i = 0; i < val->commandBufferInfoCount; i++)
vn_encode_VkCommandBufferSubmitInfo(enc, &val->pCommandBufferInfos[i]);
} else {
vn_encode_array_size(enc, 0);
}
vn_encode_uint32_t(enc, &val->signalSemaphoreInfoCount);
if (val->pSignalSemaphoreInfos) {
vn_encode_array_size(enc, val->signalSemaphoreInfoCount);
for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++)
vn_encode_VkSemaphoreSubmitInfo(enc, &val->pSignalSemaphoreInfos[i]);
} else {
vn_encode_array_size(enc, 0);
}
}
static inline void
vn_encode_VkSubmitInfo2(struct vn_cs_encoder *enc, const VkSubmitInfo2 *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_SUBMIT_INFO_2);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBMIT_INFO_2 });
vn_encode_VkSubmitInfo2_pnext(enc, val->pNext);
vn_encode_VkSubmitInfo2_self(enc, val);
}
static inline size_t vn_sizeof_vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit_EXT;
@ -969,6 +1184,76 @@ static inline VkResult vn_decode_vkQueueBindSparse_reply(struct vn_cs_decoder *d
return ret;
}
static inline size_t vn_sizeof_vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkQueue(&queue);
cmd_size += vn_sizeof_uint32_t(&submitCount);
if (pSubmits) {
cmd_size += vn_sizeof_array_size(submitCount);
for (uint32_t i = 0; i < submitCount; i++)
cmd_size += vn_sizeof_VkSubmitInfo2(&pSubmits[i]);
} else {
cmd_size += vn_sizeof_array_size(0);
}
cmd_size += vn_sizeof_VkFence(&fence);
return cmd_size;
}
static inline void vn_encode_vkQueueSubmit2(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkQueue(enc, &queue);
vn_encode_uint32_t(enc, &submitCount);
if (pSubmits) {
vn_encode_array_size(enc, submitCount);
for (uint32_t i = 0; i < submitCount; i++)
vn_encode_VkSubmitInfo2(enc, &pSubmits[i]);
} else {
vn_encode_array_size(enc, 0);
}
vn_encode_VkFence(enc, &fence);
}
static inline size_t vn_sizeof_vkQueueSubmit2_reply(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkQueueSubmit2_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
VkResult ret;
cmd_size += vn_sizeof_VkResult(&ret);
/* skip queue */
/* skip submitCount */
/* skip pSubmits */
/* skip fence */
return cmd_size;
}
static inline VkResult vn_decode_vkQueueSubmit2_reply(struct vn_cs_decoder *dec, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkQueueSubmit2_EXT);
VkResult ret;
vn_decode_VkResult(dec, &ret);
/* skip queue */
/* skip submitCount */
/* skip pSubmits */
/* skip fence */
return ret;
}
static inline void vn_submit_vkQueueSubmit(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@ -1032,6 +1317,27 @@ static inline void vn_submit_vkQueueBindSparse(struct vn_instance *vn_instance,
}
}
static inline void vn_submit_vkQueueSubmit2(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence, struct vn_instance_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
void *cmd_data = local_cmd_data;
size_t cmd_size = vn_sizeof_vkQueueSubmit2(queue, submitCount, pSubmits, fence);
if (cmd_size > sizeof(local_cmd_data)) {
cmd_data = malloc(cmd_size);
if (!cmd_data)
cmd_size = 0;
}
const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkQueueSubmit2_reply(queue, submitCount, pSubmits, fence) : 0;
struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkQueueSubmit2(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 VkResult vn_call_vkQueueSubmit(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
{
VN_TRACE_FUNC();
@ -1098,4 +1404,26 @@ static inline void vn_async_vkQueueBindSparse(struct vn_instance *vn_instance, V
vn_submit_vkQueueBindSparse(vn_instance, 0, queue, bindInfoCount, pBindInfo, fence, &submit);
}
static inline VkResult vn_call_vkQueueSubmit2(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
VN_TRACE_FUNC();
struct vn_instance_submit_command submit;
vn_submit_vkQueueSubmit2(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, queue, submitCount, pSubmits, fence, &submit);
struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
if (dec) {
const VkResult ret = vn_decode_vkQueueSubmit2_reply(dec, queue, submitCount, pSubmits, fence);
vn_instance_free_command_reply(vn_instance, &submit);
return ret;
} else {
return VK_ERROR_OUT_OF_HOST_MEMORY;
}
}
static inline void vn_async_vkQueueSubmit2(struct vn_instance *vn_instance, VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
struct vn_instance_submit_command submit;
vn_submit_vkQueueSubmit2(vn_instance, 0, queue, submitCount, pSubmits, fence, &submit);
}
#endif /* VN_PROTOCOL_DRIVER_QUEUE_H */

37
src/virtio/venus-protocol/vn_protocol_driver_render_pass.h
View File

@ -1018,7 +1018,24 @@ vn_encode_VkSubpassDescription2(struct vn_cs_encoder *enc, const VkSubpassDescri
static inline size_t
vn_sizeof_VkSubpassDependency2_pnext(const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
size_t size = 0;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkSubpassDependency2_pnext(pnext->pNext);
size += vn_sizeof_VkMemoryBarrier2_self((const VkMemoryBarrier2 *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@ -1053,7 +1070,23 @@ vn_sizeof_VkSubpassDependency2(const VkSubpassDependency2 *val)
static inline void
vn_encode_VkSubpassDependency2_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
const VkBaseInStructure *pnext = val;
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkSubpassDependency2_pnext(enc, pnext->pNext);
vn_encode_VkMemoryBarrier2_self(enc, (const VkMemoryBarrier2 *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}

120
src/virtio/venus-protocol/vn_protocol_driver_structs.h
View File

@ -394,6 +394,40 @@ vn_encode_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFo
vn_encode_VkImageFormatListCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkImageFormatListCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkImageFormatListCreateInfo_self(struct vn_cs_decoder *dec, VkImageFormatListCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_uint32_t(dec, &val->viewFormatCount);
if (vn_peek_array_size(dec)) {
const size_t array_size = vn_decode_array_size(dec, val->viewFormatCount);
vn_decode_VkFormat_array(dec, (VkFormat *)val->pViewFormats, array_size);
} else {
vn_decode_array_size_unchecked(dec);
val->pViewFormats = NULL;
}
}
static inline void
vn_decode_VkImageFormatListCreateInfo(struct vn_cs_decoder *dec, VkImageFormatListCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkImageFormatListCreateInfo_pnext(dec, val->pNext);
vn_decode_VkImageFormatListCreateInfo_self(dec, val);
}
/* struct VkImageStencilUsageCreateInfo chain */
static inline size_t
@ -447,6 +481,33 @@ vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImage
vn_encode_VkImageStencilUsageCreateInfo_self(enc, val);
}
static inline void
vn_decode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_decoder *dec, const void *val)
{
/* no known/supported struct */
if (vn_decode_simple_pointer(dec))
assert(false);
}
static inline void
vn_decode_VkImageStencilUsageCreateInfo_self(struct vn_cs_decoder *dec, VkImageStencilUsageCreateInfo *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkFlags(dec, &val->stencilUsage);
}
static inline void
vn_decode_VkImageStencilUsageCreateInfo(struct vn_cs_decoder *dec, VkImageStencilUsageCreateInfo *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
assert(val->sType == stype);
vn_decode_VkImageStencilUsageCreateInfo_pnext(dec, val->pNext);
vn_decode_VkImageStencilUsageCreateInfo_self(dec, val);
}
/* struct VkComponentMapping */
static inline size_t
@ -1024,4 +1085,63 @@ vn_encode_VkMemoryRequirements2_partial(struct vn_cs_encoder *enc, const VkMemor
vn_encode_VkMemoryRequirements2_self_partial(enc, val);
}
/* struct VkMemoryBarrier2 chain */
static inline size_t
vn_sizeof_VkMemoryBarrier2_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkMemoryBarrier2_self(const VkMemoryBarrier2 *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkFlags64(&val->srcStageMask);
size += vn_sizeof_VkFlags64(&val->srcAccessMask);
size += vn_sizeof_VkFlags64(&val->dstStageMask);
size += vn_sizeof_VkFlags64(&val->dstAccessMask);
return size;
}
static inline size_t
vn_sizeof_VkMemoryBarrier2(const VkMemoryBarrier2 *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkMemoryBarrier2_pnext(val->pNext);
size += vn_sizeof_VkMemoryBarrier2_self(val);
return size;
}
static inline void
vn_encode_VkMemoryBarrier2_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkMemoryBarrier2_self(struct vn_cs_encoder *enc, const VkMemoryBarrier2 *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkFlags64(enc, &val->srcStageMask);
vn_encode_VkFlags64(enc, &val->srcAccessMask);
vn_encode_VkFlags64(enc, &val->dstStageMask);
vn_encode_VkFlags64(enc, &val->dstAccessMask);
}
static inline void
vn_encode_VkMemoryBarrier2(struct vn_cs_encoder *enc, const VkMemoryBarrier2 *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_MEMORY_BARRIER_2);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 });
vn_encode_VkMemoryBarrier2_pnext(enc, val->pNext);
vn_encode_VkMemoryBarrier2_self(enc, val);
}
#endif /* VN_PROTOCOL_DRIVER_STRUCTS_H */

227
src/virtio/venus-protocol/vn_protocol_driver_types.h
View File

@ -534,6 +534,26 @@ vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count)
vn_decode_uint32_t_array(dec, val, count);
}
/* typedef uint64_t VkFlags64 */
static inline size_t
vn_sizeof_VkFlags64(const VkFlags64 *val)
{
return vn_sizeof_uint64_t(val);
}
static inline void
vn_encode_VkFlags64(struct vn_cs_encoder *enc, const VkFlags64 *val)
{
vn_encode_uint64_t(enc, val);
}
static inline void
vn_decode_VkFlags64(struct vn_cs_decoder *dec, VkFlags64 *val)
{
vn_decode_uint64_t(dec, val);
}
/* typedef uint64_t VkDeviceSize */
static inline size_t
@ -694,6 +714,48 @@ vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCac
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkPipelineDepthStencilStateCreateFlagBits */
static inline size_t
vn_sizeof_VkPipelineDepthStencilStateCreateFlagBits(const VkPipelineDepthStencilStateCreateFlagBits *val)
{
assert(sizeof(*val) == sizeof(int32_t));
return vn_sizeof_int32_t((const int32_t *)val);
}
static inline void
vn_encode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateFlagBits *val)
{
vn_encode_int32_t(enc, (const int32_t *)val);
}
static inline void
vn_decode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateFlagBits *val)
{
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkPipelineColorBlendStateCreateFlagBits */
static inline size_t
vn_sizeof_VkPipelineColorBlendStateCreateFlagBits(const VkPipelineColorBlendStateCreateFlagBits *val)
{
assert(sizeof(*val) == sizeof(int32_t));
return vn_sizeof_int32_t((const int32_t *)val);
}
static inline void
vn_encode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateFlagBits *val)
{
vn_encode_int32_t(enc, (const int32_t *)val);
}
static inline void
vn_decode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateFlagBits *val)
{
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkPipelineShaderStageCreateFlagBits */
static inline size_t
@ -1345,6 +1407,24 @@ vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits
vn_decode_int32_t(dec, (int32_t *)val);
}
static inline size_t
vn_sizeof_VkSampleCountFlagBits_array(const VkSampleCountFlagBits *val, uint32_t count)
{
return vn_sizeof_int32_t_array((const int32_t *)val, count);
}
static inline void
vn_encode_VkSampleCountFlagBits_array(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val, uint32_t count)
{
vn_encode_int32_t_array(enc, (const int32_t *)val, count);
}
static inline void
vn_decode_VkSampleCountFlagBits_array(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val, uint32_t count)
{
vn_decode_int32_t_array(dec, (int32_t *)val, count);
}
/* enum VkAttachmentDescriptionFlagBits */
static inline size_t
@ -1471,6 +1551,27 @@ vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeature
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkPipelineCreationFeedbackFlagBits */
static inline size_t
vn_sizeof_VkPipelineCreationFeedbackFlagBits(const VkPipelineCreationFeedbackFlagBits *val)
{
assert(sizeof(*val) == sizeof(int32_t));
return vn_sizeof_int32_t((const int32_t *)val);
}
static inline void
vn_encode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackFlagBits *val)
{
vn_encode_int32_t(enc, (const int32_t *)val);
}
static inline void
vn_decode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackFlagBits *val)
{
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkSemaphoreWaitFlagBits */
static inline size_t
@ -1492,6 +1593,90 @@ vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlag
vn_decode_int32_t(dec, (int32_t *)val);
}
/* typedef VkFlags64 VkAccessFlagBits2 */
static inline size_t
vn_sizeof_VkAccessFlagBits2(const VkAccessFlagBits2 *val)
{
assert(sizeof(*val) == sizeof(uint64_t));
return vn_sizeof_uint64_t((const uint64_t *)val);
}
static inline void
vn_encode_VkAccessFlagBits2(struct vn_cs_encoder *enc, const VkAccessFlagBits2 *val)
{
vn_encode_uint64_t(enc, (const uint64_t *)val);
}
static inline void
vn_decode_VkAccessFlagBits2(struct vn_cs_decoder *dec, VkAccessFlagBits2 *val)
{
vn_decode_uint64_t(dec, (uint64_t *)val);
}
/* typedef VkFlags64 VkPipelineStageFlagBits2 */
static inline size_t
vn_sizeof_VkPipelineStageFlagBits2(const VkPipelineStageFlagBits2 *val)
{
assert(sizeof(*val) == sizeof(uint64_t));
return vn_sizeof_uint64_t((const uint64_t *)val);
}
static inline void
vn_encode_VkPipelineStageFlagBits2(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits2 *val)
{
vn_encode_uint64_t(enc, (const uint64_t *)val);
}
static inline void
vn_decode_VkPipelineStageFlagBits2(struct vn_cs_decoder *dec, VkPipelineStageFlagBits2 *val)
{
vn_decode_uint64_t(dec, (uint64_t *)val);
}
/* typedef VkFlags64 VkFormatFeatureFlagBits2 */
static inline size_t
vn_sizeof_VkFormatFeatureFlagBits2(const VkFormatFeatureFlagBits2 *val)
{
assert(sizeof(*val) == sizeof(uint64_t));
return vn_sizeof_uint64_t((const uint64_t *)val);
}
static inline void
vn_encode_VkFormatFeatureFlagBits2(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits2 *val)
{
vn_encode_uint64_t(enc, (const uint64_t *)val);
}
static inline void
vn_decode_VkFormatFeatureFlagBits2(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits2 *val)
{
vn_decode_uint64_t(dec, (uint64_t *)val);
}
/* enum VkRenderingFlagBits */
static inline size_t
vn_sizeof_VkRenderingFlagBits(const VkRenderingFlagBits *val)
{
assert(sizeof(*val) == sizeof(int32_t));
return vn_sizeof_int32_t((const int32_t *)val);
}
static inline void
vn_encode_VkRenderingFlagBits(struct vn_cs_encoder *enc, const VkRenderingFlagBits *val)
{
vn_encode_int32_t(enc, (const int32_t *)val);
}
static inline void
vn_decode_VkRenderingFlagBits(struct vn_cs_decoder *dec, VkRenderingFlagBits *val)
{
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkPeerMemoryFeatureFlagBits */
static inline size_t
@ -1744,6 +1929,48 @@ vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkToolPurposeFlagBits */
static inline size_t
vn_sizeof_VkToolPurposeFlagBits(const VkToolPurposeFlagBits *val)
{
assert(sizeof(*val) == sizeof(int32_t));
return vn_sizeof_int32_t((const int32_t *)val);
}
static inline void
vn_encode_VkToolPurposeFlagBits(struct vn_cs_encoder *enc, const VkToolPurposeFlagBits *val)
{
vn_encode_int32_t(enc, (const int32_t *)val);
}
static inline void
vn_decode_VkToolPurposeFlagBits(struct vn_cs_decoder *dec, VkToolPurposeFlagBits *val)
{
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkSubmitFlagBits */
static inline size_t
vn_sizeof_VkSubmitFlagBits(const VkSubmitFlagBits *val)
{
assert(sizeof(*val) == sizeof(int32_t));
return vn_sizeof_int32_t((const int32_t *)val);
}
static inline void
vn_encode_VkSubmitFlagBits(struct vn_cs_encoder *enc, const VkSubmitFlagBits *val)
{
vn_encode_int32_t(enc, (const int32_t *)val);
}
static inline void
vn_decode_VkSubmitFlagBits(struct vn_cs_decoder *dec, VkSubmitFlagBits *val)
{
vn_decode_int32_t(dec, (int32_t *)val);
}
/* enum VkAttachmentLoadOp */
static inline size_t

14
src/virtio/vulkan/vn_instance.c
View File

@ -267,17 +267,19 @@ vn_instance_init_renderer(struct vn_instance *instance)
return VK_ERROR_INITIALIZATION_FAILED;
}
version = vn_info_extension_spec_version("VK_EXT_command_serialization");
const struct vn_info_extension *ext =
vn_info_extension_get("VK_EXT_command_serialization");
if (instance->renderer_info.vk_ext_command_serialization_spec_version >
version) {
ext->spec_version) {
instance->renderer_info.vk_ext_command_serialization_spec_version =
version;
ext->spec_version;
}
version = vn_info_extension_spec_version("VK_MESA_venus_protocol");
ext = vn_info_extension_get("VK_MESA_venus_protocol");
if (instance->renderer_info.vk_mesa_venus_protocol_spec_version >
version) {
instance->renderer_info.vk_mesa_venus_protocol_spec_version = version;
ext->spec_version) {
instance->renderer_info.vk_mesa_venus_protocol_spec_version =
ext->spec_version;
}
if (VN_DEBUG(INIT)) {

8
src/virtio/vulkan/vn_physical_device.c
View File

@ -1048,14 +1048,14 @@ vn_physical_device_init_renderer_extensions(
continue;
/* check encoder support */
const uint32_t spec_version =
vn_info_extension_spec_version(props->extensionName);
if (!spec_version)
const struct vn_info_extension *enc_ext =
vn_info_extension_get(props->extensionName);
if (!enc_ext)
continue;
physical_dev->renderer_extensions.extensions[i] = true;
physical_dev->extension_spec_versions[i] =
MIN2(exts[j].specVersion, spec_version);
MIN2(exts[j].specVersion, enc_ext->spec_version);
break;
}