1 /* This file is generated by venus-protocol. See vn_protocol_renderer.h. */
2
3 /*
4 * Copyright 2020 Google LLC
5 * SPDX-License-Identifier: MIT
6 */
7
8 #ifndef VN_PROTOCOL_RENDERER_IMAGE_H
9 #define VN_PROTOCOL_RENDERER_IMAGE_H
10
11 #include "vn_protocol_renderer_structs.h"
12
13 #pragma GCC diagnostic push
14 #pragma GCC diagnostic ignored "-Wpointer-arith"
15 #pragma GCC diagnostic ignored "-Wunused-parameter"
16
17 /* struct VkSparseImageMemoryRequirements */
18
19 static inline void
vn_encode_VkSparseImageMemoryRequirements(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements * val)20 vn_encode_VkSparseImageMemoryRequirements(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements *val)
21 {
22 vn_encode_VkSparseImageFormatProperties(enc, &val->formatProperties);
23 vn_encode_uint32_t(enc, &val->imageMipTailFirstLod);
24 vn_encode_VkDeviceSize(enc, &val->imageMipTailSize);
25 vn_encode_VkDeviceSize(enc, &val->imageMipTailOffset);
26 vn_encode_VkDeviceSize(enc, &val->imageMipTailStride);
27 }
28
29 static inline void
vn_decode_VkSparseImageMemoryRequirements_partial_temp(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements * val)30 vn_decode_VkSparseImageMemoryRequirements_partial_temp(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements *val)
31 {
32 vn_decode_VkSparseImageFormatProperties_partial_temp(dec, &val->formatProperties);
33 /* skip val->imageMipTailFirstLod */
34 /* skip val->imageMipTailSize */
35 /* skip val->imageMipTailOffset */
36 /* skip val->imageMipTailStride */
37 }
38
39 /* struct VkExternalMemoryImageCreateInfo chain */
40
41 static inline void *
vn_decode_VkExternalMemoryImageCreateInfo_pnext_temp(struct vn_cs_decoder * dec)42 vn_decode_VkExternalMemoryImageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
43 {
44 /* no known/supported struct */
45 if (vn_decode_simple_pointer(dec))
46 vn_cs_decoder_set_fatal(dec);
47 return NULL;
48 }
49
50 static inline void
vn_decode_VkExternalMemoryImageCreateInfo_self_temp(struct vn_cs_decoder * dec,VkExternalMemoryImageCreateInfo * val)51 vn_decode_VkExternalMemoryImageCreateInfo_self_temp(struct vn_cs_decoder *dec, VkExternalMemoryImageCreateInfo *val)
52 {
53 /* skip val->{sType,pNext} */
54 vn_decode_VkFlags(dec, &val->handleTypes);
55 }
56
57 static inline void
vn_decode_VkExternalMemoryImageCreateInfo_temp(struct vn_cs_decoder * dec,VkExternalMemoryImageCreateInfo * val)58 vn_decode_VkExternalMemoryImageCreateInfo_temp(struct vn_cs_decoder *dec, VkExternalMemoryImageCreateInfo *val)
59 {
60 VkStructureType stype;
61 vn_decode_VkStructureType(dec, &stype);
62 if (stype != VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO)
63 vn_cs_decoder_set_fatal(dec);
64
65 val->sType = stype;
66 val->pNext = vn_decode_VkExternalMemoryImageCreateInfo_pnext_temp(dec);
67 vn_decode_VkExternalMemoryImageCreateInfo_self_temp(dec, val);
68 }
69
70 static inline void
vn_replace_VkExternalMemoryImageCreateInfo_handle_self(VkExternalMemoryImageCreateInfo * val)71 vn_replace_VkExternalMemoryImageCreateInfo_handle_self(VkExternalMemoryImageCreateInfo *val)
72 {
73 /* skip val->sType */
74 /* skip val->pNext */
75 /* skip val->handleTypes */
76 }
77
78 static inline void
vn_replace_VkExternalMemoryImageCreateInfo_handle(VkExternalMemoryImageCreateInfo * val)79 vn_replace_VkExternalMemoryImageCreateInfo_handle(VkExternalMemoryImageCreateInfo *val)
80 {
81 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
82
83 do {
84 switch ((int32_t)pnext->sType) {
85 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
86 vn_replace_VkExternalMemoryImageCreateInfo_handle_self((VkExternalMemoryImageCreateInfo *)pnext);
87 break;
88 default:
89 /* ignore unknown/unsupported struct */
90 break;
91 }
92 pnext = pnext->pNext;
93 } while (pnext);
94 }
95
96 /* struct VkImageDrmFormatModifierListCreateInfoEXT chain */
97
98 static inline void *
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)99 vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
100 {
101 /* no known/supported struct */
102 if (vn_decode_simple_pointer(dec))
103 vn_cs_decoder_set_fatal(dec);
104 return NULL;
105 }
106
107 static inline void
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierListCreateInfoEXT * val)108 vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierListCreateInfoEXT *val)
109 {
110 /* skip val->{sType,pNext} */
111 vn_decode_uint32_t(dec, &val->drmFormatModifierCount);
112 if (vn_peek_array_size(dec)) {
113 const size_t array_size = vn_decode_array_size(dec, val->drmFormatModifierCount);
114 val->pDrmFormatModifiers = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDrmFormatModifiers) * array_size);
115 if (!val->pDrmFormatModifiers) return;
116 vn_decode_uint64_t_array(dec, (uint64_t *)val->pDrmFormatModifiers, array_size);
117 } else {
118 vn_decode_array_size(dec, val->drmFormatModifierCount);
119 val->pDrmFormatModifiers = NULL;
120 }
121 }
122
123 static inline void
vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierListCreateInfoEXT * val)124 vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierListCreateInfoEXT *val)
125 {
126 VkStructureType stype;
127 vn_decode_VkStructureType(dec, &stype);
128 if (stype != VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT)
129 vn_cs_decoder_set_fatal(dec);
130
131 val->sType = stype;
132 val->pNext = vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext_temp(dec);
133 vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self_temp(dec, val);
134 }
135
136 static inline void
vn_replace_VkImageDrmFormatModifierListCreateInfoEXT_handle_self(VkImageDrmFormatModifierListCreateInfoEXT * val)137 vn_replace_VkImageDrmFormatModifierListCreateInfoEXT_handle_self(VkImageDrmFormatModifierListCreateInfoEXT *val)
138 {
139 /* skip val->sType */
140 /* skip val->pNext */
141 /* skip val->drmFormatModifierCount */
142 /* skip val->pDrmFormatModifiers */
143 }
144
145 static inline void
vn_replace_VkImageDrmFormatModifierListCreateInfoEXT_handle(VkImageDrmFormatModifierListCreateInfoEXT * val)146 vn_replace_VkImageDrmFormatModifierListCreateInfoEXT_handle(VkImageDrmFormatModifierListCreateInfoEXT *val)
147 {
148 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
149
150 do {
151 switch ((int32_t)pnext->sType) {
152 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
153 vn_replace_VkImageDrmFormatModifierListCreateInfoEXT_handle_self((VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
154 break;
155 default:
156 /* ignore unknown/unsupported struct */
157 break;
158 }
159 pnext = pnext->pNext;
160 } while (pnext);
161 }
162
163 /* struct VkSubresourceLayout */
164
165 static inline void
vn_encode_VkSubresourceLayout(struct vn_cs_encoder * enc,const VkSubresourceLayout * val)166 vn_encode_VkSubresourceLayout(struct vn_cs_encoder *enc, const VkSubresourceLayout *val)
167 {
168 vn_encode_VkDeviceSize(enc, &val->offset);
169 vn_encode_VkDeviceSize(enc, &val->size);
170 vn_encode_VkDeviceSize(enc, &val->rowPitch);
171 vn_encode_VkDeviceSize(enc, &val->arrayPitch);
172 vn_encode_VkDeviceSize(enc, &val->depthPitch);
173 }
174
175 static inline void
vn_decode_VkSubresourceLayout_temp(struct vn_cs_decoder * dec,VkSubresourceLayout * val)176 vn_decode_VkSubresourceLayout_temp(struct vn_cs_decoder *dec, VkSubresourceLayout *val)
177 {
178 vn_decode_VkDeviceSize(dec, &val->offset);
179 vn_decode_VkDeviceSize(dec, &val->size);
180 vn_decode_VkDeviceSize(dec, &val->rowPitch);
181 vn_decode_VkDeviceSize(dec, &val->arrayPitch);
182 vn_decode_VkDeviceSize(dec, &val->depthPitch);
183 }
184
185 static inline void
vn_decode_VkSubresourceLayout_partial_temp(struct vn_cs_decoder * dec,VkSubresourceLayout * val)186 vn_decode_VkSubresourceLayout_partial_temp(struct vn_cs_decoder *dec, VkSubresourceLayout *val)
187 {
188 /* skip val->offset */
189 /* skip val->size */
190 /* skip val->rowPitch */
191 /* skip val->arrayPitch */
192 /* skip val->depthPitch */
193 }
194
195 static inline void
vn_replace_VkSubresourceLayout_handle(VkSubresourceLayout * val)196 vn_replace_VkSubresourceLayout_handle(VkSubresourceLayout *val)
197 {
198 /* skip val->offset */
199 /* skip val->size */
200 /* skip val->rowPitch */
201 /* skip val->arrayPitch */
202 /* skip val->depthPitch */
203 }
204
205 /* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */
206
207 static inline void *
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext_temp(struct vn_cs_decoder * dec)208 vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
209 {
210 /* no known/supported struct */
211 if (vn_decode_simple_pointer(dec))
212 vn_cs_decoder_set_fatal(dec);
213 return NULL;
214 }
215
216 static inline void
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierExplicitCreateInfoEXT * val)217 vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
218 {
219 /* skip val->{sType,pNext} */
220 vn_decode_uint64_t(dec, &val->drmFormatModifier);
221 vn_decode_uint32_t(dec, &val->drmFormatModifierPlaneCount);
222 if (vn_peek_array_size(dec)) {
223 const uint32_t iter_count = vn_decode_array_size(dec, val->drmFormatModifierPlaneCount);
224 val->pPlaneLayouts = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pPlaneLayouts) * iter_count);
225 if (!val->pPlaneLayouts) return;
226 for (uint32_t i = 0; i < iter_count; i++)
227 vn_decode_VkSubresourceLayout_temp(dec, &((VkSubresourceLayout *)val->pPlaneLayouts)[i]);
228 } else {
229 vn_decode_array_size(dec, val->drmFormatModifierPlaneCount);
230 val->pPlaneLayouts = NULL;
231 }
232 }
233
234 static inline void
vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierExplicitCreateInfoEXT * val)235 vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
236 {
237 VkStructureType stype;
238 vn_decode_VkStructureType(dec, &stype);
239 if (stype != VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT)
240 vn_cs_decoder_set_fatal(dec);
241
242 val->sType = stype;
243 val->pNext = vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext_temp(dec);
244 vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self_temp(dec, val);
245 }
246
247 static inline void
vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle_self(VkImageDrmFormatModifierExplicitCreateInfoEXT * val)248 vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle_self(VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
249 {
250 /* skip val->sType */
251 /* skip val->pNext */
252 /* skip val->drmFormatModifier */
253 /* skip val->drmFormatModifierPlaneCount */
254 if (val->pPlaneLayouts) {
255 for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
256 vn_replace_VkSubresourceLayout_handle(&((VkSubresourceLayout *)val->pPlaneLayouts)[i]);
257 }
258 }
259
260 static inline void
vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle(VkImageDrmFormatModifierExplicitCreateInfoEXT * val)261 vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle(VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
262 {
263 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
264
265 do {
266 switch ((int32_t)pnext->sType) {
267 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
268 vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle_self((VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
269 break;
270 default:
271 /* ignore unknown/unsupported struct */
272 break;
273 }
274 pnext = pnext->pNext;
275 } while (pnext);
276 }
277
278 /* struct VkImageCreateInfo chain */
279
280 static inline void *
vn_decode_VkImageCreateInfo_pnext_temp(struct vn_cs_decoder * dec)281 vn_decode_VkImageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
282 {
283 VkBaseOutStructure *pnext;
284 VkStructureType stype;
285
286 if (!vn_decode_simple_pointer(dec))
287 return NULL;
288
289 vn_decode_VkStructureType(dec, &stype);
290 switch ((int32_t)stype) {
291 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
292 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkExternalMemoryImageCreateInfo));
293 if (pnext) {
294 pnext->sType = stype;
295 pnext->pNext = vn_decode_VkImageCreateInfo_pnext_temp(dec);
296 vn_decode_VkExternalMemoryImageCreateInfo_self_temp(dec, (VkExternalMemoryImageCreateInfo *)pnext);
297 }
298 break;
299 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
300 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImageFormatListCreateInfo));
301 if (pnext) {
302 pnext->sType = stype;
303 pnext->pNext = vn_decode_VkImageCreateInfo_pnext_temp(dec);
304 vn_decode_VkImageFormatListCreateInfo_self_temp(dec, (VkImageFormatListCreateInfo *)pnext);
305 }
306 break;
307 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
308 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImageDrmFormatModifierListCreateInfoEXT));
309 if (pnext) {
310 pnext->sType = stype;
311 pnext->pNext = vn_decode_VkImageCreateInfo_pnext_temp(dec);
312 vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_self_temp(dec, (VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
313 }
314 break;
315 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
316 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT));
317 if (pnext) {
318 pnext->sType = stype;
319 pnext->pNext = vn_decode_VkImageCreateInfo_pnext_temp(dec);
320 vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self_temp(dec, (VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
321 }
322 break;
323 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
324 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImageStencilUsageCreateInfo));
325 if (pnext) {
326 pnext->sType = stype;
327 pnext->pNext = vn_decode_VkImageCreateInfo_pnext_temp(dec);
328 vn_decode_VkImageStencilUsageCreateInfo_self_temp(dec, (VkImageStencilUsageCreateInfo *)pnext);
329 }
330 break;
331 default:
332 /* unexpected struct */
333 pnext = NULL;
334 vn_cs_decoder_set_fatal(dec);
335 break;
336 }
337
338 return pnext;
339 }
340
341 static inline void
vn_decode_VkImageCreateInfo_self_temp(struct vn_cs_decoder * dec,VkImageCreateInfo * val)342 vn_decode_VkImageCreateInfo_self_temp(struct vn_cs_decoder *dec, VkImageCreateInfo *val)
343 {
344 /* skip val->{sType,pNext} */
345 vn_decode_VkFlags(dec, &val->flags);
346 vn_decode_VkImageType(dec, &val->imageType);
347 vn_decode_VkFormat(dec, &val->format);
348 vn_decode_VkExtent3D_temp(dec, &val->extent);
349 vn_decode_uint32_t(dec, &val->mipLevels);
350 vn_decode_uint32_t(dec, &val->arrayLayers);
351 vn_decode_VkSampleCountFlagBits(dec, &val->samples);
352 vn_decode_VkImageTiling(dec, &val->tiling);
353 vn_decode_VkFlags(dec, &val->usage);
354 vn_decode_VkSharingMode(dec, &val->sharingMode);
355 vn_decode_uint32_t(dec, &val->queueFamilyIndexCount);
356 if (vn_peek_array_size(dec)) {
357 const size_t array_size = vn_decode_array_size(dec, val->queueFamilyIndexCount);
358 val->pQueueFamilyIndices = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pQueueFamilyIndices) * array_size);
359 if (!val->pQueueFamilyIndices) return;
360 vn_decode_uint32_t_array(dec, (uint32_t *)val->pQueueFamilyIndices, array_size);
361 } else {
362 vn_decode_array_size_unchecked(dec);
363 val->pQueueFamilyIndices = NULL;
364 }
365 vn_decode_VkImageLayout(dec, &val->initialLayout);
366 }
367
368 static inline void
vn_decode_VkImageCreateInfo_temp(struct vn_cs_decoder * dec,VkImageCreateInfo * val)369 vn_decode_VkImageCreateInfo_temp(struct vn_cs_decoder *dec, VkImageCreateInfo *val)
370 {
371 VkStructureType stype;
372 vn_decode_VkStructureType(dec, &stype);
373 if (stype != VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
374 vn_cs_decoder_set_fatal(dec);
375
376 val->sType = stype;
377 val->pNext = vn_decode_VkImageCreateInfo_pnext_temp(dec);
378 vn_decode_VkImageCreateInfo_self_temp(dec, val);
379 }
380
381 static inline void
vn_replace_VkImageCreateInfo_handle_self(VkImageCreateInfo * val)382 vn_replace_VkImageCreateInfo_handle_self(VkImageCreateInfo *val)
383 {
384 /* skip val->sType */
385 /* skip val->pNext */
386 /* skip val->flags */
387 /* skip val->imageType */
388 /* skip val->format */
389 vn_replace_VkExtent3D_handle(&val->extent);
390 /* skip val->mipLevels */
391 /* skip val->arrayLayers */
392 /* skip val->samples */
393 /* skip val->tiling */
394 /* skip val->usage */
395 /* skip val->sharingMode */
396 /* skip val->queueFamilyIndexCount */
397 /* skip val->pQueueFamilyIndices */
398 /* skip val->initialLayout */
399 }
400
401 static inline void
vn_replace_VkImageCreateInfo_handle(VkImageCreateInfo * val)402 vn_replace_VkImageCreateInfo_handle(VkImageCreateInfo *val)
403 {
404 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
405
406 do {
407 switch ((int32_t)pnext->sType) {
408 case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:
409 vn_replace_VkImageCreateInfo_handle_self((VkImageCreateInfo *)pnext);
410 break;
411 case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
412 vn_replace_VkExternalMemoryImageCreateInfo_handle_self((VkExternalMemoryImageCreateInfo *)pnext);
413 break;
414 case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
415 vn_replace_VkImageFormatListCreateInfo_handle_self((VkImageFormatListCreateInfo *)pnext);
416 break;
417 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
418 vn_replace_VkImageDrmFormatModifierListCreateInfoEXT_handle_self((VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
419 break;
420 case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
421 vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle_self((VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
422 break;
423 case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
424 vn_replace_VkImageStencilUsageCreateInfo_handle_self((VkImageStencilUsageCreateInfo *)pnext);
425 break;
426 default:
427 /* ignore unknown/unsupported struct */
428 break;
429 }
430 pnext = pnext->pNext;
431 } while (pnext);
432 }
433
434 /* struct VkBindImageMemoryDeviceGroupInfo chain */
435
436 static inline void
vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder * enc,const void * val)437 vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(struct vn_cs_encoder *enc, const void *val)
438 {
439 /* no known/supported struct */
440 vn_encode_simple_pointer(enc, NULL);
441 }
442
443 static inline void
vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder * enc,const VkBindImageMemoryDeviceGroupInfo * val)444 vn_encode_VkBindImageMemoryDeviceGroupInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
445 {
446 /* skip val->{sType,pNext} */
447 vn_encode_uint32_t(enc, &val->deviceIndexCount);
448 if (val->pDeviceIndices) {
449 vn_encode_array_size(enc, val->deviceIndexCount);
450 vn_encode_uint32_t_array(enc, val->pDeviceIndices, val->deviceIndexCount);
451 } else {
452 vn_encode_array_size(enc, 0);
453 }
454 vn_encode_uint32_t(enc, &val->splitInstanceBindRegionCount);
455 if (val->pSplitInstanceBindRegions) {
456 vn_encode_array_size(enc, val->splitInstanceBindRegionCount);
457 for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
458 vn_encode_VkRect2D(enc, &val->pSplitInstanceBindRegions[i]);
459 } else {
460 vn_encode_array_size(enc, 0);
461 }
462 }
463
464 static inline void
vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder * enc,const VkBindImageMemoryDeviceGroupInfo * val)465 vn_encode_VkBindImageMemoryDeviceGroupInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryDeviceGroupInfo *val)
466 {
467 assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO);
468 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO });
469 vn_encode_VkBindImageMemoryDeviceGroupInfo_pnext(enc, val->pNext);
470 vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, val);
471 }
472
473 static inline void *
vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext_temp(struct vn_cs_decoder * dec)474 vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext_temp(struct vn_cs_decoder *dec)
475 {
476 /* no known/supported struct */
477 if (vn_decode_simple_pointer(dec))
478 vn_cs_decoder_set_fatal(dec);
479 return NULL;
480 }
481
482 static inline void
vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(struct vn_cs_decoder * dec,VkBindImageMemoryDeviceGroupInfo * val)483 vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
484 {
485 /* skip val->{sType,pNext} */
486 vn_decode_uint32_t(dec, &val->deviceIndexCount);
487 if (vn_peek_array_size(dec)) {
488 const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount);
489 val->pDeviceIndices = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDeviceIndices) * array_size);
490 if (!val->pDeviceIndices) return;
491 vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size);
492 } else {
493 vn_decode_array_size(dec, val->deviceIndexCount);
494 val->pDeviceIndices = NULL;
495 }
496 vn_decode_uint32_t(dec, &val->splitInstanceBindRegionCount);
497 if (vn_peek_array_size(dec)) {
498 const uint32_t iter_count = vn_decode_array_size(dec, val->splitInstanceBindRegionCount);
499 val->pSplitInstanceBindRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSplitInstanceBindRegions) * iter_count);
500 if (!val->pSplitInstanceBindRegions) return;
501 for (uint32_t i = 0; i < iter_count; i++)
502 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)val->pSplitInstanceBindRegions)[i]);
503 } else {
504 vn_decode_array_size(dec, val->splitInstanceBindRegionCount);
505 val->pSplitInstanceBindRegions = NULL;
506 }
507 }
508
509 static inline void
vn_decode_VkBindImageMemoryDeviceGroupInfo_temp(struct vn_cs_decoder * dec,VkBindImageMemoryDeviceGroupInfo * val)510 vn_decode_VkBindImageMemoryDeviceGroupInfo_temp(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
511 {
512 VkStructureType stype;
513 vn_decode_VkStructureType(dec, &stype);
514 if (stype != VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO)
515 vn_cs_decoder_set_fatal(dec);
516
517 val->sType = stype;
518 val->pNext = vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext_temp(dec);
519 vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(dec, val);
520 }
521
522 static inline void
vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self(VkBindImageMemoryDeviceGroupInfo * val)523 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self(VkBindImageMemoryDeviceGroupInfo *val)
524 {
525 /* skip val->sType */
526 /* skip val->pNext */
527 /* skip val->deviceIndexCount */
528 /* skip val->pDeviceIndices */
529 /* skip val->splitInstanceBindRegionCount */
530 if (val->pSplitInstanceBindRegions) {
531 for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
532 vn_replace_VkRect2D_handle(&((VkRect2D *)val->pSplitInstanceBindRegions)[i]);
533 }
534 }
535
536 static inline void
vn_replace_VkBindImageMemoryDeviceGroupInfo_handle(VkBindImageMemoryDeviceGroupInfo * val)537 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle(VkBindImageMemoryDeviceGroupInfo *val)
538 {
539 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
540
541 do {
542 switch ((int32_t)pnext->sType) {
543 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
544 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self((VkBindImageMemoryDeviceGroupInfo *)pnext);
545 break;
546 default:
547 /* ignore unknown/unsupported struct */
548 break;
549 }
550 pnext = pnext->pNext;
551 } while (pnext);
552 }
553
554 /* struct VkBindImagePlaneMemoryInfo chain */
555
556 static inline void
vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder * enc,const void * val)557 vn_encode_VkBindImagePlaneMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
558 {
559 /* no known/supported struct */
560 vn_encode_simple_pointer(enc, NULL);
561 }
562
563 static inline void
vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder * enc,const VkBindImagePlaneMemoryInfo * val)564 vn_encode_VkBindImagePlaneMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
565 {
566 /* skip val->{sType,pNext} */
567 vn_encode_VkImageAspectFlagBits(enc, &val->planeAspect);
568 }
569
570 static inline void
vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder * enc,const VkBindImagePlaneMemoryInfo * val)571 vn_encode_VkBindImagePlaneMemoryInfo(struct vn_cs_encoder *enc, const VkBindImagePlaneMemoryInfo *val)
572 {
573 assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO);
574 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO });
575 vn_encode_VkBindImagePlaneMemoryInfo_pnext(enc, val->pNext);
576 vn_encode_VkBindImagePlaneMemoryInfo_self(enc, val);
577 }
578
579 static inline void *
vn_decode_VkBindImagePlaneMemoryInfo_pnext_temp(struct vn_cs_decoder * dec)580 vn_decode_VkBindImagePlaneMemoryInfo_pnext_temp(struct vn_cs_decoder *dec)
581 {
582 /* no known/supported struct */
583 if (vn_decode_simple_pointer(dec))
584 vn_cs_decoder_set_fatal(dec);
585 return NULL;
586 }
587
588 static inline void
vn_decode_VkBindImagePlaneMemoryInfo_self_temp(struct vn_cs_decoder * dec,VkBindImagePlaneMemoryInfo * val)589 vn_decode_VkBindImagePlaneMemoryInfo_self_temp(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
590 {
591 /* skip val->{sType,pNext} */
592 vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
593 }
594
595 static inline void
vn_decode_VkBindImagePlaneMemoryInfo_temp(struct vn_cs_decoder * dec,VkBindImagePlaneMemoryInfo * val)596 vn_decode_VkBindImagePlaneMemoryInfo_temp(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
597 {
598 VkStructureType stype;
599 vn_decode_VkStructureType(dec, &stype);
600 if (stype != VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO)
601 vn_cs_decoder_set_fatal(dec);
602
603 val->sType = stype;
604 val->pNext = vn_decode_VkBindImagePlaneMemoryInfo_pnext_temp(dec);
605 vn_decode_VkBindImagePlaneMemoryInfo_self_temp(dec, val);
606 }
607
608 static inline void
vn_replace_VkBindImagePlaneMemoryInfo_handle_self(VkBindImagePlaneMemoryInfo * val)609 vn_replace_VkBindImagePlaneMemoryInfo_handle_self(VkBindImagePlaneMemoryInfo *val)
610 {
611 /* skip val->sType */
612 /* skip val->pNext */
613 /* skip val->planeAspect */
614 }
615
616 static inline void
vn_replace_VkBindImagePlaneMemoryInfo_handle(VkBindImagePlaneMemoryInfo * val)617 vn_replace_VkBindImagePlaneMemoryInfo_handle(VkBindImagePlaneMemoryInfo *val)
618 {
619 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
620
621 do {
622 switch ((int32_t)pnext->sType) {
623 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
624 vn_replace_VkBindImagePlaneMemoryInfo_handle_self((VkBindImagePlaneMemoryInfo *)pnext);
625 break;
626 default:
627 /* ignore unknown/unsupported struct */
628 break;
629 }
630 pnext = pnext->pNext;
631 } while (pnext);
632 }
633
634 /* struct VkBindImageMemoryInfo chain */
635
636 static inline void
vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder * enc,const void * val)637 vn_encode_VkBindImageMemoryInfo_pnext(struct vn_cs_encoder *enc, const void *val)
638 {
639 const VkBaseInStructure *pnext = val;
640
641 while (pnext) {
642 switch ((int32_t)pnext->sType) {
643 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
644 vn_encode_simple_pointer(enc, pnext);
645 vn_encode_VkStructureType(enc, &pnext->sType);
646 vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
647 vn_encode_VkBindImageMemoryDeviceGroupInfo_self(enc, (const VkBindImageMemoryDeviceGroupInfo *)pnext);
648 return;
649 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
650 vn_encode_simple_pointer(enc, pnext);
651 vn_encode_VkStructureType(enc, &pnext->sType);
652 vn_encode_VkBindImageMemoryInfo_pnext(enc, pnext->pNext);
653 vn_encode_VkBindImagePlaneMemoryInfo_self(enc, (const VkBindImagePlaneMemoryInfo *)pnext);
654 return;
655 default:
656 /* ignore unknown/unsupported struct */
657 break;
658 }
659 pnext = pnext->pNext;
660 }
661
662 vn_encode_simple_pointer(enc, NULL);
663 }
664
665 static inline void
vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder * enc,const VkBindImageMemoryInfo * val)666 vn_encode_VkBindImageMemoryInfo_self(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
667 {
668 /* skip val->{sType,pNext} */
669 vn_encode_VkImage(enc, &val->image);
670 vn_encode_VkDeviceMemory(enc, &val->memory);
671 vn_encode_VkDeviceSize(enc, &val->memoryOffset);
672 }
673
674 static inline void
vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder * enc,const VkBindImageMemoryInfo * val)675 vn_encode_VkBindImageMemoryInfo(struct vn_cs_encoder *enc, const VkBindImageMemoryInfo *val)
676 {
677 assert(val->sType == VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
678 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO });
679 vn_encode_VkBindImageMemoryInfo_pnext(enc, val->pNext);
680 vn_encode_VkBindImageMemoryInfo_self(enc, val);
681 }
682
683 static inline void *
vn_decode_VkBindImageMemoryInfo_pnext_temp(struct vn_cs_decoder * dec)684 vn_decode_VkBindImageMemoryInfo_pnext_temp(struct vn_cs_decoder *dec)
685 {
686 VkBaseOutStructure *pnext;
687 VkStructureType stype;
688
689 if (!vn_decode_simple_pointer(dec))
690 return NULL;
691
692 vn_decode_VkStructureType(dec, &stype);
693 switch ((int32_t)stype) {
694 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
695 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkBindImageMemoryDeviceGroupInfo));
696 if (pnext) {
697 pnext->sType = stype;
698 pnext->pNext = vn_decode_VkBindImageMemoryInfo_pnext_temp(dec);
699 vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(dec, (VkBindImageMemoryDeviceGroupInfo *)pnext);
700 }
701 break;
702 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
703 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkBindImagePlaneMemoryInfo));
704 if (pnext) {
705 pnext->sType = stype;
706 pnext->pNext = vn_decode_VkBindImageMemoryInfo_pnext_temp(dec);
707 vn_decode_VkBindImagePlaneMemoryInfo_self_temp(dec, (VkBindImagePlaneMemoryInfo *)pnext);
708 }
709 break;
710 default:
711 /* unexpected struct */
712 pnext = NULL;
713 vn_cs_decoder_set_fatal(dec);
714 break;
715 }
716
717 return pnext;
718 }
719
720 static inline void
vn_decode_VkBindImageMemoryInfo_self_temp(struct vn_cs_decoder * dec,VkBindImageMemoryInfo * val)721 vn_decode_VkBindImageMemoryInfo_self_temp(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
722 {
723 /* skip val->{sType,pNext} */
724 vn_decode_VkImage_lookup(dec, &val->image);
725 vn_decode_VkDeviceMemory_lookup(dec, &val->memory);
726 vn_decode_VkDeviceSize(dec, &val->memoryOffset);
727 }
728
729 static inline void
vn_decode_VkBindImageMemoryInfo_temp(struct vn_cs_decoder * dec,VkBindImageMemoryInfo * val)730 vn_decode_VkBindImageMemoryInfo_temp(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
731 {
732 VkStructureType stype;
733 vn_decode_VkStructureType(dec, &stype);
734 if (stype != VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO)
735 vn_cs_decoder_set_fatal(dec);
736
737 val->sType = stype;
738 val->pNext = vn_decode_VkBindImageMemoryInfo_pnext_temp(dec);
739 vn_decode_VkBindImageMemoryInfo_self_temp(dec, val);
740 }
741
742 static inline void
vn_replace_VkBindImageMemoryInfo_handle_self(VkBindImageMemoryInfo * val)743 vn_replace_VkBindImageMemoryInfo_handle_self(VkBindImageMemoryInfo *val)
744 {
745 /* skip val->sType */
746 /* skip val->pNext */
747 vn_replace_VkImage_handle(&val->image);
748 vn_replace_VkDeviceMemory_handle(&val->memory);
749 /* skip val->memoryOffset */
750 }
751
752 static inline void
vn_replace_VkBindImageMemoryInfo_handle(VkBindImageMemoryInfo * val)753 vn_replace_VkBindImageMemoryInfo_handle(VkBindImageMemoryInfo *val)
754 {
755 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
756
757 do {
758 switch ((int32_t)pnext->sType) {
759 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
760 vn_replace_VkBindImageMemoryInfo_handle_self((VkBindImageMemoryInfo *)pnext);
761 break;
762 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
763 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self((VkBindImageMemoryDeviceGroupInfo *)pnext);
764 break;
765 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
766 vn_replace_VkBindImagePlaneMemoryInfo_handle_self((VkBindImagePlaneMemoryInfo *)pnext);
767 break;
768 default:
769 /* ignore unknown/unsupported struct */
770 break;
771 }
772 pnext = pnext->pNext;
773 } while (pnext);
774 }
775
776 /* struct VkImagePlaneMemoryRequirementsInfo chain */
777
778 static inline void *
vn_decode_VkImagePlaneMemoryRequirementsInfo_pnext_temp(struct vn_cs_decoder * dec)779 vn_decode_VkImagePlaneMemoryRequirementsInfo_pnext_temp(struct vn_cs_decoder *dec)
780 {
781 /* no known/supported struct */
782 if (vn_decode_simple_pointer(dec))
783 vn_cs_decoder_set_fatal(dec);
784 return NULL;
785 }
786
787 static inline void
vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(struct vn_cs_decoder * dec,VkImagePlaneMemoryRequirementsInfo * val)788 vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(struct vn_cs_decoder *dec, VkImagePlaneMemoryRequirementsInfo *val)
789 {
790 /* skip val->{sType,pNext} */
791 vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
792 }
793
794 static inline void
vn_decode_VkImagePlaneMemoryRequirementsInfo_temp(struct vn_cs_decoder * dec,VkImagePlaneMemoryRequirementsInfo * val)795 vn_decode_VkImagePlaneMemoryRequirementsInfo_temp(struct vn_cs_decoder *dec, VkImagePlaneMemoryRequirementsInfo *val)
796 {
797 VkStructureType stype;
798 vn_decode_VkStructureType(dec, &stype);
799 if (stype != VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO)
800 vn_cs_decoder_set_fatal(dec);
801
802 val->sType = stype;
803 val->pNext = vn_decode_VkImagePlaneMemoryRequirementsInfo_pnext_temp(dec);
804 vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(dec, val);
805 }
806
807 static inline void
vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self(VkImagePlaneMemoryRequirementsInfo * val)808 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self(VkImagePlaneMemoryRequirementsInfo *val)
809 {
810 /* skip val->sType */
811 /* skip val->pNext */
812 /* skip val->planeAspect */
813 }
814
815 static inline void
vn_replace_VkImagePlaneMemoryRequirementsInfo_handle(VkImagePlaneMemoryRequirementsInfo * val)816 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle(VkImagePlaneMemoryRequirementsInfo *val)
817 {
818 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
819
820 do {
821 switch ((int32_t)pnext->sType) {
822 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
823 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self((VkImagePlaneMemoryRequirementsInfo *)pnext);
824 break;
825 default:
826 /* ignore unknown/unsupported struct */
827 break;
828 }
829 pnext = pnext->pNext;
830 } while (pnext);
831 }
832
833 /* struct VkImageMemoryRequirementsInfo2 chain */
834
835 static inline void *
vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder * dec)836 vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder *dec)
837 {
838 VkBaseOutStructure *pnext;
839 VkStructureType stype;
840
841 if (!vn_decode_simple_pointer(dec))
842 return NULL;
843
844 vn_decode_VkStructureType(dec, &stype);
845 switch ((int32_t)stype) {
846 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
847 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImagePlaneMemoryRequirementsInfo));
848 if (pnext) {
849 pnext->sType = stype;
850 pnext->pNext = vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(dec);
851 vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(dec, (VkImagePlaneMemoryRequirementsInfo *)pnext);
852 }
853 break;
854 default:
855 /* unexpected struct */
856 pnext = NULL;
857 vn_cs_decoder_set_fatal(dec);
858 break;
859 }
860
861 return pnext;
862 }
863
864 static inline void
vn_decode_VkImageMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder * dec,VkImageMemoryRequirementsInfo2 * val)865 vn_decode_VkImageMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder *dec, VkImageMemoryRequirementsInfo2 *val)
866 {
867 /* skip val->{sType,pNext} */
868 vn_decode_VkImage_lookup(dec, &val->image);
869 }
870
871 static inline void
vn_decode_VkImageMemoryRequirementsInfo2_temp(struct vn_cs_decoder * dec,VkImageMemoryRequirementsInfo2 * val)872 vn_decode_VkImageMemoryRequirementsInfo2_temp(struct vn_cs_decoder *dec, VkImageMemoryRequirementsInfo2 *val)
873 {
874 VkStructureType stype;
875 vn_decode_VkStructureType(dec, &stype);
876 if (stype != VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2)
877 vn_cs_decoder_set_fatal(dec);
878
879 val->sType = stype;
880 val->pNext = vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(dec);
881 vn_decode_VkImageMemoryRequirementsInfo2_self_temp(dec, val);
882 }
883
884 static inline void
vn_replace_VkImageMemoryRequirementsInfo2_handle_self(VkImageMemoryRequirementsInfo2 * val)885 vn_replace_VkImageMemoryRequirementsInfo2_handle_self(VkImageMemoryRequirementsInfo2 *val)
886 {
887 /* skip val->sType */
888 /* skip val->pNext */
889 vn_replace_VkImage_handle(&val->image);
890 }
891
892 static inline void
vn_replace_VkImageMemoryRequirementsInfo2_handle(VkImageMemoryRequirementsInfo2 * val)893 vn_replace_VkImageMemoryRequirementsInfo2_handle(VkImageMemoryRequirementsInfo2 *val)
894 {
895 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
896
897 do {
898 switch ((int32_t)pnext->sType) {
899 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
900 vn_replace_VkImageMemoryRequirementsInfo2_handle_self((VkImageMemoryRequirementsInfo2 *)pnext);
901 break;
902 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
903 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self((VkImagePlaneMemoryRequirementsInfo *)pnext);
904 break;
905 default:
906 /* ignore unknown/unsupported struct */
907 break;
908 }
909 pnext = pnext->pNext;
910 } while (pnext);
911 }
912
913 /* struct VkImageSparseMemoryRequirementsInfo2 chain */
914
915 static inline void *
vn_decode_VkImageSparseMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder * dec)916 vn_decode_VkImageSparseMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder *dec)
917 {
918 /* no known/supported struct */
919 if (vn_decode_simple_pointer(dec))
920 vn_cs_decoder_set_fatal(dec);
921 return NULL;
922 }
923
924 static inline void
vn_decode_VkImageSparseMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder * dec,VkImageSparseMemoryRequirementsInfo2 * val)925 vn_decode_VkImageSparseMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder *dec, VkImageSparseMemoryRequirementsInfo2 *val)
926 {
927 /* skip val->{sType,pNext} */
928 vn_decode_VkImage_lookup(dec, &val->image);
929 }
930
931 static inline void
vn_decode_VkImageSparseMemoryRequirementsInfo2_temp(struct vn_cs_decoder * dec,VkImageSparseMemoryRequirementsInfo2 * val)932 vn_decode_VkImageSparseMemoryRequirementsInfo2_temp(struct vn_cs_decoder *dec, VkImageSparseMemoryRequirementsInfo2 *val)
933 {
934 VkStructureType stype;
935 vn_decode_VkStructureType(dec, &stype);
936 if (stype != VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2)
937 vn_cs_decoder_set_fatal(dec);
938
939 val->sType = stype;
940 val->pNext = vn_decode_VkImageSparseMemoryRequirementsInfo2_pnext_temp(dec);
941 vn_decode_VkImageSparseMemoryRequirementsInfo2_self_temp(dec, val);
942 }
943
944 static inline void
vn_replace_VkImageSparseMemoryRequirementsInfo2_handle_self(VkImageSparseMemoryRequirementsInfo2 * val)945 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle_self(VkImageSparseMemoryRequirementsInfo2 *val)
946 {
947 /* skip val->sType */
948 /* skip val->pNext */
949 vn_replace_VkImage_handle(&val->image);
950 }
951
952 static inline void
vn_replace_VkImageSparseMemoryRequirementsInfo2_handle(VkImageSparseMemoryRequirementsInfo2 * val)953 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle(VkImageSparseMemoryRequirementsInfo2 *val)
954 {
955 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
956
957 do {
958 switch ((int32_t)pnext->sType) {
959 case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
960 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle_self((VkImageSparseMemoryRequirementsInfo2 *)pnext);
961 break;
962 default:
963 /* ignore unknown/unsupported struct */
964 break;
965 }
966 pnext = pnext->pNext;
967 } while (pnext);
968 }
969
970 /* struct VkSparseImageMemoryRequirements2 chain */
971
972 static inline void
vn_encode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_encoder * enc,const void * val)973 vn_encode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_encoder *enc, const void *val)
974 {
975 /* no known/supported struct */
976 vn_encode_simple_pointer(enc, NULL);
977 }
978
979 static inline void
vn_encode_VkSparseImageMemoryRequirements2_self(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements2 * val)980 vn_encode_VkSparseImageMemoryRequirements2_self(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
981 {
982 /* skip val->{sType,pNext} */
983 vn_encode_VkSparseImageMemoryRequirements(enc, &val->memoryRequirements);
984 }
985
986 static inline void
vn_encode_VkSparseImageMemoryRequirements2(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements2 * val)987 vn_encode_VkSparseImageMemoryRequirements2(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
988 {
989 assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
990 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 });
991 vn_encode_VkSparseImageMemoryRequirements2_pnext(enc, val->pNext);
992 vn_encode_VkSparseImageMemoryRequirements2_self(enc, val);
993 }
994
995 static inline void *
vn_decode_VkSparseImageMemoryRequirements2_pnext_partial_temp(struct vn_cs_decoder * dec)996 vn_decode_VkSparseImageMemoryRequirements2_pnext_partial_temp(struct vn_cs_decoder *dec)
997 {
998 /* no known/supported struct */
999 if (vn_decode_simple_pointer(dec))
1000 vn_cs_decoder_set_fatal(dec);
1001 return NULL;
1002 }
1003
1004 static inline void
vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements2 * val)1005 vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
1006 {
1007 /* skip val->{sType,pNext} */
1008 vn_decode_VkSparseImageMemoryRequirements_partial_temp(dec, &val->memoryRequirements);
1009 }
1010
1011 static inline void
vn_decode_VkSparseImageMemoryRequirements2_partial_temp(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements2 * val)1012 vn_decode_VkSparseImageMemoryRequirements2_partial_temp(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
1013 {
1014 VkStructureType stype;
1015 vn_decode_VkStructureType(dec, &stype);
1016 if (stype != VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2)
1017 vn_cs_decoder_set_fatal(dec);
1018
1019 val->sType = stype;
1020 val->pNext = vn_decode_VkSparseImageMemoryRequirements2_pnext_partial_temp(dec);
1021 vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(dec, val);
1022 }
1023
1024 /* struct VkImageDrmFormatModifierPropertiesEXT chain */
1025
1026 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_encoder * enc,const void * val)1027 vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
1028 {
1029 /* no known/supported struct */
1030 vn_encode_simple_pointer(enc, NULL);
1031 }
1032
1033 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierPropertiesEXT * val)1034 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
1035 {
1036 /* skip val->{sType,pNext} */
1037 vn_encode_uint64_t(enc, &val->drmFormatModifier);
1038 }
1039
1040 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierPropertiesEXT * val)1041 vn_encode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
1042 {
1043 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
1044 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT });
1045 vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext(enc, val->pNext);
1046 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self(enc, val);
1047 }
1048
1049 static inline void *
vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial_temp(struct vn_cs_decoder * dec)1050 vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial_temp(struct vn_cs_decoder *dec)
1051 {
1052 /* no known/supported struct */
1053 if (vn_decode_simple_pointer(dec))
1054 vn_cs_decoder_set_fatal(dec);
1055 return NULL;
1056 }
1057
1058 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT_self_partial_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierPropertiesEXT * val)1059 vn_decode_VkImageDrmFormatModifierPropertiesEXT_self_partial_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
1060 {
1061 /* skip val->{sType,pNext} */
1062 /* skip val->drmFormatModifier */
1063 }
1064
1065 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT_partial_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierPropertiesEXT * val)1066 vn_decode_VkImageDrmFormatModifierPropertiesEXT_partial_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
1067 {
1068 VkStructureType stype;
1069 vn_decode_VkStructureType(dec, &stype);
1070 if (stype != VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT)
1071 vn_cs_decoder_set_fatal(dec);
1072
1073 val->sType = stype;
1074 val->pNext = vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial_temp(dec);
1075 vn_decode_VkImageDrmFormatModifierPropertiesEXT_self_partial_temp(dec, val);
1076 }
1077
vn_decode_vkGetImageMemoryRequirements_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageMemoryRequirements * args)1078 static inline void vn_decode_vkGetImageMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageMemoryRequirements *args)
1079 {
1080 vn_decode_VkDevice_lookup(dec, &args->device);
1081 vn_decode_VkImage_lookup(dec, &args->image);
1082 if (vn_decode_simple_pointer(dec)) {
1083 args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
1084 if (!args->pMemoryRequirements) return;
1085 vn_decode_VkMemoryRequirements_partial_temp(dec, args->pMemoryRequirements);
1086 } else {
1087 args->pMemoryRequirements = NULL;
1088 vn_cs_decoder_set_fatal(dec);
1089 }
1090 }
1091
vn_replace_vkGetImageMemoryRequirements_args_handle(struct vn_command_vkGetImageMemoryRequirements * args)1092 static inline void vn_replace_vkGetImageMemoryRequirements_args_handle(struct vn_command_vkGetImageMemoryRequirements *args)
1093 {
1094 vn_replace_VkDevice_handle(&args->device);
1095 vn_replace_VkImage_handle(&args->image);
1096 /* skip args->pMemoryRequirements */
1097 }
1098
vn_encode_vkGetImageMemoryRequirements_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageMemoryRequirements * args)1099 static inline void vn_encode_vkGetImageMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageMemoryRequirements *args)
1100 {
1101 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT});
1102
1103 /* skip args->device */
1104 /* skip args->image */
1105 if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
1106 vn_encode_VkMemoryRequirements(enc, args->pMemoryRequirements);
1107 }
1108
vn_decode_vkBindImageMemory_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkBindImageMemory * args)1109 static inline void vn_decode_vkBindImageMemory_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkBindImageMemory *args)
1110 {
1111 vn_decode_VkDevice_lookup(dec, &args->device);
1112 vn_decode_VkImage_lookup(dec, &args->image);
1113 vn_decode_VkDeviceMemory_lookup(dec, &args->memory);
1114 vn_decode_VkDeviceSize(dec, &args->memoryOffset);
1115 }
1116
vn_replace_vkBindImageMemory_args_handle(struct vn_command_vkBindImageMemory * args)1117 static inline void vn_replace_vkBindImageMemory_args_handle(struct vn_command_vkBindImageMemory *args)
1118 {
1119 vn_replace_VkDevice_handle(&args->device);
1120 vn_replace_VkImage_handle(&args->image);
1121 vn_replace_VkDeviceMemory_handle(&args->memory);
1122 /* skip args->memoryOffset */
1123 }
1124
vn_encode_vkBindImageMemory_reply(struct vn_cs_encoder * enc,const struct vn_command_vkBindImageMemory * args)1125 static inline void vn_encode_vkBindImageMemory_reply(struct vn_cs_encoder *enc, const struct vn_command_vkBindImageMemory *args)
1126 {
1127 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkBindImageMemory_EXT});
1128
1129 vn_encode_VkResult(enc, &args->ret);
1130 /* skip args->device */
1131 /* skip args->image */
1132 /* skip args->memory */
1133 /* skip args->memoryOffset */
1134 }
1135
vn_decode_vkGetImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageSparseMemoryRequirements * args)1136 static inline void vn_decode_vkGetImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageSparseMemoryRequirements *args)
1137 {
1138 vn_decode_VkDevice_lookup(dec, &args->device);
1139 vn_decode_VkImage_lookup(dec, &args->image);
1140 if (vn_decode_simple_pointer(dec)) {
1141 args->pSparseMemoryRequirementCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirementCount));
1142 if (!args->pSparseMemoryRequirementCount) return;
1143 vn_decode_uint32_t(dec, args->pSparseMemoryRequirementCount);
1144 } else {
1145 args->pSparseMemoryRequirementCount = NULL;
1146 vn_cs_decoder_set_fatal(dec);
1147 }
1148 if (vn_peek_array_size(dec)) {
1149 const uint32_t iter_count = vn_decode_array_size(dec, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1150 args->pSparseMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirements) * iter_count);
1151 if (!args->pSparseMemoryRequirements) return;
1152 for (uint32_t i = 0; i < iter_count; i++)
1153 vn_decode_VkSparseImageMemoryRequirements_partial_temp(dec, &args->pSparseMemoryRequirements[i]);
1154 } else {
1155 vn_decode_array_size_unchecked(dec);
1156 args->pSparseMemoryRequirements = NULL;
1157 }
1158 }
1159
vn_replace_vkGetImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements * args)1160 static inline void vn_replace_vkGetImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements *args)
1161 {
1162 vn_replace_VkDevice_handle(&args->device);
1163 vn_replace_VkImage_handle(&args->image);
1164 /* skip args->pSparseMemoryRequirementCount */
1165 /* skip args->pSparseMemoryRequirements */
1166 }
1167
vn_encode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageSparseMemoryRequirements * args)1168 static inline void vn_encode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageSparseMemoryRequirements *args)
1169 {
1170 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT});
1171
1172 /* skip args->device */
1173 /* skip args->image */
1174 if (vn_encode_simple_pointer(enc, args->pSparseMemoryRequirementCount))
1175 vn_encode_uint32_t(enc, args->pSparseMemoryRequirementCount);
1176 if (args->pSparseMemoryRequirements) {
1177 vn_encode_array_size(enc, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1178 for (uint32_t i = 0; i < (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0); i++)
1179 vn_encode_VkSparseImageMemoryRequirements(enc, &args->pSparseMemoryRequirements[i]);
1180 } else {
1181 vn_encode_array_size(enc, 0);
1182 }
1183 }
1184
vn_decode_vkCreateImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateImage * args)1185 static inline void vn_decode_vkCreateImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateImage *args)
1186 {
1187 vn_decode_VkDevice_lookup(dec, &args->device);
1188 if (vn_decode_simple_pointer(dec)) {
1189 args->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfo));
1190 if (!args->pCreateInfo) return;
1191 vn_decode_VkImageCreateInfo_temp(dec, (VkImageCreateInfo *)args->pCreateInfo);
1192 } else {
1193 args->pCreateInfo = NULL;
1194 vn_cs_decoder_set_fatal(dec);
1195 }
1196 if (vn_decode_simple_pointer(dec)) {
1197 vn_cs_decoder_set_fatal(dec);
1198 } else {
1199 args->pAllocator = NULL;
1200 }
1201 if (vn_decode_simple_pointer(dec)) {
1202 args->pImage = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImage));
1203 if (!args->pImage) return;
1204 vn_decode_VkImage(dec, args->pImage);
1205 } else {
1206 args->pImage = NULL;
1207 vn_cs_decoder_set_fatal(dec);
1208 }
1209 }
1210
vn_replace_vkCreateImage_args_handle(struct vn_command_vkCreateImage * args)1211 static inline void vn_replace_vkCreateImage_args_handle(struct vn_command_vkCreateImage *args)
1212 {
1213 vn_replace_VkDevice_handle(&args->device);
1214 if (args->pCreateInfo)
1215 vn_replace_VkImageCreateInfo_handle((VkImageCreateInfo *)args->pCreateInfo);
1216 /* skip args->pAllocator */
1217 /* skip args->pImage */
1218 }
1219
vn_encode_vkCreateImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateImage * args)1220 static inline void vn_encode_vkCreateImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateImage *args)
1221 {
1222 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateImage_EXT});
1223
1224 vn_encode_VkResult(enc, &args->ret);
1225 /* skip args->device */
1226 /* skip args->pCreateInfo */
1227 /* skip args->pAllocator */
1228 if (vn_encode_simple_pointer(enc, args->pImage))
1229 vn_encode_VkImage(enc, args->pImage);
1230 }
1231
vn_decode_vkDestroyImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkDestroyImage * args)1232 static inline void vn_decode_vkDestroyImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDestroyImage *args)
1233 {
1234 vn_decode_VkDevice_lookup(dec, &args->device);
1235 vn_decode_VkImage_lookup(dec, &args->image);
1236 if (vn_decode_simple_pointer(dec)) {
1237 vn_cs_decoder_set_fatal(dec);
1238 } else {
1239 args->pAllocator = NULL;
1240 }
1241 }
1242
vn_replace_vkDestroyImage_args_handle(struct vn_command_vkDestroyImage * args)1243 static inline void vn_replace_vkDestroyImage_args_handle(struct vn_command_vkDestroyImage *args)
1244 {
1245 vn_replace_VkDevice_handle(&args->device);
1246 vn_replace_VkImage_handle(&args->image);
1247 /* skip args->pAllocator */
1248 }
1249
vn_encode_vkDestroyImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkDestroyImage * args)1250 static inline void vn_encode_vkDestroyImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDestroyImage *args)
1251 {
1252 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDestroyImage_EXT});
1253
1254 /* skip args->device */
1255 /* skip args->image */
1256 /* skip args->pAllocator */
1257 }
1258
vn_decode_vkGetImageSubresourceLayout_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageSubresourceLayout * args)1259 static inline void vn_decode_vkGetImageSubresourceLayout_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageSubresourceLayout *args)
1260 {
1261 vn_decode_VkDevice_lookup(dec, &args->device);
1262 vn_decode_VkImage_lookup(dec, &args->image);
1263 if (vn_decode_simple_pointer(dec)) {
1264 args->pSubresource = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubresource));
1265 if (!args->pSubresource) return;
1266 vn_decode_VkImageSubresource_temp(dec, (VkImageSubresource *)args->pSubresource);
1267 } else {
1268 args->pSubresource = NULL;
1269 vn_cs_decoder_set_fatal(dec);
1270 }
1271 if (vn_decode_simple_pointer(dec)) {
1272 args->pLayout = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pLayout));
1273 if (!args->pLayout) return;
1274 vn_decode_VkSubresourceLayout_partial_temp(dec, args->pLayout);
1275 } else {
1276 args->pLayout = NULL;
1277 vn_cs_decoder_set_fatal(dec);
1278 }
1279 }
1280
vn_replace_vkGetImageSubresourceLayout_args_handle(struct vn_command_vkGetImageSubresourceLayout * args)1281 static inline void vn_replace_vkGetImageSubresourceLayout_args_handle(struct vn_command_vkGetImageSubresourceLayout *args)
1282 {
1283 vn_replace_VkDevice_handle(&args->device);
1284 vn_replace_VkImage_handle(&args->image);
1285 if (args->pSubresource)
1286 vn_replace_VkImageSubresource_handle((VkImageSubresource *)args->pSubresource);
1287 /* skip args->pLayout */
1288 }
1289
vn_encode_vkGetImageSubresourceLayout_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageSubresourceLayout * args)1290 static inline void vn_encode_vkGetImageSubresourceLayout_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageSubresourceLayout *args)
1291 {
1292 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT});
1293
1294 /* skip args->device */
1295 /* skip args->image */
1296 /* skip args->pSubresource */
1297 if (vn_encode_simple_pointer(enc, args->pLayout))
1298 vn_encode_VkSubresourceLayout(enc, args->pLayout);
1299 }
1300
vn_decode_vkBindImageMemory2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkBindImageMemory2 * args)1301 static inline void vn_decode_vkBindImageMemory2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkBindImageMemory2 *args)
1302 {
1303 vn_decode_VkDevice_lookup(dec, &args->device);
1304 vn_decode_uint32_t(dec, &args->bindInfoCount);
1305 if (vn_peek_array_size(dec)) {
1306 const uint32_t iter_count = vn_decode_array_size(dec, args->bindInfoCount);
1307 args->pBindInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBindInfos) * iter_count);
1308 if (!args->pBindInfos) return;
1309 for (uint32_t i = 0; i < iter_count; i++)
1310 vn_decode_VkBindImageMemoryInfo_temp(dec, &((VkBindImageMemoryInfo *)args->pBindInfos)[i]);
1311 } else {
1312 vn_decode_array_size(dec, args->bindInfoCount);
1313 args->pBindInfos = NULL;
1314 }
1315 }
1316
vn_replace_vkBindImageMemory2_args_handle(struct vn_command_vkBindImageMemory2 * args)1317 static inline void vn_replace_vkBindImageMemory2_args_handle(struct vn_command_vkBindImageMemory2 *args)
1318 {
1319 vn_replace_VkDevice_handle(&args->device);
1320 /* skip args->bindInfoCount */
1321 if (args->pBindInfos) {
1322 for (uint32_t i = 0; i < args->bindInfoCount; i++)
1323 vn_replace_VkBindImageMemoryInfo_handle(&((VkBindImageMemoryInfo *)args->pBindInfos)[i]);
1324 }
1325 }
1326
vn_encode_vkBindImageMemory2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkBindImageMemory2 * args)1327 static inline void vn_encode_vkBindImageMemory2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkBindImageMemory2 *args)
1328 {
1329 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkBindImageMemory2_EXT});
1330
1331 vn_encode_VkResult(enc, &args->ret);
1332 /* skip args->device */
1333 /* skip args->bindInfoCount */
1334 /* skip args->pBindInfos */
1335 }
1336
vn_decode_vkGetImageMemoryRequirements2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageMemoryRequirements2 * args)1337 static inline void vn_decode_vkGetImageMemoryRequirements2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageMemoryRequirements2 *args)
1338 {
1339 vn_decode_VkDevice_lookup(dec, &args->device);
1340 if (vn_decode_simple_pointer(dec)) {
1341 args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
1342 if (!args->pInfo) return;
1343 vn_decode_VkImageMemoryRequirementsInfo2_temp(dec, (VkImageMemoryRequirementsInfo2 *)args->pInfo);
1344 } else {
1345 args->pInfo = NULL;
1346 vn_cs_decoder_set_fatal(dec);
1347 }
1348 if (vn_decode_simple_pointer(dec)) {
1349 args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
1350 if (!args->pMemoryRequirements) return;
1351 vn_decode_VkMemoryRequirements2_partial_temp(dec, args->pMemoryRequirements);
1352 } else {
1353 args->pMemoryRequirements = NULL;
1354 vn_cs_decoder_set_fatal(dec);
1355 }
1356 }
1357
vn_replace_vkGetImageMemoryRequirements2_args_handle(struct vn_command_vkGetImageMemoryRequirements2 * args)1358 static inline void vn_replace_vkGetImageMemoryRequirements2_args_handle(struct vn_command_vkGetImageMemoryRequirements2 *args)
1359 {
1360 vn_replace_VkDevice_handle(&args->device);
1361 if (args->pInfo)
1362 vn_replace_VkImageMemoryRequirementsInfo2_handle((VkImageMemoryRequirementsInfo2 *)args->pInfo);
1363 /* skip args->pMemoryRequirements */
1364 }
1365
vn_encode_vkGetImageMemoryRequirements2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageMemoryRequirements2 * args)1366 static inline void vn_encode_vkGetImageMemoryRequirements2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageMemoryRequirements2 *args)
1367 {
1368 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT});
1369
1370 /* skip args->device */
1371 /* skip args->pInfo */
1372 if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
1373 vn_encode_VkMemoryRequirements2(enc, args->pMemoryRequirements);
1374 }
1375
vn_decode_vkGetImageSparseMemoryRequirements2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageSparseMemoryRequirements2 * args)1376 static inline void vn_decode_vkGetImageSparseMemoryRequirements2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageSparseMemoryRequirements2 *args)
1377 {
1378 vn_decode_VkDevice_lookup(dec, &args->device);
1379 if (vn_decode_simple_pointer(dec)) {
1380 args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
1381 if (!args->pInfo) return;
1382 vn_decode_VkImageSparseMemoryRequirementsInfo2_temp(dec, (VkImageSparseMemoryRequirementsInfo2 *)args->pInfo);
1383 } else {
1384 args->pInfo = NULL;
1385 vn_cs_decoder_set_fatal(dec);
1386 }
1387 if (vn_decode_simple_pointer(dec)) {
1388 args->pSparseMemoryRequirementCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirementCount));
1389 if (!args->pSparseMemoryRequirementCount) return;
1390 vn_decode_uint32_t(dec, args->pSparseMemoryRequirementCount);
1391 } else {
1392 args->pSparseMemoryRequirementCount = NULL;
1393 vn_cs_decoder_set_fatal(dec);
1394 }
1395 if (vn_peek_array_size(dec)) {
1396 const uint32_t iter_count = vn_decode_array_size(dec, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1397 args->pSparseMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirements) * iter_count);
1398 if (!args->pSparseMemoryRequirements) return;
1399 for (uint32_t i = 0; i < iter_count; i++)
1400 vn_decode_VkSparseImageMemoryRequirements2_partial_temp(dec, &args->pSparseMemoryRequirements[i]);
1401 } else {
1402 vn_decode_array_size_unchecked(dec);
1403 args->pSparseMemoryRequirements = NULL;
1404 }
1405 }
1406
vn_replace_vkGetImageSparseMemoryRequirements2_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements2 * args)1407 static inline void vn_replace_vkGetImageSparseMemoryRequirements2_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements2 *args)
1408 {
1409 vn_replace_VkDevice_handle(&args->device);
1410 if (args->pInfo)
1411 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle((VkImageSparseMemoryRequirementsInfo2 *)args->pInfo);
1412 /* skip args->pSparseMemoryRequirementCount */
1413 /* skip args->pSparseMemoryRequirements */
1414 }
1415
vn_encode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageSparseMemoryRequirements2 * args)1416 static inline void vn_encode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageSparseMemoryRequirements2 *args)
1417 {
1418 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT});
1419
1420 /* skip args->device */
1421 /* skip args->pInfo */
1422 if (vn_encode_simple_pointer(enc, args->pSparseMemoryRequirementCount))
1423 vn_encode_uint32_t(enc, args->pSparseMemoryRequirementCount);
1424 if (args->pSparseMemoryRequirements) {
1425 vn_encode_array_size(enc, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1426 for (uint32_t i = 0; i < (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0); i++)
1427 vn_encode_VkSparseImageMemoryRequirements2(enc, &args->pSparseMemoryRequirements[i]);
1428 } else {
1429 vn_encode_array_size(enc, 0);
1430 }
1431 }
1432
vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT * args)1433 static inline void vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
1434 {
1435 vn_decode_VkDevice_lookup(dec, &args->device);
1436 vn_decode_VkImage_lookup(dec, &args->image);
1437 if (vn_decode_simple_pointer(dec)) {
1438 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties));
1439 if (!args->pProperties) return;
1440 vn_decode_VkImageDrmFormatModifierPropertiesEXT_partial_temp(dec, args->pProperties);
1441 } else {
1442 args->pProperties = NULL;
1443 vn_cs_decoder_set_fatal(dec);
1444 }
1445 }
1446
vn_replace_vkGetImageDrmFormatModifierPropertiesEXT_args_handle(struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT * args)1447 static inline void vn_replace_vkGetImageDrmFormatModifierPropertiesEXT_args_handle(struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
1448 {
1449 vn_replace_VkDevice_handle(&args->device);
1450 vn_replace_VkImage_handle(&args->image);
1451 /* skip args->pProperties */
1452 }
1453
vn_encode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT * args)1454 static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
1455 {
1456 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT});
1457
1458 vn_encode_VkResult(enc, &args->ret);
1459 /* skip args->device */
1460 /* skip args->image */
1461 if (vn_encode_simple_pointer(enc, args->pProperties))
1462 vn_encode_VkImageDrmFormatModifierPropertiesEXT(enc, args->pProperties);
1463 }
1464
vn_dispatch_vkGetImageMemoryRequirements(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1465 static inline void vn_dispatch_vkGetImageMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1466 {
1467 struct vn_command_vkGetImageMemoryRequirements args;
1468
1469 if (!ctx->dispatch_vkGetImageMemoryRequirements) {
1470 vn_cs_decoder_set_fatal(ctx->decoder);
1471 return;
1472 }
1473
1474 vn_decode_vkGetImageMemoryRequirements_args_temp(ctx->decoder, &args);
1475 if (!args.device) {
1476 vn_cs_decoder_set_fatal(ctx->decoder);
1477 return;
1478 }
1479
1480 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1481 ctx->dispatch_vkGetImageMemoryRequirements(ctx, &args);
1482
1483
1484 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1485 vn_encode_vkGetImageMemoryRequirements_reply(ctx->encoder, &args);
1486
1487 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1488 }
1489
vn_dispatch_vkBindImageMemory(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1490 static inline void vn_dispatch_vkBindImageMemory(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1491 {
1492 struct vn_command_vkBindImageMemory args;
1493
1494 if (!ctx->dispatch_vkBindImageMemory) {
1495 vn_cs_decoder_set_fatal(ctx->decoder);
1496 return;
1497 }
1498
1499 vn_decode_vkBindImageMemory_args_temp(ctx->decoder, &args);
1500 if (!args.device) {
1501 vn_cs_decoder_set_fatal(ctx->decoder);
1502 return;
1503 }
1504
1505 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1506 ctx->dispatch_vkBindImageMemory(ctx, &args);
1507
1508 #ifdef DEBUG
1509 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1510 vn_dispatch_debug_log(ctx, "vkBindImageMemory returned %d", args.ret);
1511 #endif
1512
1513 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1514 vn_encode_vkBindImageMemory_reply(ctx->encoder, &args);
1515
1516 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1517 }
1518
vn_dispatch_vkGetImageSparseMemoryRequirements(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1519 static inline void vn_dispatch_vkGetImageSparseMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1520 {
1521 struct vn_command_vkGetImageSparseMemoryRequirements args;
1522
1523 if (!ctx->dispatch_vkGetImageSparseMemoryRequirements) {
1524 vn_cs_decoder_set_fatal(ctx->decoder);
1525 return;
1526 }
1527
1528 vn_decode_vkGetImageSparseMemoryRequirements_args_temp(ctx->decoder, &args);
1529 if (!args.device) {
1530 vn_cs_decoder_set_fatal(ctx->decoder);
1531 return;
1532 }
1533
1534 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1535 ctx->dispatch_vkGetImageSparseMemoryRequirements(ctx, &args);
1536
1537
1538 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1539 vn_encode_vkGetImageSparseMemoryRequirements_reply(ctx->encoder, &args);
1540
1541 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1542 }
1543
vn_dispatch_vkCreateImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1544 static inline void vn_dispatch_vkCreateImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1545 {
1546 struct vn_command_vkCreateImage args;
1547
1548 if (!ctx->dispatch_vkCreateImage) {
1549 vn_cs_decoder_set_fatal(ctx->decoder);
1550 return;
1551 }
1552
1553 vn_decode_vkCreateImage_args_temp(ctx->decoder, &args);
1554 if (!args.device) {
1555 vn_cs_decoder_set_fatal(ctx->decoder);
1556 return;
1557 }
1558
1559 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1560 ctx->dispatch_vkCreateImage(ctx, &args);
1561
1562 #ifdef DEBUG
1563 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1564 vn_dispatch_debug_log(ctx, "vkCreateImage returned %d", args.ret);
1565 #endif
1566
1567 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1568 vn_encode_vkCreateImage_reply(ctx->encoder, &args);
1569
1570 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1571 }
1572
vn_dispatch_vkDestroyImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1573 static inline void vn_dispatch_vkDestroyImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1574 {
1575 struct vn_command_vkDestroyImage args;
1576
1577 if (!ctx->dispatch_vkDestroyImage) {
1578 vn_cs_decoder_set_fatal(ctx->decoder);
1579 return;
1580 }
1581
1582 vn_decode_vkDestroyImage_args_temp(ctx->decoder, &args);
1583 if (!args.device) {
1584 vn_cs_decoder_set_fatal(ctx->decoder);
1585 return;
1586 }
1587
1588 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1589 ctx->dispatch_vkDestroyImage(ctx, &args);
1590
1591
1592 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1593 vn_encode_vkDestroyImage_reply(ctx->encoder, &args);
1594
1595 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1596 }
1597
vn_dispatch_vkGetImageSubresourceLayout(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1598 static inline void vn_dispatch_vkGetImageSubresourceLayout(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1599 {
1600 struct vn_command_vkGetImageSubresourceLayout args;
1601
1602 if (!ctx->dispatch_vkGetImageSubresourceLayout) {
1603 vn_cs_decoder_set_fatal(ctx->decoder);
1604 return;
1605 }
1606
1607 vn_decode_vkGetImageSubresourceLayout_args_temp(ctx->decoder, &args);
1608 if (!args.device) {
1609 vn_cs_decoder_set_fatal(ctx->decoder);
1610 return;
1611 }
1612
1613 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1614 ctx->dispatch_vkGetImageSubresourceLayout(ctx, &args);
1615
1616
1617 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1618 vn_encode_vkGetImageSubresourceLayout_reply(ctx->encoder, &args);
1619
1620 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1621 }
1622
vn_dispatch_vkBindImageMemory2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1623 static inline void vn_dispatch_vkBindImageMemory2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1624 {
1625 struct vn_command_vkBindImageMemory2 args;
1626
1627 if (!ctx->dispatch_vkBindImageMemory2) {
1628 vn_cs_decoder_set_fatal(ctx->decoder);
1629 return;
1630 }
1631
1632 vn_decode_vkBindImageMemory2_args_temp(ctx->decoder, &args);
1633 if (!args.device) {
1634 vn_cs_decoder_set_fatal(ctx->decoder);
1635 return;
1636 }
1637
1638 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1639 ctx->dispatch_vkBindImageMemory2(ctx, &args);
1640
1641 #ifdef DEBUG
1642 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1643 vn_dispatch_debug_log(ctx, "vkBindImageMemory2 returned %d", args.ret);
1644 #endif
1645
1646 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1647 vn_encode_vkBindImageMemory2_reply(ctx->encoder, &args);
1648
1649 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1650 }
1651
vn_dispatch_vkGetImageMemoryRequirements2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1652 static inline void vn_dispatch_vkGetImageMemoryRequirements2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1653 {
1654 struct vn_command_vkGetImageMemoryRequirements2 args;
1655
1656 if (!ctx->dispatch_vkGetImageMemoryRequirements2) {
1657 vn_cs_decoder_set_fatal(ctx->decoder);
1658 return;
1659 }
1660
1661 vn_decode_vkGetImageMemoryRequirements2_args_temp(ctx->decoder, &args);
1662 if (!args.device) {
1663 vn_cs_decoder_set_fatal(ctx->decoder);
1664 return;
1665 }
1666
1667 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1668 ctx->dispatch_vkGetImageMemoryRequirements2(ctx, &args);
1669
1670
1671 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1672 vn_encode_vkGetImageMemoryRequirements2_reply(ctx->encoder, &args);
1673
1674 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1675 }
1676
vn_dispatch_vkGetImageSparseMemoryRequirements2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1677 static inline void vn_dispatch_vkGetImageSparseMemoryRequirements2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1678 {
1679 struct vn_command_vkGetImageSparseMemoryRequirements2 args;
1680
1681 if (!ctx->dispatch_vkGetImageSparseMemoryRequirements2) {
1682 vn_cs_decoder_set_fatal(ctx->decoder);
1683 return;
1684 }
1685
1686 vn_decode_vkGetImageSparseMemoryRequirements2_args_temp(ctx->decoder, &args);
1687 if (!args.device) {
1688 vn_cs_decoder_set_fatal(ctx->decoder);
1689 return;
1690 }
1691
1692 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1693 ctx->dispatch_vkGetImageSparseMemoryRequirements2(ctx, &args);
1694
1695
1696 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1697 vn_encode_vkGetImageSparseMemoryRequirements2_reply(ctx->encoder, &args);
1698
1699 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1700 }
1701
vn_dispatch_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1702 static inline void vn_dispatch_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1703 {
1704 struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT args;
1705
1706 if (!ctx->dispatch_vkGetImageDrmFormatModifierPropertiesEXT) {
1707 vn_cs_decoder_set_fatal(ctx->decoder);
1708 return;
1709 }
1710
1711 vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(ctx->decoder, &args);
1712 if (!args.device) {
1713 vn_cs_decoder_set_fatal(ctx->decoder);
1714 return;
1715 }
1716
1717 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1718 ctx->dispatch_vkGetImageDrmFormatModifierPropertiesEXT(ctx, &args);
1719
1720 #ifdef DEBUG
1721 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1722 vn_dispatch_debug_log(ctx, "vkGetImageDrmFormatModifierPropertiesEXT returned %d", args.ret);
1723 #endif
1724
1725 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1726 vn_encode_vkGetImageDrmFormatModifierPropertiesEXT_reply(ctx->encoder, &args);
1727
1728 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1729 }
1730
1731 #pragma GCC diagnostic pop
1732
1733 #endif /* VN_PROTOCOL_RENDERER_IMAGE_H */
1734