OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

venus: sync protocol for VK_KHR_maintenance5

Browse Source 
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>

Signed-off-by: Corentin Noël <corentin.noel@collabora.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/29058>
This commit is contained in:
Corentin Noël
2024-05-06 10:45:49 +02:00
committed by Marge Bot
parent 51d6162c80
commit 3359fbc25b
12 changed files with 1315 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,4 +1,4 @@
/* This file is generated by venus-protocol git-879064be. */
/* This file is generated by venus-protocol git-028d2c84. */
/*
* Copyright 2020 Google LLC

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

@@ -127,6 +127,14 @@ vn_sizeof_VkBufferCreateInfo_pnext(const void *val)
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkBufferCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_self((const VkBufferUsageFlags2CreateInfoKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
@@ -187,6 +195,14 @@ vn_encode_VkBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkBufferUsageFlags2CreateInfoKHR_self(enc, (const VkBufferUsageFlags2CreateInfoKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);

41
src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h
View File

@@ -16,7 +16,26 @@
static inline size_t
vn_sizeof_VkBufferViewCreateInfo_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_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkBufferViewCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_self((const VkBufferUsageFlags2CreateInfoKHR *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@@ -48,7 +67,25 @@ vn_sizeof_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *val)
static inline void
vn_encode_VkBufferViewCreateInfo_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_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkBufferViewCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkBufferUsageFlags2CreateInfoKHR_self(enc, (const VkBufferUsageFlags2CreateInfoKHR *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}

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

@@ -7220,6 +7220,62 @@ static inline void vn_decode_vkCmdSetScissorWithCount_reply(struct vn_cs_decoder
/* skip pScissors */
}
static inline size_t vn_sizeof_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer2KHR_EXT;
const VkFlags cmd_flags = 0;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
cmd_size += vn_sizeof_VkCommandBuffer(&commandBuffer);
cmd_size += vn_sizeof_VkBuffer(&buffer);
cmd_size += vn_sizeof_VkDeviceSize(&offset);
cmd_size += vn_sizeof_VkDeviceSize(&size);
cmd_size += vn_sizeof_VkIndexType(&indexType);
return cmd_size;
}
static inline void vn_encode_vkCmdBindIndexBuffer2KHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer2KHR_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkCommandBuffer(enc, &commandBuffer);
vn_encode_VkBuffer(enc, &buffer);
vn_encode_VkDeviceSize(enc, &offset);
vn_encode_VkDeviceSize(enc, &size);
vn_encode_VkIndexType(enc, &indexType);
}
static inline size_t vn_sizeof_vkCmdBindIndexBuffer2KHR_reply(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindIndexBuffer2KHR_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip commandBuffer */
/* skip buffer */
/* skip offset */
/* skip size */
/* skip indexType */
return cmd_size;
}
static inline void vn_decode_vkCmdBindIndexBuffer2KHR_reply(struct vn_cs_decoder *dec, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkCmdBindIndexBuffer2KHR_EXT);
/* skip commandBuffer */
/* skip buffer */
/* skip offset */
/* skip size */
/* skip indexType */
}
static inline size_t vn_sizeof_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT;
@@ -11209,6 +11265,27 @@ static inline void vn_submit_vkCmdSetScissorWithCount(struct vn_ring *vn_ring, V
}
}
static inline void vn_submit_vkCmdBindIndexBuffer2KHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType, struct vn_ring_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_vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType);
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_vkCmdBindIndexBuffer2KHR_reply(commandBuffer, buffer, offset, size, indexType) : 0;
struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkCmdBindIndexBuffer2KHR(enc, cmd_flags, commandBuffer, buffer, offset, size, indexType);
vn_ring_submit_command(vn_ring, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCmdBindVertexBuffers2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides, struct vn_ring_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@@ -13637,6 +13714,25 @@ static inline void vn_async_vkCmdSetScissorWithCount(struct vn_ring *vn_ring, Vk
vn_submit_vkCmdSetScissorWithCount(vn_ring, 0, commandBuffer, scissorCount, pScissors, &submit);
}
static inline void vn_call_vkCmdBindIndexBuffer2KHR(struct vn_ring *vn_ring, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
VN_TRACE_FUNC();
struct vn_ring_submit_command submit;
vn_submit_vkCmdBindIndexBuffer2KHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, commandBuffer, buffer, offset, size, indexType, &submit);
struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
if (dec) {
vn_decode_vkCmdBindIndexBuffer2KHR_reply(dec, commandBuffer, buffer, offset, size, indexType);
vn_ring_free_command_reply(vn_ring, &submit);
}
}
static inline void vn_async_vkCmdBindIndexBuffer2KHR(struct vn_ring *vn_ring, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType)
{
struct vn_ring_submit_command submit;
vn_submit_vkCmdBindIndexBuffer2KHR(vn_ring, 0, commandBuffer, buffer, offset, size, indexType, &submit);
}
static inline void vn_call_vkCmdBindVertexBuffers2(struct vn_ring *vn_ring, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
{
VN_TRACE_FUNC();

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

@@ -368,6 +368,11 @@ typedef enum VkCommandTypeEXT {
VK_COMMAND_TYPE_vkCmdSetLineRasterizationModeEXT_EXT = 274,
VK_COMMAND_TYPE_vkCmdSetLineStippleEnableEXT_EXT = 275,
VK_COMMAND_TYPE_vkCmdSetDepthClipNegativeOneToOneEXT_EXT = 276,
VK_COMMAND_TYPE_vkCmdBindIndexBuffer2KHR_EXT = 279,
VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT = 280,
VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT = 281,
VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT = 282,
VK_COMMAND_TYPE_vkGetImageSubresourceLayout2EXT_EXT = 282,
VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT = 178,
VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT = 179,
VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT = 180,

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

@@ -2636,6 +2636,137 @@ vn_encode_VkPhysicalDeviceMaintenance4Features_partial(struct vn_cs_encoder *enc
vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, val);
}
/* struct VkPhysicalDeviceMaintenance5FeaturesKHR chain */
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkBool32(&val->maintenance5);
return size;
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(val->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self(val);
return size;
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkBool32(enc, &val->maintenance5);
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR });
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(enc, val->pNext);
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(enc, val);
}
static inline void
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_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_VkPhysicalDeviceMaintenance5FeaturesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkBool32(dec, &val->maintenance5);
}
static inline void
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
assert(val->sType == stype);
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext(dec, val->pNext);
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(dec, val);
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
/* skip val->maintenance5 */
return size;
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_partial(const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(val->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(val);
return size;
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
/* skip val->{sType,pNext} */
/* skip val->maintenance5 */
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5FeaturesKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR });
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_pnext_partial(enc, val->pNext);
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(enc, val);
}
/* struct VkPhysicalDeviceShaderDrawParametersFeatures chain */
static inline size_t
@@ -11092,6 +11223,14 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext(const void *val)
size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self((const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
@@ -11632,6 +11771,14 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_encoder *enc, const void
vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkPhysicalDeviceFeatures2_pnext(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(enc, (const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
@@ -12151,6 +12298,10 @@ vn_decode_VkPhysicalDeviceFeatures2_pnext(struct vn_cs_decoder *dec, const void
vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
vn_decode_VkPhysicalDeviceMaintenance4Features_self(dec, (VkPhysicalDeviceMaintenance4Features *)pnext);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
vn_decode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(dec, (VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
vn_decode_VkPhysicalDeviceFeatures2_pnext(dec, pnext->pNext);
vn_decode_VkPhysicalDeviceShaderDrawParametersFeatures_self(dec, (VkPhysicalDeviceShaderDrawParametersFeatures *)pnext);
@@ -12484,6 +12635,14 @@ vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(const void *val)
size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self_partial((const VkPhysicalDeviceMaintenance4Features *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkPhysicalDeviceFeatures2_pnext_partial(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial((const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
@@ -13024,6 +13183,14 @@ vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(struct vn_cs_encoder *enc, con
vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance4Features_self_partial(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkPhysicalDeviceFeatures2_pnext_partial(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self_partial(enc, (const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
@@ -13649,6 +13816,14 @@ vn_sizeof_VkDeviceCreateInfo_pnext(const void *val)
size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance4Features_self((const VkPhysicalDeviceMaintenance4Features *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkDeviceCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5FeaturesKHR_self((const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
@@ -14242,6 +14417,14 @@ vn_encode_VkDeviceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance4Features_self(enc, (const VkPhysicalDeviceMaintenance4Features *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkDeviceCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance5FeaturesKHR_self(enc, (const VkPhysicalDeviceMaintenance5FeaturesKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
@@ -16160,6 +16343,134 @@ vn_encode_VkPhysicalDeviceMaintenance4Properties_partial(struct vn_cs_encoder *e
vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, val);
}
/* struct VkPhysicalDeviceMaintenance5PropertiesKHR chain */
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkBool32(&val->earlyFragmentMultisampleCoverageAfterSampleCounting);
size += vn_sizeof_VkBool32(&val->earlyFragmentSampleMaskTestBeforeSampleCounting);
size += vn_sizeof_VkBool32(&val->depthStencilSwizzleOneSupport);
size += vn_sizeof_VkBool32(&val->polygonModePointSize);
size += vn_sizeof_VkBool32(&val->nonStrictSinglePixelWideLinesUseParallelogram);
size += vn_sizeof_VkBool32(&val->nonStrictWideLinesUseParallelogram);
return size;
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(val->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self(val);
return size;
}
static inline void
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_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_VkPhysicalDeviceMaintenance5PropertiesKHR_self(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkBool32(dec, &val->earlyFragmentMultisampleCoverageAfterSampleCounting);
vn_decode_VkBool32(dec, &val->earlyFragmentSampleMaskTestBeforeSampleCounting);
vn_decode_VkBool32(dec, &val->depthStencilSwizzleOneSupport);
vn_decode_VkBool32(dec, &val->polygonModePointSize);
vn_decode_VkBool32(dec, &val->nonStrictSinglePixelWideLinesUseParallelogram);
vn_decode_VkBool32(dec, &val->nonStrictWideLinesUseParallelogram);
}
static inline void
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR(struct vn_cs_decoder *dec, VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR);
assert(val->sType == stype);
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext(dec, val->pNext);
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_self(dec, val);
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
/* skip val->earlyFragmentMultisampleCoverageAfterSampleCounting */
/* skip val->earlyFragmentSampleMaskTestBeforeSampleCounting */
/* skip val->depthStencilSwizzleOneSupport */
/* skip val->polygonModePointSize */
/* skip val->nonStrictSinglePixelWideLinesUseParallelogram */
/* skip val->nonStrictWideLinesUseParallelogram */
return size;
}
static inline size_t
vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_partial(const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(val->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(val);
return size;
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
/* skip val->{sType,pNext} */
/* skip val->earlyFragmentMultisampleCoverageAfterSampleCounting */
/* skip val->earlyFragmentSampleMaskTestBeforeSampleCounting */
/* skip val->depthStencilSwizzleOneSupport */
/* skip val->polygonModePointSize */
/* skip val->nonStrictSinglePixelWideLinesUseParallelogram */
/* skip val->nonStrictWideLinesUseParallelogram */
}
static inline void
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_partial(struct vn_cs_encoder *enc, const VkPhysicalDeviceMaintenance5PropertiesKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR });
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_pnext_partial(enc, val->pNext);
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(enc, val);
}
/* struct VkPhysicalDeviceFloatControlsProperties chain */
static inline size_t
@@ -19434,6 +19745,14 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext(const void *val)
size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self((const VkPhysicalDeviceMaintenance4Properties *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkPhysicalDeviceProperties2_pnext(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self((const VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
@@ -19688,6 +20007,10 @@ vn_decode_VkPhysicalDeviceProperties2_pnext(struct vn_cs_decoder *dec, const voi
vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
vn_decode_VkPhysicalDeviceMaintenance4Properties_self(dec, (VkPhysicalDeviceMaintenance4Properties *)pnext);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
vn_decode_VkPhysicalDeviceMaintenance5PropertiesKHR_self(dec, (VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
break;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
vn_decode_VkPhysicalDeviceProperties2_pnext(dec, pnext->pNext);
vn_decode_VkPhysicalDeviceFloatControlsProperties_self(dec, (VkPhysicalDeviceFloatControlsProperties *)pnext);
@@ -19885,6 +20208,14 @@ vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(const void *val)
size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance4Properties_self_partial((const VkPhysicalDeviceMaintenance4Properties *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkPhysicalDeviceProperties2_pnext_partial(pnext->pNext);
size += vn_sizeof_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial((const VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
@@ -20159,6 +20490,14 @@ vn_encode_VkPhysicalDeviceProperties2_pnext_partial(struct vn_cs_encoder *enc, c
vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance4Properties_self_partial(enc, (const VkPhysicalDeviceMaintenance4Properties *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkPhysicalDeviceProperties2_pnext_partial(enc, pnext->pNext);
vn_encode_VkPhysicalDeviceMaintenance5PropertiesKHR_self_partial(enc, (const VkPhysicalDeviceMaintenance5PropertiesKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES:
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
@@ -22346,7 +22685,26 @@ vn_encode_VkSparseImageFormatProperties2_partial(struct vn_cs_encoder *enc, cons
static inline size_t
vn_sizeof_VkPhysicalDeviceExternalBufferInfo_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_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkPhysicalDeviceExternalBufferInfo_pnext(pnext->pNext);
size += vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_self((const VkBufferUsageFlags2CreateInfoKHR *)pnext);
return size;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
return vn_sizeof_simple_pointer(NULL);
}
@@ -22376,7 +22734,25 @@ vn_sizeof_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBuffe
static inline void
vn_encode_VkPhysicalDeviceExternalBufferInfo_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_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkPhysicalDeviceExternalBufferInfo_pnext(enc, pnext->pNext);
vn_encode_VkBufferUsageFlags2CreateInfoKHR_self(enc, (const VkBufferUsageFlags2CreateInfoKHR *)pnext);
return;
default:
/* ignore unknown/unsupported struct */
break;
}
pnext = pnext->pNext;
}
vn_encode_simple_pointer(enc, NULL);
}

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

@@ -1178,6 +1178,228 @@ vn_encode_VkImageDrmFormatModifierPropertiesEXT_partial(struct vn_cs_encoder *en
vn_encode_VkImageDrmFormatModifierPropertiesEXT_self_partial(enc, val);
}
/* struct VkImageSubresource2KHR chain */
static inline size_t
vn_sizeof_VkImageSubresource2KHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkImageSubresource2KHR_self(const VkImageSubresource2KHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkImageSubresource(&val->imageSubresource);
return size;
}
static inline size_t
vn_sizeof_VkImageSubresource2KHR(const VkImageSubresource2KHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkImageSubresource2KHR_pnext(val->pNext);
size += vn_sizeof_VkImageSubresource2KHR_self(val);
return size;
}
static inline void
vn_encode_VkImageSubresource2KHR_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkImageSubresource2KHR_self(struct vn_cs_encoder *enc, const VkImageSubresource2KHR *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkImageSubresource(enc, &val->imageSubresource);
}
static inline void
vn_encode_VkImageSubresource2KHR(struct vn_cs_encoder *enc, const VkImageSubresource2KHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR });
vn_encode_VkImageSubresource2KHR_pnext(enc, val->pNext);
vn_encode_VkImageSubresource2KHR_self(enc, val);
}
/* struct VkSubresourceLayout2KHR chain */
static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_self(const VkSubresourceLayout2KHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkSubresourceLayout(&val->subresourceLayout);
return size;
}
static inline size_t
vn_sizeof_VkSubresourceLayout2KHR(const VkSubresourceLayout2KHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkSubresourceLayout2KHR_pnext(val->pNext);
size += vn_sizeof_VkSubresourceLayout2KHR_self(val);
return size;
}
static inline void
vn_decode_VkSubresourceLayout2KHR_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_VkSubresourceLayout2KHR_self(struct vn_cs_decoder *dec, VkSubresourceLayout2KHR *val)
{
/* skip val->{sType,pNext} */
vn_decode_VkSubresourceLayout(dec, &val->subresourceLayout);
}
static inline void
vn_decode_VkSubresourceLayout2KHR(struct vn_cs_decoder *dec, VkSubresourceLayout2KHR *val)
{
VkStructureType stype;
vn_decode_VkStructureType(dec, &stype);
assert(stype == VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR);
assert(val->sType == stype);
vn_decode_VkSubresourceLayout2KHR_pnext(dec, val->pNext);
vn_decode_VkSubresourceLayout2KHR_self(dec, val);
}
static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_pnext_partial(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_self_partial(const VkSubresourceLayout2KHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkSubresourceLayout_partial(&val->subresourceLayout);
return size;
}
static inline size_t
vn_sizeof_VkSubresourceLayout2KHR_partial(const VkSubresourceLayout2KHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkSubresourceLayout2KHR_pnext_partial(val->pNext);
size += vn_sizeof_VkSubresourceLayout2KHR_self_partial(val);
return size;
}
static inline void
vn_encode_VkSubresourceLayout2KHR_pnext_partial(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkSubresourceLayout2KHR_self_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout2KHR *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkSubresourceLayout_partial(enc, &val->subresourceLayout);
}
static inline void
vn_encode_VkSubresourceLayout2KHR_partial(struct vn_cs_encoder *enc, const VkSubresourceLayout2KHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR });
vn_encode_VkSubresourceLayout2KHR_pnext_partial(enc, val->pNext);
vn_encode_VkSubresourceLayout2KHR_self_partial(enc, val);
}
/* struct VkDeviceImageSubresourceInfoKHR chain */
static inline size_t
vn_sizeof_VkDeviceImageSubresourceInfoKHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkDeviceImageSubresourceInfoKHR_self(const VkDeviceImageSubresourceInfoKHR *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_simple_pointer(val->pSubresource);
if (val->pSubresource)
size += vn_sizeof_VkImageSubresource2KHR(val->pSubresource);
return size;
}
static inline size_t
vn_sizeof_VkDeviceImageSubresourceInfoKHR(const VkDeviceImageSubresourceInfoKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkDeviceImageSubresourceInfoKHR_pnext(val->pNext);
size += vn_sizeof_VkDeviceImageSubresourceInfoKHR_self(val);
return size;
}
static inline void
vn_encode_VkDeviceImageSubresourceInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkDeviceImageSubresourceInfoKHR_self(struct vn_cs_encoder *enc, const VkDeviceImageSubresourceInfoKHR *val)
{
/* skip val->{sType,pNext} */
if (vn_encode_simple_pointer(enc, val->pCreateInfo))
vn_encode_VkImageCreateInfo(enc, val->pCreateInfo);
if (vn_encode_simple_pointer(enc, val->pSubresource))
vn_encode_VkImageSubresource2KHR(enc, val->pSubresource);
}
static inline void
vn_encode_VkDeviceImageSubresourceInfoKHR(struct vn_cs_encoder *enc, const VkDeviceImageSubresourceInfoKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR });
vn_encode_VkDeviceImageSubresourceInfoKHR_pnext(enc, val->pNext);
vn_encode_VkDeviceImageSubresourceInfoKHR_self(enc, val);
}
static inline size_t vn_sizeof_vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT;
@@ -1994,6 +2216,130 @@ static inline VkResult vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_reply(
return ret;
}
static inline size_t vn_sizeof_vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_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_VkImage(&image);
cmd_size += vn_sizeof_simple_pointer(pSubresource);
if (pSubresource)
cmd_size += vn_sizeof_VkImageSubresource2KHR(pSubresource);
cmd_size += vn_sizeof_simple_pointer(pLayout);
if (pLayout)
cmd_size += vn_sizeof_VkSubresourceLayout2KHR_partial(pLayout);
return cmd_size;
}
static inline void vn_encode_vkGetImageSubresourceLayout2KHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
vn_encode_VkImage(enc, &image);
if (vn_encode_simple_pointer(enc, pSubresource))
vn_encode_VkImageSubresource2KHR(enc, pSubresource);
if (vn_encode_simple_pointer(enc, pLayout))
vn_encode_VkSubresourceLayout2KHR_partial(enc, pLayout);
}
static inline size_t vn_sizeof_vkGetImageSubresourceLayout2KHR_reply(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip image */
/* skip pSubresource */
cmd_size += vn_sizeof_simple_pointer(pLayout);
if (pLayout)
cmd_size += vn_sizeof_VkSubresourceLayout2KHR(pLayout);
return cmd_size;
}
static inline void vn_decode_vkGetImageSubresourceLayout2KHR_reply(struct vn_cs_decoder *dec, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetImageSubresourceLayout2KHR_EXT);
/* skip device */
/* skip image */
/* skip pSubresource */
if (vn_decode_simple_pointer(dec)) {
vn_decode_VkSubresourceLayout2KHR(dec, pLayout);
} else {
pLayout = NULL;
}
}
static inline size_t vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_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_VkDeviceImageSubresourceInfoKHR(pInfo);
cmd_size += vn_sizeof_simple_pointer(pLayout);
if (pLayout)
cmd_size += vn_sizeof_VkSubresourceLayout2KHR_partial(pLayout);
return cmd_size;
}
static inline void vn_encode_vkGetDeviceImageSubresourceLayoutKHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_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_VkDeviceImageSubresourceInfoKHR(enc, pInfo);
if (vn_encode_simple_pointer(enc, pLayout))
vn_encode_VkSubresourceLayout2KHR_partial(enc, pLayout);
}
static inline size_t vn_sizeof_vkGetDeviceImageSubresourceLayoutKHR_reply(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip pInfo */
cmd_size += vn_sizeof_simple_pointer(pLayout);
if (pLayout)
cmd_size += vn_sizeof_VkSubresourceLayout2KHR(pLayout);
return cmd_size;
}
static inline void vn_decode_vkGetDeviceImageSubresourceLayoutKHR_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetDeviceImageSubresourceLayoutKHR_EXT);
/* skip device */
/* skip pInfo */
if (vn_decode_simple_pointer(dec)) {
vn_decode_VkSubresourceLayout2KHR(dec, pLayout);
} else {
pLayout = NULL;
}
}
static inline void vn_submit_vkGetImageMemoryRequirements(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements, struct vn_ring_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@@ -2246,6 +2592,48 @@ static inline void vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_
}
}
static inline void vn_submit_vkGetImageSubresourceLayout2KHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout, struct vn_ring_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_vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout);
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_vkGetImageSubresourceLayout2KHR_reply(device, image, pSubresource, pLayout) : 0;
struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetImageSubresourceLayout2KHR(enc, cmd_flags, device, image, pSubresource, pLayout);
vn_ring_submit_command(vn_ring, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout, struct vn_ring_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_vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout);
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_vkGetDeviceImageSubresourceLayoutKHR_reply(device, pInfo, pLayout) : 0;
struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetDeviceImageSubresourceLayoutKHR(enc, cmd_flags, device, pInfo, pLayout);
vn_ring_submit_command(vn_ring, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_call_vkGetImageMemoryRequirements(struct vn_ring *vn_ring, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
{
VN_TRACE_FUNC();
@@ -2486,4 +2874,42 @@ static inline void vn_async_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_r
vn_submit_vkGetImageDrmFormatModifierPropertiesEXT(vn_ring, 0, device, image, pProperties, &submit);
}
static inline void vn_call_vkGetImageSubresourceLayout2KHR(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
{
VN_TRACE_FUNC();
struct vn_ring_submit_command submit;
vn_submit_vkGetImageSubresourceLayout2KHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, image, pSubresource, pLayout, &submit);
struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
if (dec) {
vn_decode_vkGetImageSubresourceLayout2KHR_reply(dec, device, image, pSubresource, pLayout);
vn_ring_free_command_reply(vn_ring, &submit);
}
}
static inline void vn_async_vkGetImageSubresourceLayout2KHR(struct vn_ring *vn_ring, VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout)
{
struct vn_ring_submit_command submit;
vn_submit_vkGetImageSubresourceLayout2KHR(vn_ring, 0, device, image, pSubresource, pLayout, &submit);
}
static inline void vn_call_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
{
VN_TRACE_FUNC();
struct vn_ring_submit_command submit;
vn_submit_vkGetDeviceImageSubresourceLayoutKHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pInfo, pLayout, &submit);
struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
if (dec) {
vn_decode_vkGetDeviceImageSubresourceLayoutKHR_reply(dec, device, pInfo, pLayout);
vn_ring_free_command_reply(vn_ring, &submit);
}
}
static inline void vn_async_vkGetDeviceImageSubresourceLayoutKHR(struct vn_ring *vn_ring, VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout)
{
struct vn_ring_submit_command submit;
vn_submit_vkGetDeviceImageSubresourceLayoutKHR(vn_ring, 0, device, pInfo, pLayout, &submit);
}
#endif /* VN_PROTOCOL_DRIVER_IMAGE_H */

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

@@ -19,8 +19,8 @@ struct vn_info_extension {
};
/* sorted by extension names for bsearch */
static const uint32_t _vn_info_extension_count = 116;
static const struct vn_info_extension _vn_info_extensions[116] = {
static const uint32_t _vn_info_extension_count = 117;
static const struct vn_info_extension _vn_info_extensions[117] = {
{ "VK_EXT_4444_formats", 341, 1 },
{ "VK_EXT_attachment_feedback_loop_layout", 340, 2 },
{ "VK_EXT_border_color_swizzle", 412, 1 },
@@ -111,6 +111,7 @@ static const struct vn_info_extension _vn_info_extensions[116] = {
{ "VK_KHR_maintenance2", 118, 1 },
{ "VK_KHR_maintenance3", 169, 1 },
{ "VK_KHR_maintenance4", 414, 2 },
{ "VK_KHR_maintenance5", 471, 1 },
{ "VK_KHR_multiview", 54, 1 },
{ "VK_KHR_pipeline_library", 291, 1 },
{ "VK_KHR_push_descriptor", 81, 2 },

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

@@ -1778,6 +1778,59 @@ vn_encode_VkPipelineDynamicStateCreateInfo(struct vn_cs_encoder *enc, const VkPi
vn_encode_VkPipelineDynamicStateCreateInfo_self(enc, val);
}
/* struct VkPipelineCreateFlags2CreateInfoKHR chain */
static inline size_t
vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self(const VkPipelineCreateFlags2CreateInfoKHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkFlags64(&val->flags);
return size;
}
static inline size_t
vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR(const VkPipelineCreateFlags2CreateInfoKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_pnext(val->pNext);
size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self(val);
return size;
}
static inline void
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(struct vn_cs_encoder *enc, const VkPipelineCreateFlags2CreateInfoKHR *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkFlags64(enc, &val->flags);
}
static inline void
vn_encode_VkPipelineCreateFlags2CreateInfoKHR(struct vn_cs_encoder *enc, const VkPipelineCreateFlags2CreateInfoKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR });
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_pnext(enc, val->pNext);
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(enc, val);
}
/* struct VkPipelineLibraryCreateInfoKHR chain */
static inline size_t
@@ -2126,6 +2179,14 @@ vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(const void *val)
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkGraphicsPipelineCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self((const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(291 /* VK_KHR_pipeline_library */))
break;
@@ -2244,6 +2305,14 @@ vn_encode_VkGraphicsPipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const vo
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkGraphicsPipelineCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(enc, (const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(291 /* VK_KHR_pipeline_library */))
break;
@@ -2351,6 +2420,14 @@ vn_sizeof_VkComputePipelineCreateInfo_pnext(const void *val)
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
size += vn_sizeof_simple_pointer(pnext);
size += vn_sizeof_VkStructureType(&pnext->sType);
size += vn_sizeof_VkComputePipelineCreateInfo_pnext(pnext->pNext);
size += vn_sizeof_VkPipelineCreateFlags2CreateInfoKHR_self((const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
return size;
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
break;
@@ -2401,6 +2478,14 @@ vn_encode_VkComputePipelineCreateInfo_pnext(struct vn_cs_encoder *enc, const voi
while (pnext) {
switch ((int32_t)pnext->sType) {
case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR:
if (!vn_cs_renderer_protocol_has_extension(471 /* VK_KHR_maintenance5 */))
break;
vn_encode_simple_pointer(enc, pnext);
vn_encode_VkStructureType(enc, &pnext->sType);
vn_encode_VkComputePipelineCreateInfo_pnext(enc, pnext->pNext);
vn_encode_VkPipelineCreateFlags2CreateInfoKHR_self(enc, (const VkPipelineCreateFlags2CreateInfoKHR *)pnext);
return;
case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
if (!vn_cs_renderer_protocol_has_extension(193 /* VK_EXT_pipeline_creation_feedback */))
break;

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

@@ -498,6 +498,77 @@ vn_encode_VkRenderPassCreateInfo(struct vn_cs_encoder *enc, const VkRenderPassCr
vn_encode_VkRenderPassCreateInfo_self(enc, val);
}
/* struct VkRenderingAreaInfoKHR chain */
static inline size_t
vn_sizeof_VkRenderingAreaInfoKHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkRenderingAreaInfoKHR_self(const VkRenderingAreaInfoKHR *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_VkRenderingAreaInfoKHR(const VkRenderingAreaInfoKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkRenderingAreaInfoKHR_pnext(val->pNext);
size += vn_sizeof_VkRenderingAreaInfoKHR_self(val);
return size;
}
static inline void
vn_encode_VkRenderingAreaInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkRenderingAreaInfoKHR_self(struct vn_cs_encoder *enc, const VkRenderingAreaInfoKHR *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_VkRenderingAreaInfoKHR(struct vn_cs_encoder *enc, const VkRenderingAreaInfoKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR });
vn_encode_VkRenderingAreaInfoKHR_pnext(enc, val->pNext);
vn_encode_VkRenderingAreaInfoKHR_self(enc, val);
}
/* struct VkAttachmentDescriptionStencilLayout chain */
static inline size_t
@@ -1487,6 +1558,66 @@ static inline void vn_decode_vkGetRenderAreaGranularity_reply(struct vn_cs_decod
}
}
static inline size_t vn_sizeof_vkGetRenderingAreaGranularityKHR(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_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(pRenderingAreaInfo);
if (pRenderingAreaInfo)
cmd_size += vn_sizeof_VkRenderingAreaInfoKHR(pRenderingAreaInfo);
cmd_size += vn_sizeof_simple_pointer(pGranularity);
if (pGranularity)
cmd_size += vn_sizeof_VkExtent2D_partial(pGranularity);
return cmd_size;
}
static inline void vn_encode_vkGetRenderingAreaGranularityKHR(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT;
vn_encode_VkCommandTypeEXT(enc, &cmd_type);
vn_encode_VkFlags(enc, &cmd_flags);
vn_encode_VkDevice(enc, &device);
if (vn_encode_simple_pointer(enc, pRenderingAreaInfo))
vn_encode_VkRenderingAreaInfoKHR(enc, pRenderingAreaInfo);
if (vn_encode_simple_pointer(enc, pGranularity))
vn_encode_VkExtent2D_partial(enc, pGranularity);
}
static inline size_t vn_sizeof_vkGetRenderingAreaGranularityKHR_reply(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT;
size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
/* skip device */
/* skip pRenderingAreaInfo */
cmd_size += vn_sizeof_simple_pointer(pGranularity);
if (pGranularity)
cmd_size += vn_sizeof_VkExtent2D(pGranularity);
return cmd_size;
}
static inline void vn_decode_vkGetRenderingAreaGranularityKHR_reply(struct vn_cs_decoder *dec, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
VkCommandTypeEXT command_type;
vn_decode_VkCommandTypeEXT(dec, &command_type);
assert(command_type == VK_COMMAND_TYPE_vkGetRenderingAreaGranularityKHR_EXT);
/* skip device */
/* skip pRenderingAreaInfo */
if (vn_decode_simple_pointer(dec)) {
vn_decode_VkExtent2D(dec, pGranularity);
} else {
pGranularity = NULL;
}
}
static inline size_t vn_sizeof_vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRenderPass2_EXT;
@@ -1623,6 +1754,27 @@ static inline void vn_submit_vkGetRenderAreaGranularity(struct vn_ring *vn_ring,
}
}
static inline void vn_submit_vkGetRenderingAreaGranularityKHR(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity, struct vn_ring_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_vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity);
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_vkGetRenderingAreaGranularityKHR_reply(device, pRenderingAreaInfo, pGranularity) : 0;
struct vn_cs_encoder *enc = vn_ring_submit_command_init(vn_ring, submit, cmd_data, cmd_size, reply_size);
if (cmd_size) {
vn_encode_vkGetRenderingAreaGranularityKHR(enc, cmd_flags, device, pRenderingAreaInfo, pGranularity);
vn_ring_submit_command(vn_ring, submit);
if (cmd_data != local_cmd_data)
free(cmd_data);
}
}
static inline void vn_submit_vkCreateRenderPass2(struct vn_ring *vn_ring, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, struct vn_ring_submit_command *submit)
{
uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
@@ -1704,6 +1856,25 @@ static inline void vn_async_vkGetRenderAreaGranularity(struct vn_ring *vn_ring,
vn_submit_vkGetRenderAreaGranularity(vn_ring, 0, device, renderPass, pGranularity, &submit);
}
static inline void vn_call_vkGetRenderingAreaGranularityKHR(struct vn_ring *vn_ring, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
VN_TRACE_FUNC();
struct vn_ring_submit_command submit;
vn_submit_vkGetRenderingAreaGranularityKHR(vn_ring, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pRenderingAreaInfo, pGranularity, &submit);
struct vn_cs_decoder *dec = vn_ring_get_command_reply(vn_ring, &submit);
if (dec) {
vn_decode_vkGetRenderingAreaGranularityKHR_reply(dec, device, pRenderingAreaInfo, pGranularity);
vn_ring_free_command_reply(vn_ring, &submit);
}
}
static inline void vn_async_vkGetRenderingAreaGranularityKHR(struct vn_ring *vn_ring, VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity)
{
struct vn_ring_submit_command submit;
vn_submit_vkGetRenderingAreaGranularityKHR(vn_ring, 0, device, pRenderingAreaInfo, pGranularity, &submit);
}
static inline VkResult vn_call_vkCreateRenderPass2(struct vn_ring *vn_ring, VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
VN_TRACE_FUNC();

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

@@ -329,6 +329,59 @@ vn_encode_VkSemaphoreTypeCreateInfo(struct vn_cs_encoder *enc, const VkSemaphore
vn_encode_VkSemaphoreTypeCreateInfo_self(enc, val);
}
/* struct VkBufferUsageFlags2CreateInfoKHR chain */
static inline size_t
vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_pnext(const void *val)
{
/* no known/supported struct */
return vn_sizeof_simple_pointer(NULL);
}
static inline size_t
vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_self(const VkBufferUsageFlags2CreateInfoKHR *val)
{
size_t size = 0;
/* skip val->{sType,pNext} */
size += vn_sizeof_VkFlags64(&val->usage);
return size;
}
static inline size_t
vn_sizeof_VkBufferUsageFlags2CreateInfoKHR(const VkBufferUsageFlags2CreateInfoKHR *val)
{
size_t size = 0;
size += vn_sizeof_VkStructureType(&val->sType);
size += vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_pnext(val->pNext);
size += vn_sizeof_VkBufferUsageFlags2CreateInfoKHR_self(val);
return size;
}
static inline void
vn_encode_VkBufferUsageFlags2CreateInfoKHR_pnext(struct vn_cs_encoder *enc, const void *val)
{
/* no known/supported struct */
vn_encode_simple_pointer(enc, NULL);
}
static inline void
vn_encode_VkBufferUsageFlags2CreateInfoKHR_self(struct vn_cs_encoder *enc, const VkBufferUsageFlags2CreateInfoKHR *val)
{
/* skip val->{sType,pNext} */
vn_encode_VkFlags64(enc, &val->usage);
}
static inline void
vn_encode_VkBufferUsageFlags2CreateInfoKHR(struct vn_cs_encoder *enc, const VkBufferUsageFlags2CreateInfoKHR *val)
{
assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR);
vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR });
vn_encode_VkBufferUsageFlags2CreateInfoKHR_pnext(enc, val->pNext);
vn_encode_VkBufferUsageFlags2CreateInfoKHR_self(enc, val);
}
/* struct VkImageFormatListCreateInfo chain */
static inline size_t

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

@@ -1759,6 +1759,48 @@ vn_decode_VkRenderingFlagBits(struct vn_cs_decoder *dec, VkRenderingFlagBits *va
vn_decode_int32_t(dec, (int32_t *)val);
}
/* typedef VkFlags64 VkPipelineCreateFlagBits2KHR */
static inline size_t
vn_sizeof_VkPipelineCreateFlagBits2KHR(const VkPipelineCreateFlagBits2KHR *val)
{
assert(sizeof(*val) == sizeof(uint64_t));
return vn_sizeof_uint64_t((const uint64_t *)val);
}
static inline void
vn_encode_VkPipelineCreateFlagBits2KHR(struct vn_cs_encoder *enc, const VkPipelineCreateFlagBits2KHR *val)
{
vn_encode_uint64_t(enc, (const uint64_t *)val);
}
static inline void
vn_decode_VkPipelineCreateFlagBits2KHR(struct vn_cs_decoder *dec, VkPipelineCreateFlagBits2KHR *val)
{
vn_decode_uint64_t(dec, (uint64_t *)val);
}
/* typedef VkFlags64 VkBufferUsageFlagBits2KHR */
static inline size_t
vn_sizeof_VkBufferUsageFlagBits2KHR(const VkBufferUsageFlagBits2KHR *val)
{
assert(sizeof(*val) == sizeof(uint64_t));
return vn_sizeof_uint64_t((const uint64_t *)val);
}
static inline void
vn_encode_VkBufferUsageFlagBits2KHR(struct vn_cs_encoder *enc, const VkBufferUsageFlagBits2KHR *val)
{
vn_encode_uint64_t(enc, (const uint64_t *)val);
}
static inline void
vn_decode_VkBufferUsageFlagBits2KHR(struct vn_cs_decoder *dec, VkBufferUsageFlagBits2KHR *val)
{
vn_decode_uint64_t(dec, (uint64_t *)val);
}
/* enum VkPeerMemoryFeatureFlagBits */
static inline size_t