Home | History | Annotate | Line # | Download | only in venus-protocol 
      1 /* This file is generated by venus-protocol.  See vn_protocol_driver.h. */
      2 
      3 /*
      4  * Copyright 2020 Google LLC
      5  * SPDX-License-Identifier: MIT
      6  */
      7 
      8 #ifndef VN_PROTOCOL_DRIVER_SAMPLER_H
      9 #define VN_PROTOCOL_DRIVER_SAMPLER_H
     10 
     11 #include "vn_instance.h"
     12 #include "vn_protocol_driver_structs.h"
     13 
     14 /* struct VkSamplerReductionModeCreateInfo chain */
     15 
     16 static inline size_t
     17 vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(const void *val)
     18 {
     19     /* no known/supported struct */
     20     return vn_sizeof_simple_pointer(NULL);
     21 }
     22 
     23 static inline size_t
     24 vn_sizeof_VkSamplerReductionModeCreateInfo_self(const VkSamplerReductionModeCreateInfo *val)
     25 {
     26     size_t size = 0;
     27     /* skip val->{sType,pNext} */
     28     size += vn_sizeof_VkSamplerReductionMode(&val->reductionMode);
     29     return size;
     30 }
     31 
     32 static inline size_t
     33 vn_sizeof_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *val)
     34 {
     35     size_t size = 0;
     36 
     37     size += vn_sizeof_VkStructureType(&val->sType);
     38     size += vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(val->pNext);
     39     size += vn_sizeof_VkSamplerReductionModeCreateInfo_self(val);
     40 
     41     return size;
     42 }
     43 
     44 static inline void
     45 vn_encode_VkSamplerReductionModeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
     46 {
     47     /* no known/supported struct */
     48     vn_encode_simple_pointer(enc, NULL);
     49 }
     50 
     51 static inline void
     52 vn_encode_VkSamplerReductionModeCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
     53 {
     54     /* skip val->{sType,pNext} */
     55     vn_encode_VkSamplerReductionMode(enc, &val->reductionMode);
     56 }
     57 
     58 static inline void
     59 vn_encode_VkSamplerReductionModeCreateInfo(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
     60 {
     61     assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO);
     62     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO });
     63     vn_encode_VkSamplerReductionModeCreateInfo_pnext(enc, val->pNext);
     64     vn_encode_VkSamplerReductionModeCreateInfo_self(enc, val);
     65 }
     66 
     67 /* struct VkSamplerCreateInfo chain */
     68 
     69 static inline size_t
     70 vn_sizeof_VkSamplerCreateInfo_pnext(const void *val)
     71 {
     72     const VkBaseInStructure *pnext = val;
     73     size_t size = 0;
     74 
     75     while (pnext) {
     76         switch ((int32_t)pnext->sType) {
     77         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
     78             size += vn_sizeof_simple_pointer(pnext);
     79             size += vn_sizeof_VkStructureType(&pnext->sType);
     80             size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
     81             size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
     82             return size;
     83         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
     84             size += vn_sizeof_simple_pointer(pnext);
     85             size += vn_sizeof_VkStructureType(&pnext->sType);
     86             size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
     87             size += vn_sizeof_VkSamplerReductionModeCreateInfo_self((const VkSamplerReductionModeCreateInfo *)pnext);
     88             return size;
     89         default:
     90             /* ignore unknown/unsupported struct */
     91             break;
     92         }
     93         pnext = pnext->pNext;
     94     }
     95 
     96     return vn_sizeof_simple_pointer(NULL);
     97 }
     98 
     99 static inline size_t
    100 vn_sizeof_VkSamplerCreateInfo_self(const VkSamplerCreateInfo *val)
    101 {
    102     size_t size = 0;
    103     /* skip val->{sType,pNext} */
    104     size += vn_sizeof_VkFlags(&val->flags);
    105     size += vn_sizeof_VkFilter(&val->magFilter);
    106     size += vn_sizeof_VkFilter(&val->minFilter);
    107     size += vn_sizeof_VkSamplerMipmapMode(&val->mipmapMode);
    108     size += vn_sizeof_VkSamplerAddressMode(&val->addressModeU);
    109     size += vn_sizeof_VkSamplerAddressMode(&val->addressModeV);
    110     size += vn_sizeof_VkSamplerAddressMode(&val->addressModeW);
    111     size += vn_sizeof_float(&val->mipLodBias);
    112     size += vn_sizeof_VkBool32(&val->anisotropyEnable);
    113     size += vn_sizeof_float(&val->maxAnisotropy);
    114     size += vn_sizeof_VkBool32(&val->compareEnable);
    115     size += vn_sizeof_VkCompareOp(&val->compareOp);
    116     size += vn_sizeof_float(&val->minLod);
    117     size += vn_sizeof_float(&val->maxLod);
    118     size += vn_sizeof_VkBorderColor(&val->borderColor);
    119     size += vn_sizeof_VkBool32(&val->unnormalizedCoordinates);
    120     return size;
    121 }
    122 
    123 static inline size_t
    124 vn_sizeof_VkSamplerCreateInfo(const VkSamplerCreateInfo *val)
    125 {
    126     size_t size = 0;
    127 
    128     size += vn_sizeof_VkStructureType(&val->sType);
    129     size += vn_sizeof_VkSamplerCreateInfo_pnext(val->pNext);
    130     size += vn_sizeof_VkSamplerCreateInfo_self(val);
    131 
    132     return size;
    133 }
    134 
    135 static inline void
    136 vn_encode_VkSamplerCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
    137 {
    138     const VkBaseInStructure *pnext = val;
    139 
    140     while (pnext) {
    141         switch ((int32_t)pnext->sType) {
    142         case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
    143             vn_encode_simple_pointer(enc, pnext);
    144             vn_encode_VkStructureType(enc, &pnext->sType);
    145             vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
    146             vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
    147             return;
    148         case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
    149             vn_encode_simple_pointer(enc, pnext);
    150             vn_encode_VkStructureType(enc, &pnext->sType);
    151             vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
    152             vn_encode_VkSamplerReductionModeCreateInfo_self(enc, (const VkSamplerReductionModeCreateInfo *)pnext);
    153             return;
    154         default:
    155             /* ignore unknown/unsupported struct */
    156             break;
    157         }
    158         pnext = pnext->pNext;
    159     }
    160 
    161     vn_encode_simple_pointer(enc, NULL);
    162 }
    163 
    164 static inline void
    165 vn_encode_VkSamplerCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
    166 {
    167     /* skip val->{sType,pNext} */
    168     vn_encode_VkFlags(enc, &val->flags);
    169     vn_encode_VkFilter(enc, &val->magFilter);
    170     vn_encode_VkFilter(enc, &val->minFilter);
    171     vn_encode_VkSamplerMipmapMode(enc, &val->mipmapMode);
    172     vn_encode_VkSamplerAddressMode(enc, &val->addressModeU);
    173     vn_encode_VkSamplerAddressMode(enc, &val->addressModeV);
    174     vn_encode_VkSamplerAddressMode(enc, &val->addressModeW);
    175     vn_encode_float(enc, &val->mipLodBias);
    176     vn_encode_VkBool32(enc, &val->anisotropyEnable);
    177     vn_encode_float(enc, &val->maxAnisotropy);
    178     vn_encode_VkBool32(enc, &val->compareEnable);
    179     vn_encode_VkCompareOp(enc, &val->compareOp);
    180     vn_encode_float(enc, &val->minLod);
    181     vn_encode_float(enc, &val->maxLod);
    182     vn_encode_VkBorderColor(enc, &val->borderColor);
    183     vn_encode_VkBool32(enc, &val->unnormalizedCoordinates);
    184 }
    185 
    186 static inline void
    187 vn_encode_VkSamplerCreateInfo(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
    188 {
    189     assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
    190     vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO });
    191     vn_encode_VkSamplerCreateInfo_pnext(enc, val->pNext);
    192     vn_encode_VkSamplerCreateInfo_self(enc, val);
    193 }
    194 
    195 static inline size_t vn_sizeof_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
    196 {
    197     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
    198     const VkFlags cmd_flags = 0;
    199     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
    200 
    201     cmd_size += vn_sizeof_VkDevice(&device);
    202     cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
    203     if (pCreateInfo)
    204         cmd_size += vn_sizeof_VkSamplerCreateInfo(pCreateInfo);
    205     cmd_size += vn_sizeof_simple_pointer(pAllocator);
    206     if (pAllocator)
    207         assert(false);
    208     cmd_size += vn_sizeof_simple_pointer(pSampler);
    209     if (pSampler)
    210         cmd_size += vn_sizeof_VkSampler(pSampler);
    211 
    212     return cmd_size;
    213 }
    214 
    215 static inline void vn_encode_vkCreateSampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
    216 {
    217     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
    218 
    219     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
    220     vn_encode_VkFlags(enc, &cmd_flags);
    221 
    222     vn_encode_VkDevice(enc, &device);
    223     if (vn_encode_simple_pointer(enc, pCreateInfo))
    224         vn_encode_VkSamplerCreateInfo(enc, pCreateInfo);
    225     if (vn_encode_simple_pointer(enc, pAllocator))
    226         assert(false);
    227     if (vn_encode_simple_pointer(enc, pSampler))
    228         vn_encode_VkSampler(enc, pSampler);
    229 }
    230 
    231 static inline size_t vn_sizeof_vkCreateSampler_reply(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
    232 {
    233     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
    234     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
    235 
    236     VkResult ret;
    237     cmd_size += vn_sizeof_VkResult(&ret);
    238     /* skip device */
    239     /* skip pCreateInfo */
    240     /* skip pAllocator */
    241     cmd_size += vn_sizeof_simple_pointer(pSampler);
    242     if (pSampler)
    243         cmd_size += vn_sizeof_VkSampler(pSampler);
    244 
    245     return cmd_size;
    246 }
    247 
    248 static inline VkResult vn_decode_vkCreateSampler_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
    249 {
    250     VkCommandTypeEXT command_type;
    251     vn_decode_VkCommandTypeEXT(dec, &command_type);
    252     assert(command_type == VK_COMMAND_TYPE_vkCreateSampler_EXT);
    253 
    254     VkResult ret;
    255     vn_decode_VkResult(dec, &ret);
    256     /* skip device */
    257     /* skip pCreateInfo */
    258     /* skip pAllocator */
    259     if (vn_decode_simple_pointer(dec)) {
    260         vn_decode_VkSampler(dec, pSampler);
    261     } else {
    262         pSampler = NULL;
    263     }
    264 
    265     return ret;
    266 }
    267 
    268 static inline size_t vn_sizeof_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
    269 {
    270     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
    271     const VkFlags cmd_flags = 0;
    272     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
    273 
    274     cmd_size += vn_sizeof_VkDevice(&device);
    275     cmd_size += vn_sizeof_VkSampler(&sampler);
    276     cmd_size += vn_sizeof_simple_pointer(pAllocator);
    277     if (pAllocator)
    278         assert(false);
    279 
    280     return cmd_size;
    281 }
    282 
    283 static inline void vn_encode_vkDestroySampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
    284 {
    285     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
    286 
    287     vn_encode_VkCommandTypeEXT(enc, &cmd_type);
    288     vn_encode_VkFlags(enc, &cmd_flags);
    289 
    290     vn_encode_VkDevice(enc, &device);
    291     vn_encode_VkSampler(enc, &sampler);
    292     if (vn_encode_simple_pointer(enc, pAllocator))
    293         assert(false);
    294 }
    295 
    296 static inline size_t vn_sizeof_vkDestroySampler_reply(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
    297 {
    298     const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
    299     size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
    300 
    301     /* skip device */
    302     /* skip sampler */
    303     /* skip pAllocator */
    304 
    305     return cmd_size;
    306 }
    307 
    308 static inline void vn_decode_vkDestroySampler_reply(struct vn_cs_decoder *dec, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
    309 {
    310     VkCommandTypeEXT command_type;
    311     vn_decode_VkCommandTypeEXT(dec, &command_type);
    312     assert(command_type == VK_COMMAND_TYPE_vkDestroySampler_EXT);
    313 
    314     /* skip device */
    315     /* skip sampler */
    316     /* skip pAllocator */
    317 }
    318 
    319 static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, struct vn_instance_submit_command *submit)
    320 {
    321     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
    322     void *cmd_data = local_cmd_data;
    323     size_t cmd_size = vn_sizeof_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
    324     if (cmd_size > sizeof(local_cmd_data)) {
    325         cmd_data = malloc(cmd_size);
    326         if (!cmd_data)
    327             cmd_size = 0;
    328     }
    329     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;
    330 
    331     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
    332     if (cmd_size) {
    333         vn_encode_vkCreateSampler(enc, cmd_flags, device, pCreateInfo, pAllocator, pSampler);
    334         vn_instance_submit_command(vn_instance, submit);
    335         if (cmd_data != local_cmd_data)
    336             free(cmd_data);
    337     }
    338 }
    339 
    340 static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
    341 {
    342     uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
    343     void *cmd_data = local_cmd_data;
    344     size_t cmd_size = vn_sizeof_vkDestroySampler(device, sampler, pAllocator);
    345     if (cmd_size > sizeof(local_cmd_data)) {
    346         cmd_data = malloc(cmd_size);
    347         if (!cmd_data)
    348             cmd_size = 0;
    349     }
    350     const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;
    351 
    352     struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
    353     if (cmd_size) {
    354         vn_encode_vkDestroySampler(enc, cmd_flags, device, sampler, pAllocator);
    355         vn_instance_submit_command(vn_instance, submit);
    356         if (cmd_data != local_cmd_data)
    357             free(cmd_data);
    358     }
    359 }
    360 
    361 static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
    362 {
    363     VN_TRACE_FUNC();
    364 
    365     struct vn_instance_submit_command submit;
    366     vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit);
    367     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
    368     if (dec) {
    369         const VkResult ret = vn_decode_vkCreateSampler_reply(dec, device, pCreateInfo, pAllocator, pSampler);
    370         vn_instance_free_command_reply(vn_instance, &submit);
    371         return ret;
    372     } else {
    373         return VK_ERROR_OUT_OF_HOST_MEMORY;
    374     }
    375 }
    376 
    377 static inline void vn_async_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
    378 {
    379     struct vn_instance_submit_command submit;
    380     vn_submit_vkCreateSampler(vn_instance, 0, device, pCreateInfo, pAllocator, pSampler, &submit);
    381 }
    382 
    383 static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
    384 {
    385     VN_TRACE_FUNC();
    386 
    387     struct vn_instance_submit_command submit;
    388     vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit);
    389     struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
    390     if (dec) {
    391         vn_decode_vkDestroySampler_reply(dec, device, sampler, pAllocator);
    392         vn_instance_free_command_reply(vn_instance, &submit);
    393     }
    394 }
    395 
    396 static inline void vn_async_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
    397 {
    398     struct vn_instance_submit_command submit;
    399     vn_submit_vkDestroySampler(vn_instance, 0, device, sampler, pAllocator, &submit);
    400 }
    401 
    402 #endif /* VN_PROTOCOL_DRIVER_SAMPLER_H */
    403