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_decode_VkBindImageMemoryDeviceGroupInfo_pnext_temp(struct vn_cs_decoder * dec)437 vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext_temp(struct vn_cs_decoder *dec)
438 {
439 /* no known/supported struct */
440 if (vn_decode_simple_pointer(dec))
441 vn_cs_decoder_set_fatal(dec);
442 return NULL;
443 }
444
445 static inline void
vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(struct vn_cs_decoder * dec,VkBindImageMemoryDeviceGroupInfo * val)446 vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
447 {
448 /* skip val->{sType,pNext} */
449 vn_decode_uint32_t(dec, &val->deviceIndexCount);
450 if (vn_peek_array_size(dec)) {
451 const size_t array_size = vn_decode_array_size(dec, val->deviceIndexCount);
452 val->pDeviceIndices = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pDeviceIndices) * array_size);
453 if (!val->pDeviceIndices) return;
454 vn_decode_uint32_t_array(dec, (uint32_t *)val->pDeviceIndices, array_size);
455 } else {
456 vn_decode_array_size(dec, val->deviceIndexCount);
457 val->pDeviceIndices = NULL;
458 }
459 vn_decode_uint32_t(dec, &val->splitInstanceBindRegionCount);
460 if (vn_peek_array_size(dec)) {
461 const uint32_t iter_count = vn_decode_array_size(dec, val->splitInstanceBindRegionCount);
462 val->pSplitInstanceBindRegions = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSplitInstanceBindRegions) * iter_count);
463 if (!val->pSplitInstanceBindRegions) return;
464 for (uint32_t i = 0; i < iter_count; i++)
465 vn_decode_VkRect2D_temp(dec, &((VkRect2D *)val->pSplitInstanceBindRegions)[i]);
466 } else {
467 vn_decode_array_size(dec, val->splitInstanceBindRegionCount);
468 val->pSplitInstanceBindRegions = NULL;
469 }
470 }
471
472 static inline void
vn_decode_VkBindImageMemoryDeviceGroupInfo_temp(struct vn_cs_decoder * dec,VkBindImageMemoryDeviceGroupInfo * val)473 vn_decode_VkBindImageMemoryDeviceGroupInfo_temp(struct vn_cs_decoder *dec, VkBindImageMemoryDeviceGroupInfo *val)
474 {
475 VkStructureType stype;
476 vn_decode_VkStructureType(dec, &stype);
477 if (stype != VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO)
478 vn_cs_decoder_set_fatal(dec);
479
480 val->sType = stype;
481 val->pNext = vn_decode_VkBindImageMemoryDeviceGroupInfo_pnext_temp(dec);
482 vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(dec, val);
483 }
484
485 static inline void
vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self(VkBindImageMemoryDeviceGroupInfo * val)486 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self(VkBindImageMemoryDeviceGroupInfo *val)
487 {
488 /* skip val->sType */
489 /* skip val->pNext */
490 /* skip val->deviceIndexCount */
491 /* skip val->pDeviceIndices */
492 /* skip val->splitInstanceBindRegionCount */
493 if (val->pSplitInstanceBindRegions) {
494 for (uint32_t i = 0; i < val->splitInstanceBindRegionCount; i++)
495 vn_replace_VkRect2D_handle(&((VkRect2D *)val->pSplitInstanceBindRegions)[i]);
496 }
497 }
498
499 static inline void
vn_replace_VkBindImageMemoryDeviceGroupInfo_handle(VkBindImageMemoryDeviceGroupInfo * val)500 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle(VkBindImageMemoryDeviceGroupInfo *val)
501 {
502 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
503
504 do {
505 switch ((int32_t)pnext->sType) {
506 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
507 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self((VkBindImageMemoryDeviceGroupInfo *)pnext);
508 break;
509 default:
510 /* ignore unknown/unsupported struct */
511 break;
512 }
513 pnext = pnext->pNext;
514 } while (pnext);
515 }
516
517 /* struct VkBindImagePlaneMemoryInfo chain */
518
519 static inline void *
vn_decode_VkBindImagePlaneMemoryInfo_pnext_temp(struct vn_cs_decoder * dec)520 vn_decode_VkBindImagePlaneMemoryInfo_pnext_temp(struct vn_cs_decoder *dec)
521 {
522 /* no known/supported struct */
523 if (vn_decode_simple_pointer(dec))
524 vn_cs_decoder_set_fatal(dec);
525 return NULL;
526 }
527
528 static inline void
vn_decode_VkBindImagePlaneMemoryInfo_self_temp(struct vn_cs_decoder * dec,VkBindImagePlaneMemoryInfo * val)529 vn_decode_VkBindImagePlaneMemoryInfo_self_temp(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
530 {
531 /* skip val->{sType,pNext} */
532 vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
533 }
534
535 static inline void
vn_decode_VkBindImagePlaneMemoryInfo_temp(struct vn_cs_decoder * dec,VkBindImagePlaneMemoryInfo * val)536 vn_decode_VkBindImagePlaneMemoryInfo_temp(struct vn_cs_decoder *dec, VkBindImagePlaneMemoryInfo *val)
537 {
538 VkStructureType stype;
539 vn_decode_VkStructureType(dec, &stype);
540 if (stype != VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO)
541 vn_cs_decoder_set_fatal(dec);
542
543 val->sType = stype;
544 val->pNext = vn_decode_VkBindImagePlaneMemoryInfo_pnext_temp(dec);
545 vn_decode_VkBindImagePlaneMemoryInfo_self_temp(dec, val);
546 }
547
548 static inline void
vn_replace_VkBindImagePlaneMemoryInfo_handle_self(VkBindImagePlaneMemoryInfo * val)549 vn_replace_VkBindImagePlaneMemoryInfo_handle_self(VkBindImagePlaneMemoryInfo *val)
550 {
551 /* skip val->sType */
552 /* skip val->pNext */
553 /* skip val->planeAspect */
554 }
555
556 static inline void
vn_replace_VkBindImagePlaneMemoryInfo_handle(VkBindImagePlaneMemoryInfo * val)557 vn_replace_VkBindImagePlaneMemoryInfo_handle(VkBindImagePlaneMemoryInfo *val)
558 {
559 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
560
561 do {
562 switch ((int32_t)pnext->sType) {
563 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
564 vn_replace_VkBindImagePlaneMemoryInfo_handle_self((VkBindImagePlaneMemoryInfo *)pnext);
565 break;
566 default:
567 /* ignore unknown/unsupported struct */
568 break;
569 }
570 pnext = pnext->pNext;
571 } while (pnext);
572 }
573
574 /* struct VkBindImageMemoryInfo chain */
575
576 static inline void *
vn_decode_VkBindImageMemoryInfo_pnext_temp(struct vn_cs_decoder * dec)577 vn_decode_VkBindImageMemoryInfo_pnext_temp(struct vn_cs_decoder *dec)
578 {
579 VkBaseOutStructure *pnext;
580 VkStructureType stype;
581
582 if (!vn_decode_simple_pointer(dec))
583 return NULL;
584
585 vn_decode_VkStructureType(dec, &stype);
586 switch ((int32_t)stype) {
587 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
588 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkBindImageMemoryDeviceGroupInfo));
589 if (pnext) {
590 pnext->sType = stype;
591 pnext->pNext = vn_decode_VkBindImageMemoryInfo_pnext_temp(dec);
592 vn_decode_VkBindImageMemoryDeviceGroupInfo_self_temp(dec, (VkBindImageMemoryDeviceGroupInfo *)pnext);
593 }
594 break;
595 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
596 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkBindImagePlaneMemoryInfo));
597 if (pnext) {
598 pnext->sType = stype;
599 pnext->pNext = vn_decode_VkBindImageMemoryInfo_pnext_temp(dec);
600 vn_decode_VkBindImagePlaneMemoryInfo_self_temp(dec, (VkBindImagePlaneMemoryInfo *)pnext);
601 }
602 break;
603 default:
604 /* unexpected struct */
605 pnext = NULL;
606 vn_cs_decoder_set_fatal(dec);
607 break;
608 }
609
610 return pnext;
611 }
612
613 static inline void
vn_decode_VkBindImageMemoryInfo_self_temp(struct vn_cs_decoder * dec,VkBindImageMemoryInfo * val)614 vn_decode_VkBindImageMemoryInfo_self_temp(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
615 {
616 /* skip val->{sType,pNext} */
617 vn_decode_VkImage_lookup(dec, &val->image);
618 vn_decode_VkDeviceMemory_lookup(dec, &val->memory);
619 vn_decode_VkDeviceSize(dec, &val->memoryOffset);
620 }
621
622 static inline void
vn_decode_VkBindImageMemoryInfo_temp(struct vn_cs_decoder * dec,VkBindImageMemoryInfo * val)623 vn_decode_VkBindImageMemoryInfo_temp(struct vn_cs_decoder *dec, VkBindImageMemoryInfo *val)
624 {
625 VkStructureType stype;
626 vn_decode_VkStructureType(dec, &stype);
627 if (stype != VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO)
628 vn_cs_decoder_set_fatal(dec);
629
630 val->sType = stype;
631 val->pNext = vn_decode_VkBindImageMemoryInfo_pnext_temp(dec);
632 vn_decode_VkBindImageMemoryInfo_self_temp(dec, val);
633 }
634
635 static inline void
vn_replace_VkBindImageMemoryInfo_handle_self(VkBindImageMemoryInfo * val)636 vn_replace_VkBindImageMemoryInfo_handle_self(VkBindImageMemoryInfo *val)
637 {
638 /* skip val->sType */
639 /* skip val->pNext */
640 vn_replace_VkImage_handle(&val->image);
641 vn_replace_VkDeviceMemory_handle(&val->memory);
642 /* skip val->memoryOffset */
643 }
644
645 static inline void
vn_replace_VkBindImageMemoryInfo_handle(VkBindImageMemoryInfo * val)646 vn_replace_VkBindImageMemoryInfo_handle(VkBindImageMemoryInfo *val)
647 {
648 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
649
650 do {
651 switch ((int32_t)pnext->sType) {
652 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO:
653 vn_replace_VkBindImageMemoryInfo_handle_self((VkBindImageMemoryInfo *)pnext);
654 break;
655 case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
656 vn_replace_VkBindImageMemoryDeviceGroupInfo_handle_self((VkBindImageMemoryDeviceGroupInfo *)pnext);
657 break;
658 case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
659 vn_replace_VkBindImagePlaneMemoryInfo_handle_self((VkBindImagePlaneMemoryInfo *)pnext);
660 break;
661 default:
662 /* ignore unknown/unsupported struct */
663 break;
664 }
665 pnext = pnext->pNext;
666 } while (pnext);
667 }
668
669 /* struct VkImagePlaneMemoryRequirementsInfo chain */
670
671 static inline void *
vn_decode_VkImagePlaneMemoryRequirementsInfo_pnext_temp(struct vn_cs_decoder * dec)672 vn_decode_VkImagePlaneMemoryRequirementsInfo_pnext_temp(struct vn_cs_decoder *dec)
673 {
674 /* no known/supported struct */
675 if (vn_decode_simple_pointer(dec))
676 vn_cs_decoder_set_fatal(dec);
677 return NULL;
678 }
679
680 static inline void
vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(struct vn_cs_decoder * dec,VkImagePlaneMemoryRequirementsInfo * val)681 vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(struct vn_cs_decoder *dec, VkImagePlaneMemoryRequirementsInfo *val)
682 {
683 /* skip val->{sType,pNext} */
684 vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
685 }
686
687 static inline void
vn_decode_VkImagePlaneMemoryRequirementsInfo_temp(struct vn_cs_decoder * dec,VkImagePlaneMemoryRequirementsInfo * val)688 vn_decode_VkImagePlaneMemoryRequirementsInfo_temp(struct vn_cs_decoder *dec, VkImagePlaneMemoryRequirementsInfo *val)
689 {
690 VkStructureType stype;
691 vn_decode_VkStructureType(dec, &stype);
692 if (stype != VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO)
693 vn_cs_decoder_set_fatal(dec);
694
695 val->sType = stype;
696 val->pNext = vn_decode_VkImagePlaneMemoryRequirementsInfo_pnext_temp(dec);
697 vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(dec, val);
698 }
699
700 static inline void
vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self(VkImagePlaneMemoryRequirementsInfo * val)701 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self(VkImagePlaneMemoryRequirementsInfo *val)
702 {
703 /* skip val->sType */
704 /* skip val->pNext */
705 /* skip val->planeAspect */
706 }
707
708 static inline void
vn_replace_VkImagePlaneMemoryRequirementsInfo_handle(VkImagePlaneMemoryRequirementsInfo * val)709 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle(VkImagePlaneMemoryRequirementsInfo *val)
710 {
711 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
712
713 do {
714 switch ((int32_t)pnext->sType) {
715 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
716 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self((VkImagePlaneMemoryRequirementsInfo *)pnext);
717 break;
718 default:
719 /* ignore unknown/unsupported struct */
720 break;
721 }
722 pnext = pnext->pNext;
723 } while (pnext);
724 }
725
726 /* struct VkImageMemoryRequirementsInfo2 chain */
727
728 static inline void *
vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder * dec)729 vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder *dec)
730 {
731 VkBaseOutStructure *pnext;
732 VkStructureType stype;
733
734 if (!vn_decode_simple_pointer(dec))
735 return NULL;
736
737 vn_decode_VkStructureType(dec, &stype);
738 switch ((int32_t)stype) {
739 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
740 pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkImagePlaneMemoryRequirementsInfo));
741 if (pnext) {
742 pnext->sType = stype;
743 pnext->pNext = vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(dec);
744 vn_decode_VkImagePlaneMemoryRequirementsInfo_self_temp(dec, (VkImagePlaneMemoryRequirementsInfo *)pnext);
745 }
746 break;
747 default:
748 /* unexpected struct */
749 pnext = NULL;
750 vn_cs_decoder_set_fatal(dec);
751 break;
752 }
753
754 return pnext;
755 }
756
757 static inline void
vn_decode_VkImageMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder * dec,VkImageMemoryRequirementsInfo2 * val)758 vn_decode_VkImageMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder *dec, VkImageMemoryRequirementsInfo2 *val)
759 {
760 /* skip val->{sType,pNext} */
761 vn_decode_VkImage_lookup(dec, &val->image);
762 }
763
764 static inline void
vn_decode_VkImageMemoryRequirementsInfo2_temp(struct vn_cs_decoder * dec,VkImageMemoryRequirementsInfo2 * val)765 vn_decode_VkImageMemoryRequirementsInfo2_temp(struct vn_cs_decoder *dec, VkImageMemoryRequirementsInfo2 *val)
766 {
767 VkStructureType stype;
768 vn_decode_VkStructureType(dec, &stype);
769 if (stype != VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2)
770 vn_cs_decoder_set_fatal(dec);
771
772 val->sType = stype;
773 val->pNext = vn_decode_VkImageMemoryRequirementsInfo2_pnext_temp(dec);
774 vn_decode_VkImageMemoryRequirementsInfo2_self_temp(dec, val);
775 }
776
777 static inline void
vn_replace_VkImageMemoryRequirementsInfo2_handle_self(VkImageMemoryRequirementsInfo2 * val)778 vn_replace_VkImageMemoryRequirementsInfo2_handle_self(VkImageMemoryRequirementsInfo2 *val)
779 {
780 /* skip val->sType */
781 /* skip val->pNext */
782 vn_replace_VkImage_handle(&val->image);
783 }
784
785 static inline void
vn_replace_VkImageMemoryRequirementsInfo2_handle(VkImageMemoryRequirementsInfo2 * val)786 vn_replace_VkImageMemoryRequirementsInfo2_handle(VkImageMemoryRequirementsInfo2 *val)
787 {
788 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
789
790 do {
791 switch ((int32_t)pnext->sType) {
792 case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2:
793 vn_replace_VkImageMemoryRequirementsInfo2_handle_self((VkImageMemoryRequirementsInfo2 *)pnext);
794 break;
795 case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
796 vn_replace_VkImagePlaneMemoryRequirementsInfo_handle_self((VkImagePlaneMemoryRequirementsInfo *)pnext);
797 break;
798 default:
799 /* ignore unknown/unsupported struct */
800 break;
801 }
802 pnext = pnext->pNext;
803 } while (pnext);
804 }
805
806 /* struct VkImageSparseMemoryRequirementsInfo2 chain */
807
808 static inline void *
vn_decode_VkImageSparseMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder * dec)809 vn_decode_VkImageSparseMemoryRequirementsInfo2_pnext_temp(struct vn_cs_decoder *dec)
810 {
811 /* no known/supported struct */
812 if (vn_decode_simple_pointer(dec))
813 vn_cs_decoder_set_fatal(dec);
814 return NULL;
815 }
816
817 static inline void
vn_decode_VkImageSparseMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder * dec,VkImageSparseMemoryRequirementsInfo2 * val)818 vn_decode_VkImageSparseMemoryRequirementsInfo2_self_temp(struct vn_cs_decoder *dec, VkImageSparseMemoryRequirementsInfo2 *val)
819 {
820 /* skip val->{sType,pNext} */
821 vn_decode_VkImage_lookup(dec, &val->image);
822 }
823
824 static inline void
vn_decode_VkImageSparseMemoryRequirementsInfo2_temp(struct vn_cs_decoder * dec,VkImageSparseMemoryRequirementsInfo2 * val)825 vn_decode_VkImageSparseMemoryRequirementsInfo2_temp(struct vn_cs_decoder *dec, VkImageSparseMemoryRequirementsInfo2 *val)
826 {
827 VkStructureType stype;
828 vn_decode_VkStructureType(dec, &stype);
829 if (stype != VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2)
830 vn_cs_decoder_set_fatal(dec);
831
832 val->sType = stype;
833 val->pNext = vn_decode_VkImageSparseMemoryRequirementsInfo2_pnext_temp(dec);
834 vn_decode_VkImageSparseMemoryRequirementsInfo2_self_temp(dec, val);
835 }
836
837 static inline void
vn_replace_VkImageSparseMemoryRequirementsInfo2_handle_self(VkImageSparseMemoryRequirementsInfo2 * val)838 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle_self(VkImageSparseMemoryRequirementsInfo2 *val)
839 {
840 /* skip val->sType */
841 /* skip val->pNext */
842 vn_replace_VkImage_handle(&val->image);
843 }
844
845 static inline void
vn_replace_VkImageSparseMemoryRequirementsInfo2_handle(VkImageSparseMemoryRequirementsInfo2 * val)846 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle(VkImageSparseMemoryRequirementsInfo2 *val)
847 {
848 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
849
850 do {
851 switch ((int32_t)pnext->sType) {
852 case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2:
853 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle_self((VkImageSparseMemoryRequirementsInfo2 *)pnext);
854 break;
855 default:
856 /* ignore unknown/unsupported struct */
857 break;
858 }
859 pnext = pnext->pNext;
860 } while (pnext);
861 }
862
863 /* struct VkSparseImageMemoryRequirements2 chain */
864
865 static inline void
vn_encode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_encoder * enc,const void * val)866 vn_encode_VkSparseImageMemoryRequirements2_pnext(struct vn_cs_encoder *enc, const void *val)
867 {
868 /* no known/supported struct */
869 vn_encode_simple_pointer(enc, NULL);
870 }
871
872 static inline void
vn_encode_VkSparseImageMemoryRequirements2_self(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements2 * val)873 vn_encode_VkSparseImageMemoryRequirements2_self(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
874 {
875 /* skip val->{sType,pNext} */
876 vn_encode_VkSparseImageMemoryRequirements(enc, &val->memoryRequirements);
877 }
878
879 static inline void
vn_encode_VkSparseImageMemoryRequirements2(struct vn_cs_encoder * enc,const VkSparseImageMemoryRequirements2 * val)880 vn_encode_VkSparseImageMemoryRequirements2(struct vn_cs_encoder *enc, const VkSparseImageMemoryRequirements2 *val)
881 {
882 assert(val->sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2);
883 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 });
884 vn_encode_VkSparseImageMemoryRequirements2_pnext(enc, val->pNext);
885 vn_encode_VkSparseImageMemoryRequirements2_self(enc, val);
886 }
887
888 static inline void *
vn_decode_VkSparseImageMemoryRequirements2_pnext_partial_temp(struct vn_cs_decoder * dec)889 vn_decode_VkSparseImageMemoryRequirements2_pnext_partial_temp(struct vn_cs_decoder *dec)
890 {
891 /* no known/supported struct */
892 if (vn_decode_simple_pointer(dec))
893 vn_cs_decoder_set_fatal(dec);
894 return NULL;
895 }
896
897 static inline void
vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements2 * val)898 vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
899 {
900 /* skip val->{sType,pNext} */
901 vn_decode_VkSparseImageMemoryRequirements_partial_temp(dec, &val->memoryRequirements);
902 }
903
904 static inline void
vn_decode_VkSparseImageMemoryRequirements2_partial_temp(struct vn_cs_decoder * dec,VkSparseImageMemoryRequirements2 * val)905 vn_decode_VkSparseImageMemoryRequirements2_partial_temp(struct vn_cs_decoder *dec, VkSparseImageMemoryRequirements2 *val)
906 {
907 VkStructureType stype;
908 vn_decode_VkStructureType(dec, &stype);
909 if (stype != VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2)
910 vn_cs_decoder_set_fatal(dec);
911
912 val->sType = stype;
913 val->pNext = vn_decode_VkSparseImageMemoryRequirements2_pnext_partial_temp(dec);
914 vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(dec, val);
915 }
916
917 /* struct VkDeviceImageMemoryRequirements chain */
918
919 static inline void *
vn_decode_VkDeviceImageMemoryRequirements_pnext_temp(struct vn_cs_decoder * dec)920 vn_decode_VkDeviceImageMemoryRequirements_pnext_temp(struct vn_cs_decoder *dec)
921 {
922 /* no known/supported struct */
923 if (vn_decode_simple_pointer(dec))
924 vn_cs_decoder_set_fatal(dec);
925 return NULL;
926 }
927
928 static inline void
vn_decode_VkDeviceImageMemoryRequirements_self_temp(struct vn_cs_decoder * dec,VkDeviceImageMemoryRequirements * val)929 vn_decode_VkDeviceImageMemoryRequirements_self_temp(struct vn_cs_decoder *dec, VkDeviceImageMemoryRequirements *val)
930 {
931 /* skip val->{sType,pNext} */
932 if (vn_decode_simple_pointer(dec)) {
933 val->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pCreateInfo));
934 if (!val->pCreateInfo) return;
935 vn_decode_VkImageCreateInfo_temp(dec, (VkImageCreateInfo *)val->pCreateInfo);
936 } else {
937 val->pCreateInfo = NULL;
938 vn_cs_decoder_set_fatal(dec);
939 }
940 vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
941 }
942
943 static inline void
vn_decode_VkDeviceImageMemoryRequirements_temp(struct vn_cs_decoder * dec,VkDeviceImageMemoryRequirements * val)944 vn_decode_VkDeviceImageMemoryRequirements_temp(struct vn_cs_decoder *dec, VkDeviceImageMemoryRequirements *val)
945 {
946 VkStructureType stype;
947 vn_decode_VkStructureType(dec, &stype);
948 if (stype != VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS)
949 vn_cs_decoder_set_fatal(dec);
950
951 val->sType = stype;
952 val->pNext = vn_decode_VkDeviceImageMemoryRequirements_pnext_temp(dec);
953 vn_decode_VkDeviceImageMemoryRequirements_self_temp(dec, val);
954 }
955
956 static inline void
vn_replace_VkDeviceImageMemoryRequirements_handle_self(VkDeviceImageMemoryRequirements * val)957 vn_replace_VkDeviceImageMemoryRequirements_handle_self(VkDeviceImageMemoryRequirements *val)
958 {
959 /* skip val->sType */
960 /* skip val->pNext */
961 if (val->pCreateInfo)
962 vn_replace_VkImageCreateInfo_handle((VkImageCreateInfo *)val->pCreateInfo);
963 /* skip val->planeAspect */
964 }
965
966 static inline void
vn_replace_VkDeviceImageMemoryRequirements_handle(VkDeviceImageMemoryRequirements * val)967 vn_replace_VkDeviceImageMemoryRequirements_handle(VkDeviceImageMemoryRequirements *val)
968 {
969 struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
970
971 do {
972 switch ((int32_t)pnext->sType) {
973 case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
974 vn_replace_VkDeviceImageMemoryRequirements_handle_self((VkDeviceImageMemoryRequirements *)pnext);
975 break;
976 default:
977 /* ignore unknown/unsupported struct */
978 break;
979 }
980 pnext = pnext->pNext;
981 } while (pnext);
982 }
983
984 /* struct VkImageDrmFormatModifierPropertiesEXT chain */
985
986 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_encoder * enc,const void * val)987 vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext(struct vn_cs_encoder *enc, const void *val)
988 {
989 /* no known/supported struct */
990 vn_encode_simple_pointer(enc, NULL);
991 }
992
993 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierPropertiesEXT * val)994 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
995 {
996 /* skip val->{sType,pNext} */
997 vn_encode_uint64_t(enc, &val->drmFormatModifier);
998 }
999
1000 static inline void
vn_encode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder * enc,const VkImageDrmFormatModifierPropertiesEXT * val)1001 vn_encode_VkImageDrmFormatModifierPropertiesEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierPropertiesEXT *val)
1002 {
1003 assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT);
1004 vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT });
1005 vn_encode_VkImageDrmFormatModifierPropertiesEXT_pnext(enc, val->pNext);
1006 vn_encode_VkImageDrmFormatModifierPropertiesEXT_self(enc, val);
1007 }
1008
1009 static inline void *
vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial_temp(struct vn_cs_decoder * dec)1010 vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial_temp(struct vn_cs_decoder *dec)
1011 {
1012 /* no known/supported struct */
1013 if (vn_decode_simple_pointer(dec))
1014 vn_cs_decoder_set_fatal(dec);
1015 return NULL;
1016 }
1017
1018 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT_self_partial_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierPropertiesEXT * val)1019 vn_decode_VkImageDrmFormatModifierPropertiesEXT_self_partial_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
1020 {
1021 /* skip val->{sType,pNext} */
1022 /* skip val->drmFormatModifier */
1023 }
1024
1025 static inline void
vn_decode_VkImageDrmFormatModifierPropertiesEXT_partial_temp(struct vn_cs_decoder * dec,VkImageDrmFormatModifierPropertiesEXT * val)1026 vn_decode_VkImageDrmFormatModifierPropertiesEXT_partial_temp(struct vn_cs_decoder *dec, VkImageDrmFormatModifierPropertiesEXT *val)
1027 {
1028 VkStructureType stype;
1029 vn_decode_VkStructureType(dec, &stype);
1030 if (stype != VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT)
1031 vn_cs_decoder_set_fatal(dec);
1032
1033 val->sType = stype;
1034 val->pNext = vn_decode_VkImageDrmFormatModifierPropertiesEXT_pnext_partial_temp(dec);
1035 vn_decode_VkImageDrmFormatModifierPropertiesEXT_self_partial_temp(dec, val);
1036 }
1037
vn_decode_vkGetImageMemoryRequirements_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageMemoryRequirements * args)1038 static inline void vn_decode_vkGetImageMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageMemoryRequirements *args)
1039 {
1040 vn_decode_VkDevice_lookup(dec, &args->device);
1041 vn_decode_VkImage_lookup(dec, &args->image);
1042 if (vn_decode_simple_pointer(dec)) {
1043 args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
1044 if (!args->pMemoryRequirements) return;
1045 vn_decode_VkMemoryRequirements_partial_temp(dec, args->pMemoryRequirements);
1046 } else {
1047 args->pMemoryRequirements = NULL;
1048 vn_cs_decoder_set_fatal(dec);
1049 }
1050 }
1051
vn_replace_vkGetImageMemoryRequirements_args_handle(struct vn_command_vkGetImageMemoryRequirements * args)1052 static inline void vn_replace_vkGetImageMemoryRequirements_args_handle(struct vn_command_vkGetImageMemoryRequirements *args)
1053 {
1054 vn_replace_VkDevice_handle(&args->device);
1055 vn_replace_VkImage_handle(&args->image);
1056 /* skip args->pMemoryRequirements */
1057 }
1058
vn_encode_vkGetImageMemoryRequirements_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageMemoryRequirements * args)1059 static inline void vn_encode_vkGetImageMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageMemoryRequirements *args)
1060 {
1061 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageMemoryRequirements_EXT});
1062
1063 /* skip args->device */
1064 /* skip args->image */
1065 if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
1066 vn_encode_VkMemoryRequirements(enc, args->pMemoryRequirements);
1067 }
1068
vn_decode_vkBindImageMemory_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkBindImageMemory * args)1069 static inline void vn_decode_vkBindImageMemory_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkBindImageMemory *args)
1070 {
1071 vn_decode_VkDevice_lookup(dec, &args->device);
1072 vn_decode_VkImage_lookup(dec, &args->image);
1073 vn_decode_VkDeviceMemory_lookup(dec, &args->memory);
1074 vn_decode_VkDeviceSize(dec, &args->memoryOffset);
1075 }
1076
vn_replace_vkBindImageMemory_args_handle(struct vn_command_vkBindImageMemory * args)1077 static inline void vn_replace_vkBindImageMemory_args_handle(struct vn_command_vkBindImageMemory *args)
1078 {
1079 vn_replace_VkDevice_handle(&args->device);
1080 vn_replace_VkImage_handle(&args->image);
1081 vn_replace_VkDeviceMemory_handle(&args->memory);
1082 /* skip args->memoryOffset */
1083 }
1084
vn_encode_vkBindImageMemory_reply(struct vn_cs_encoder * enc,const struct vn_command_vkBindImageMemory * args)1085 static inline void vn_encode_vkBindImageMemory_reply(struct vn_cs_encoder *enc, const struct vn_command_vkBindImageMemory *args)
1086 {
1087 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkBindImageMemory_EXT});
1088
1089 vn_encode_VkResult(enc, &args->ret);
1090 /* skip args->device */
1091 /* skip args->image */
1092 /* skip args->memory */
1093 /* skip args->memoryOffset */
1094 }
1095
vn_decode_vkGetImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageSparseMemoryRequirements * args)1096 static inline void vn_decode_vkGetImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageSparseMemoryRequirements *args)
1097 {
1098 vn_decode_VkDevice_lookup(dec, &args->device);
1099 vn_decode_VkImage_lookup(dec, &args->image);
1100 if (vn_decode_simple_pointer(dec)) {
1101 args->pSparseMemoryRequirementCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirementCount));
1102 if (!args->pSparseMemoryRequirementCount) return;
1103 vn_decode_uint32_t(dec, args->pSparseMemoryRequirementCount);
1104 } else {
1105 args->pSparseMemoryRequirementCount = NULL;
1106 vn_cs_decoder_set_fatal(dec);
1107 }
1108 if (vn_peek_array_size(dec)) {
1109 const uint32_t iter_count = vn_decode_array_size(dec, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1110 args->pSparseMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirements) * iter_count);
1111 if (!args->pSparseMemoryRequirements) return;
1112 for (uint32_t i = 0; i < iter_count; i++)
1113 vn_decode_VkSparseImageMemoryRequirements_partial_temp(dec, &args->pSparseMemoryRequirements[i]);
1114 } else {
1115 vn_decode_array_size_unchecked(dec);
1116 args->pSparseMemoryRequirements = NULL;
1117 }
1118 }
1119
vn_replace_vkGetImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements * args)1120 static inline void vn_replace_vkGetImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements *args)
1121 {
1122 vn_replace_VkDevice_handle(&args->device);
1123 vn_replace_VkImage_handle(&args->image);
1124 /* skip args->pSparseMemoryRequirementCount */
1125 /* skip args->pSparseMemoryRequirements */
1126 }
1127
vn_encode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageSparseMemoryRequirements * args)1128 static inline void vn_encode_vkGetImageSparseMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageSparseMemoryRequirements *args)
1129 {
1130 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements_EXT});
1131
1132 /* skip args->device */
1133 /* skip args->image */
1134 if (vn_encode_simple_pointer(enc, args->pSparseMemoryRequirementCount))
1135 vn_encode_uint32_t(enc, args->pSparseMemoryRequirementCount);
1136 if (args->pSparseMemoryRequirements) {
1137 vn_encode_array_size(enc, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1138 for (uint32_t i = 0; i < (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0); i++)
1139 vn_encode_VkSparseImageMemoryRequirements(enc, &args->pSparseMemoryRequirements[i]);
1140 } else {
1141 vn_encode_array_size(enc, 0);
1142 }
1143 }
1144
vn_decode_vkCreateImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkCreateImage * args)1145 static inline void vn_decode_vkCreateImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreateImage *args)
1146 {
1147 vn_decode_VkDevice_lookup(dec, &args->device);
1148 if (vn_decode_simple_pointer(dec)) {
1149 args->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfo));
1150 if (!args->pCreateInfo) return;
1151 vn_decode_VkImageCreateInfo_temp(dec, (VkImageCreateInfo *)args->pCreateInfo);
1152 } else {
1153 args->pCreateInfo = NULL;
1154 vn_cs_decoder_set_fatal(dec);
1155 }
1156 if (vn_decode_simple_pointer(dec)) {
1157 vn_cs_decoder_set_fatal(dec);
1158 } else {
1159 args->pAllocator = NULL;
1160 }
1161 if (vn_decode_simple_pointer(dec)) {
1162 args->pImage = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pImage));
1163 if (!args->pImage) return;
1164 vn_decode_VkImage(dec, args->pImage);
1165 } else {
1166 args->pImage = NULL;
1167 vn_cs_decoder_set_fatal(dec);
1168 }
1169 }
1170
vn_replace_vkCreateImage_args_handle(struct vn_command_vkCreateImage * args)1171 static inline void vn_replace_vkCreateImage_args_handle(struct vn_command_vkCreateImage *args)
1172 {
1173 vn_replace_VkDevice_handle(&args->device);
1174 if (args->pCreateInfo)
1175 vn_replace_VkImageCreateInfo_handle((VkImageCreateInfo *)args->pCreateInfo);
1176 /* skip args->pAllocator */
1177 /* skip args->pImage */
1178 }
1179
vn_encode_vkCreateImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkCreateImage * args)1180 static inline void vn_encode_vkCreateImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreateImage *args)
1181 {
1182 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreateImage_EXT});
1183
1184 vn_encode_VkResult(enc, &args->ret);
1185 /* skip args->device */
1186 /* skip args->pCreateInfo */
1187 /* skip args->pAllocator */
1188 if (vn_encode_simple_pointer(enc, args->pImage))
1189 vn_encode_VkImage(enc, args->pImage);
1190 }
1191
vn_decode_vkDestroyImage_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkDestroyImage * args)1192 static inline void vn_decode_vkDestroyImage_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDestroyImage *args)
1193 {
1194 vn_decode_VkDevice_lookup(dec, &args->device);
1195 vn_decode_VkImage_lookup(dec, &args->image);
1196 if (vn_decode_simple_pointer(dec)) {
1197 vn_cs_decoder_set_fatal(dec);
1198 } else {
1199 args->pAllocator = NULL;
1200 }
1201 }
1202
vn_replace_vkDestroyImage_args_handle(struct vn_command_vkDestroyImage * args)1203 static inline void vn_replace_vkDestroyImage_args_handle(struct vn_command_vkDestroyImage *args)
1204 {
1205 vn_replace_VkDevice_handle(&args->device);
1206 vn_replace_VkImage_handle(&args->image);
1207 /* skip args->pAllocator */
1208 }
1209
vn_encode_vkDestroyImage_reply(struct vn_cs_encoder * enc,const struct vn_command_vkDestroyImage * args)1210 static inline void vn_encode_vkDestroyImage_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDestroyImage *args)
1211 {
1212 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDestroyImage_EXT});
1213
1214 /* skip args->device */
1215 /* skip args->image */
1216 /* skip args->pAllocator */
1217 }
1218
vn_decode_vkGetImageSubresourceLayout_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageSubresourceLayout * args)1219 static inline void vn_decode_vkGetImageSubresourceLayout_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageSubresourceLayout *args)
1220 {
1221 vn_decode_VkDevice_lookup(dec, &args->device);
1222 vn_decode_VkImage_lookup(dec, &args->image);
1223 if (vn_decode_simple_pointer(dec)) {
1224 args->pSubresource = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubresource));
1225 if (!args->pSubresource) return;
1226 vn_decode_VkImageSubresource_temp(dec, (VkImageSubresource *)args->pSubresource);
1227 } else {
1228 args->pSubresource = NULL;
1229 vn_cs_decoder_set_fatal(dec);
1230 }
1231 if (vn_decode_simple_pointer(dec)) {
1232 args->pLayout = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pLayout));
1233 if (!args->pLayout) return;
1234 vn_decode_VkSubresourceLayout_partial_temp(dec, args->pLayout);
1235 } else {
1236 args->pLayout = NULL;
1237 vn_cs_decoder_set_fatal(dec);
1238 }
1239 }
1240
vn_replace_vkGetImageSubresourceLayout_args_handle(struct vn_command_vkGetImageSubresourceLayout * args)1241 static inline void vn_replace_vkGetImageSubresourceLayout_args_handle(struct vn_command_vkGetImageSubresourceLayout *args)
1242 {
1243 vn_replace_VkDevice_handle(&args->device);
1244 vn_replace_VkImage_handle(&args->image);
1245 if (args->pSubresource)
1246 vn_replace_VkImageSubresource_handle((VkImageSubresource *)args->pSubresource);
1247 /* skip args->pLayout */
1248 }
1249
vn_encode_vkGetImageSubresourceLayout_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageSubresourceLayout * args)1250 static inline void vn_encode_vkGetImageSubresourceLayout_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageSubresourceLayout *args)
1251 {
1252 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageSubresourceLayout_EXT});
1253
1254 /* skip args->device */
1255 /* skip args->image */
1256 /* skip args->pSubresource */
1257 if (vn_encode_simple_pointer(enc, args->pLayout))
1258 vn_encode_VkSubresourceLayout(enc, args->pLayout);
1259 }
1260
vn_decode_vkBindImageMemory2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkBindImageMemory2 * args)1261 static inline void vn_decode_vkBindImageMemory2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkBindImageMemory2 *args)
1262 {
1263 vn_decode_VkDevice_lookup(dec, &args->device);
1264 vn_decode_uint32_t(dec, &args->bindInfoCount);
1265 if (vn_peek_array_size(dec)) {
1266 const uint32_t iter_count = vn_decode_array_size(dec, args->bindInfoCount);
1267 args->pBindInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pBindInfos) * iter_count);
1268 if (!args->pBindInfos) return;
1269 for (uint32_t i = 0; i < iter_count; i++)
1270 vn_decode_VkBindImageMemoryInfo_temp(dec, &((VkBindImageMemoryInfo *)args->pBindInfos)[i]);
1271 } else {
1272 vn_decode_array_size(dec, args->bindInfoCount);
1273 args->pBindInfos = NULL;
1274 }
1275 }
1276
vn_replace_vkBindImageMemory2_args_handle(struct vn_command_vkBindImageMemory2 * args)1277 static inline void vn_replace_vkBindImageMemory2_args_handle(struct vn_command_vkBindImageMemory2 *args)
1278 {
1279 vn_replace_VkDevice_handle(&args->device);
1280 /* skip args->bindInfoCount */
1281 if (args->pBindInfos) {
1282 for (uint32_t i = 0; i < args->bindInfoCount; i++)
1283 vn_replace_VkBindImageMemoryInfo_handle(&((VkBindImageMemoryInfo *)args->pBindInfos)[i]);
1284 }
1285 }
1286
vn_encode_vkBindImageMemory2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkBindImageMemory2 * args)1287 static inline void vn_encode_vkBindImageMemory2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkBindImageMemory2 *args)
1288 {
1289 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkBindImageMemory2_EXT});
1290
1291 vn_encode_VkResult(enc, &args->ret);
1292 /* skip args->device */
1293 /* skip args->bindInfoCount */
1294 /* skip args->pBindInfos */
1295 }
1296
vn_decode_vkGetImageMemoryRequirements2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageMemoryRequirements2 * args)1297 static inline void vn_decode_vkGetImageMemoryRequirements2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageMemoryRequirements2 *args)
1298 {
1299 vn_decode_VkDevice_lookup(dec, &args->device);
1300 if (vn_decode_simple_pointer(dec)) {
1301 args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
1302 if (!args->pInfo) return;
1303 vn_decode_VkImageMemoryRequirementsInfo2_temp(dec, (VkImageMemoryRequirementsInfo2 *)args->pInfo);
1304 } else {
1305 args->pInfo = NULL;
1306 vn_cs_decoder_set_fatal(dec);
1307 }
1308 if (vn_decode_simple_pointer(dec)) {
1309 args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
1310 if (!args->pMemoryRequirements) return;
1311 vn_decode_VkMemoryRequirements2_partial_temp(dec, args->pMemoryRequirements);
1312 } else {
1313 args->pMemoryRequirements = NULL;
1314 vn_cs_decoder_set_fatal(dec);
1315 }
1316 }
1317
vn_replace_vkGetImageMemoryRequirements2_args_handle(struct vn_command_vkGetImageMemoryRequirements2 * args)1318 static inline void vn_replace_vkGetImageMemoryRequirements2_args_handle(struct vn_command_vkGetImageMemoryRequirements2 *args)
1319 {
1320 vn_replace_VkDevice_handle(&args->device);
1321 if (args->pInfo)
1322 vn_replace_VkImageMemoryRequirementsInfo2_handle((VkImageMemoryRequirementsInfo2 *)args->pInfo);
1323 /* skip args->pMemoryRequirements */
1324 }
1325
vn_encode_vkGetImageMemoryRequirements2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageMemoryRequirements2 * args)1326 static inline void vn_encode_vkGetImageMemoryRequirements2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageMemoryRequirements2 *args)
1327 {
1328 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT});
1329
1330 /* skip args->device */
1331 /* skip args->pInfo */
1332 if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
1333 vn_encode_VkMemoryRequirements2(enc, args->pMemoryRequirements);
1334 }
1335
vn_decode_vkGetImageSparseMemoryRequirements2_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageSparseMemoryRequirements2 * args)1336 static inline void vn_decode_vkGetImageSparseMemoryRequirements2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageSparseMemoryRequirements2 *args)
1337 {
1338 vn_decode_VkDevice_lookup(dec, &args->device);
1339 if (vn_decode_simple_pointer(dec)) {
1340 args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
1341 if (!args->pInfo) return;
1342 vn_decode_VkImageSparseMemoryRequirementsInfo2_temp(dec, (VkImageSparseMemoryRequirementsInfo2 *)args->pInfo);
1343 } else {
1344 args->pInfo = NULL;
1345 vn_cs_decoder_set_fatal(dec);
1346 }
1347 if (vn_decode_simple_pointer(dec)) {
1348 args->pSparseMemoryRequirementCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirementCount));
1349 if (!args->pSparseMemoryRequirementCount) return;
1350 vn_decode_uint32_t(dec, args->pSparseMemoryRequirementCount);
1351 } else {
1352 args->pSparseMemoryRequirementCount = NULL;
1353 vn_cs_decoder_set_fatal(dec);
1354 }
1355 if (vn_peek_array_size(dec)) {
1356 const uint32_t iter_count = vn_decode_array_size(dec, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1357 args->pSparseMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirements) * iter_count);
1358 if (!args->pSparseMemoryRequirements) return;
1359 for (uint32_t i = 0; i < iter_count; i++)
1360 vn_decode_VkSparseImageMemoryRequirements2_partial_temp(dec, &args->pSparseMemoryRequirements[i]);
1361 } else {
1362 vn_decode_array_size_unchecked(dec);
1363 args->pSparseMemoryRequirements = NULL;
1364 }
1365 }
1366
vn_replace_vkGetImageSparseMemoryRequirements2_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements2 * args)1367 static inline void vn_replace_vkGetImageSparseMemoryRequirements2_args_handle(struct vn_command_vkGetImageSparseMemoryRequirements2 *args)
1368 {
1369 vn_replace_VkDevice_handle(&args->device);
1370 if (args->pInfo)
1371 vn_replace_VkImageSparseMemoryRequirementsInfo2_handle((VkImageSparseMemoryRequirementsInfo2 *)args->pInfo);
1372 /* skip args->pSparseMemoryRequirementCount */
1373 /* skip args->pSparseMemoryRequirements */
1374 }
1375
vn_encode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageSparseMemoryRequirements2 * args)1376 static inline void vn_encode_vkGetImageSparseMemoryRequirements2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageSparseMemoryRequirements2 *args)
1377 {
1378 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT});
1379
1380 /* skip args->device */
1381 /* skip args->pInfo */
1382 if (vn_encode_simple_pointer(enc, args->pSparseMemoryRequirementCount))
1383 vn_encode_uint32_t(enc, args->pSparseMemoryRequirementCount);
1384 if (args->pSparseMemoryRequirements) {
1385 vn_encode_array_size(enc, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1386 for (uint32_t i = 0; i < (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0); i++)
1387 vn_encode_VkSparseImageMemoryRequirements2(enc, &args->pSparseMemoryRequirements[i]);
1388 } else {
1389 vn_encode_array_size(enc, 0);
1390 }
1391 }
1392
vn_decode_vkGetDeviceImageMemoryRequirements_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetDeviceImageMemoryRequirements * args)1393 static inline void vn_decode_vkGetDeviceImageMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceImageMemoryRequirements *args)
1394 {
1395 vn_decode_VkDevice_lookup(dec, &args->device);
1396 if (vn_decode_simple_pointer(dec)) {
1397 args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
1398 if (!args->pInfo) return;
1399 vn_decode_VkDeviceImageMemoryRequirements_temp(dec, (VkDeviceImageMemoryRequirements *)args->pInfo);
1400 } else {
1401 args->pInfo = NULL;
1402 vn_cs_decoder_set_fatal(dec);
1403 }
1404 if (vn_decode_simple_pointer(dec)) {
1405 args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
1406 if (!args->pMemoryRequirements) return;
1407 vn_decode_VkMemoryRequirements2_partial_temp(dec, args->pMemoryRequirements);
1408 } else {
1409 args->pMemoryRequirements = NULL;
1410 vn_cs_decoder_set_fatal(dec);
1411 }
1412 }
1413
vn_replace_vkGetDeviceImageMemoryRequirements_args_handle(struct vn_command_vkGetDeviceImageMemoryRequirements * args)1414 static inline void vn_replace_vkGetDeviceImageMemoryRequirements_args_handle(struct vn_command_vkGetDeviceImageMemoryRequirements *args)
1415 {
1416 vn_replace_VkDevice_handle(&args->device);
1417 if (args->pInfo)
1418 vn_replace_VkDeviceImageMemoryRequirements_handle((VkDeviceImageMemoryRequirements *)args->pInfo);
1419 /* skip args->pMemoryRequirements */
1420 }
1421
vn_encode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetDeviceImageMemoryRequirements * args)1422 static inline void vn_encode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceImageMemoryRequirements *args)
1423 {
1424 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT});
1425
1426 /* skip args->device */
1427 /* skip args->pInfo */
1428 if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
1429 vn_encode_VkMemoryRequirements2(enc, args->pMemoryRequirements);
1430 }
1431
vn_decode_vkGetDeviceImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetDeviceImageSparseMemoryRequirements * args)1432 static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args)
1433 {
1434 vn_decode_VkDevice_lookup(dec, &args->device);
1435 if (vn_decode_simple_pointer(dec)) {
1436 args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
1437 if (!args->pInfo) return;
1438 vn_decode_VkDeviceImageMemoryRequirements_temp(dec, (VkDeviceImageMemoryRequirements *)args->pInfo);
1439 } else {
1440 args->pInfo = NULL;
1441 vn_cs_decoder_set_fatal(dec);
1442 }
1443 if (vn_decode_simple_pointer(dec)) {
1444 args->pSparseMemoryRequirementCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirementCount));
1445 if (!args->pSparseMemoryRequirementCount) return;
1446 vn_decode_uint32_t(dec, args->pSparseMemoryRequirementCount);
1447 } else {
1448 args->pSparseMemoryRequirementCount = NULL;
1449 vn_cs_decoder_set_fatal(dec);
1450 }
1451 if (vn_peek_array_size(dec)) {
1452 const uint32_t iter_count = vn_decode_array_size(dec, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1453 args->pSparseMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirements) * iter_count);
1454 if (!args->pSparseMemoryRequirements) return;
1455 for (uint32_t i = 0; i < iter_count; i++)
1456 vn_decode_VkSparseImageMemoryRequirements2_partial_temp(dec, &args->pSparseMemoryRequirements[i]);
1457 } else {
1458 vn_decode_array_size_unchecked(dec);
1459 args->pSparseMemoryRequirements = NULL;
1460 }
1461 }
1462
vn_replace_vkGetDeviceImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetDeviceImageSparseMemoryRequirements * args)1463 static inline void vn_replace_vkGetDeviceImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args)
1464 {
1465 vn_replace_VkDevice_handle(&args->device);
1466 if (args->pInfo)
1467 vn_replace_VkDeviceImageMemoryRequirements_handle((VkDeviceImageMemoryRequirements *)args->pInfo);
1468 /* skip args->pSparseMemoryRequirementCount */
1469 /* skip args->pSparseMemoryRequirements */
1470 }
1471
vn_encode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetDeviceImageSparseMemoryRequirements * args)1472 static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args)
1473 {
1474 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT});
1475
1476 /* skip args->device */
1477 /* skip args->pInfo */
1478 if (vn_encode_simple_pointer(enc, args->pSparseMemoryRequirementCount))
1479 vn_encode_uint32_t(enc, args->pSparseMemoryRequirementCount);
1480 if (args->pSparseMemoryRequirements) {
1481 vn_encode_array_size(enc, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
1482 for (uint32_t i = 0; i < (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0); i++)
1483 vn_encode_VkSparseImageMemoryRequirements2(enc, &args->pSparseMemoryRequirements[i]);
1484 } else {
1485 vn_encode_array_size(enc, 0);
1486 }
1487 }
1488
vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(struct vn_cs_decoder * dec,struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT * args)1489 static inline void vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
1490 {
1491 vn_decode_VkDevice_lookup(dec, &args->device);
1492 vn_decode_VkImage_lookup(dec, &args->image);
1493 if (vn_decode_simple_pointer(dec)) {
1494 args->pProperties = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pProperties));
1495 if (!args->pProperties) return;
1496 vn_decode_VkImageDrmFormatModifierPropertiesEXT_partial_temp(dec, args->pProperties);
1497 } else {
1498 args->pProperties = NULL;
1499 vn_cs_decoder_set_fatal(dec);
1500 }
1501 }
1502
vn_replace_vkGetImageDrmFormatModifierPropertiesEXT_args_handle(struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT * args)1503 static inline void vn_replace_vkGetImageDrmFormatModifierPropertiesEXT_args_handle(struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
1504 {
1505 vn_replace_VkDevice_handle(&args->device);
1506 vn_replace_VkImage_handle(&args->image);
1507 /* skip args->pProperties */
1508 }
1509
vn_encode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_encoder * enc,const struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT * args)1510 static inline void vn_encode_vkGetImageDrmFormatModifierPropertiesEXT_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
1511 {
1512 vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT});
1513
1514 vn_encode_VkResult(enc, &args->ret);
1515 /* skip args->device */
1516 /* skip args->image */
1517 if (vn_encode_simple_pointer(enc, args->pProperties))
1518 vn_encode_VkImageDrmFormatModifierPropertiesEXT(enc, args->pProperties);
1519 }
1520
vn_dispatch_vkGetImageMemoryRequirements(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1521 static inline void vn_dispatch_vkGetImageMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1522 {
1523 struct vn_command_vkGetImageMemoryRequirements args;
1524
1525 if (!ctx->dispatch_vkGetImageMemoryRequirements) {
1526 vn_cs_decoder_set_fatal(ctx->decoder);
1527 return;
1528 }
1529
1530 vn_decode_vkGetImageMemoryRequirements_args_temp(ctx->decoder, &args);
1531 if (!args.device) {
1532 vn_cs_decoder_set_fatal(ctx->decoder);
1533 return;
1534 }
1535
1536 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1537 ctx->dispatch_vkGetImageMemoryRequirements(ctx, &args);
1538
1539
1540 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1541 vn_encode_vkGetImageMemoryRequirements_reply(ctx->encoder, &args);
1542
1543 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1544 }
1545
vn_dispatch_vkBindImageMemory(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1546 static inline void vn_dispatch_vkBindImageMemory(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1547 {
1548 struct vn_command_vkBindImageMemory args;
1549
1550 if (!ctx->dispatch_vkBindImageMemory) {
1551 vn_cs_decoder_set_fatal(ctx->decoder);
1552 return;
1553 }
1554
1555 vn_decode_vkBindImageMemory_args_temp(ctx->decoder, &args);
1556 if (!args.device) {
1557 vn_cs_decoder_set_fatal(ctx->decoder);
1558 return;
1559 }
1560
1561 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1562 ctx->dispatch_vkBindImageMemory(ctx, &args);
1563
1564 #ifdef DEBUG
1565 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1566 vn_dispatch_debug_log(ctx, "vkBindImageMemory returned %d", args.ret);
1567 #endif
1568
1569 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1570 vn_encode_vkBindImageMemory_reply(ctx->encoder, &args);
1571
1572 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1573 }
1574
vn_dispatch_vkGetImageSparseMemoryRequirements(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1575 static inline void vn_dispatch_vkGetImageSparseMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1576 {
1577 struct vn_command_vkGetImageSparseMemoryRequirements args;
1578
1579 if (!ctx->dispatch_vkGetImageSparseMemoryRequirements) {
1580 vn_cs_decoder_set_fatal(ctx->decoder);
1581 return;
1582 }
1583
1584 vn_decode_vkGetImageSparseMemoryRequirements_args_temp(ctx->decoder, &args);
1585 if (!args.device) {
1586 vn_cs_decoder_set_fatal(ctx->decoder);
1587 return;
1588 }
1589
1590 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1591 ctx->dispatch_vkGetImageSparseMemoryRequirements(ctx, &args);
1592
1593
1594 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1595 vn_encode_vkGetImageSparseMemoryRequirements_reply(ctx->encoder, &args);
1596
1597 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1598 }
1599
vn_dispatch_vkCreateImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1600 static inline void vn_dispatch_vkCreateImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1601 {
1602 struct vn_command_vkCreateImage args;
1603
1604 if (!ctx->dispatch_vkCreateImage) {
1605 vn_cs_decoder_set_fatal(ctx->decoder);
1606 return;
1607 }
1608
1609 vn_decode_vkCreateImage_args_temp(ctx->decoder, &args);
1610 if (!args.device) {
1611 vn_cs_decoder_set_fatal(ctx->decoder);
1612 return;
1613 }
1614
1615 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1616 ctx->dispatch_vkCreateImage(ctx, &args);
1617
1618 #ifdef DEBUG
1619 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1620 vn_dispatch_debug_log(ctx, "vkCreateImage returned %d", args.ret);
1621 #endif
1622
1623 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1624 vn_encode_vkCreateImage_reply(ctx->encoder, &args);
1625
1626 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1627 }
1628
vn_dispatch_vkDestroyImage(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1629 static inline void vn_dispatch_vkDestroyImage(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1630 {
1631 struct vn_command_vkDestroyImage args;
1632
1633 if (!ctx->dispatch_vkDestroyImage) {
1634 vn_cs_decoder_set_fatal(ctx->decoder);
1635 return;
1636 }
1637
1638 vn_decode_vkDestroyImage_args_temp(ctx->decoder, &args);
1639 if (!args.device) {
1640 vn_cs_decoder_set_fatal(ctx->decoder);
1641 return;
1642 }
1643
1644 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1645 ctx->dispatch_vkDestroyImage(ctx, &args);
1646
1647
1648 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1649 vn_encode_vkDestroyImage_reply(ctx->encoder, &args);
1650
1651 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1652 }
1653
vn_dispatch_vkGetImageSubresourceLayout(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1654 static inline void vn_dispatch_vkGetImageSubresourceLayout(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1655 {
1656 struct vn_command_vkGetImageSubresourceLayout args;
1657
1658 if (!ctx->dispatch_vkGetImageSubresourceLayout) {
1659 vn_cs_decoder_set_fatal(ctx->decoder);
1660 return;
1661 }
1662
1663 vn_decode_vkGetImageSubresourceLayout_args_temp(ctx->decoder, &args);
1664 if (!args.device) {
1665 vn_cs_decoder_set_fatal(ctx->decoder);
1666 return;
1667 }
1668
1669 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1670 ctx->dispatch_vkGetImageSubresourceLayout(ctx, &args);
1671
1672
1673 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1674 vn_encode_vkGetImageSubresourceLayout_reply(ctx->encoder, &args);
1675
1676 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1677 }
1678
vn_dispatch_vkBindImageMemory2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1679 static inline void vn_dispatch_vkBindImageMemory2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1680 {
1681 struct vn_command_vkBindImageMemory2 args;
1682
1683 if (!ctx->dispatch_vkBindImageMemory2) {
1684 vn_cs_decoder_set_fatal(ctx->decoder);
1685 return;
1686 }
1687
1688 vn_decode_vkBindImageMemory2_args_temp(ctx->decoder, &args);
1689 if (!args.device) {
1690 vn_cs_decoder_set_fatal(ctx->decoder);
1691 return;
1692 }
1693
1694 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1695 ctx->dispatch_vkBindImageMemory2(ctx, &args);
1696
1697 #ifdef DEBUG
1698 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1699 vn_dispatch_debug_log(ctx, "vkBindImageMemory2 returned %d", args.ret);
1700 #endif
1701
1702 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1703 vn_encode_vkBindImageMemory2_reply(ctx->encoder, &args);
1704
1705 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1706 }
1707
vn_dispatch_vkGetImageMemoryRequirements2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1708 static inline void vn_dispatch_vkGetImageMemoryRequirements2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1709 {
1710 struct vn_command_vkGetImageMemoryRequirements2 args;
1711
1712 if (!ctx->dispatch_vkGetImageMemoryRequirements2) {
1713 vn_cs_decoder_set_fatal(ctx->decoder);
1714 return;
1715 }
1716
1717 vn_decode_vkGetImageMemoryRequirements2_args_temp(ctx->decoder, &args);
1718 if (!args.device) {
1719 vn_cs_decoder_set_fatal(ctx->decoder);
1720 return;
1721 }
1722
1723 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1724 ctx->dispatch_vkGetImageMemoryRequirements2(ctx, &args);
1725
1726
1727 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1728 vn_encode_vkGetImageMemoryRequirements2_reply(ctx->encoder, &args);
1729
1730 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1731 }
1732
vn_dispatch_vkGetImageSparseMemoryRequirements2(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1733 static inline void vn_dispatch_vkGetImageSparseMemoryRequirements2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1734 {
1735 struct vn_command_vkGetImageSparseMemoryRequirements2 args;
1736
1737 if (!ctx->dispatch_vkGetImageSparseMemoryRequirements2) {
1738 vn_cs_decoder_set_fatal(ctx->decoder);
1739 return;
1740 }
1741
1742 vn_decode_vkGetImageSparseMemoryRequirements2_args_temp(ctx->decoder, &args);
1743 if (!args.device) {
1744 vn_cs_decoder_set_fatal(ctx->decoder);
1745 return;
1746 }
1747
1748 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1749 ctx->dispatch_vkGetImageSparseMemoryRequirements2(ctx, &args);
1750
1751
1752 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1753 vn_encode_vkGetImageSparseMemoryRequirements2_reply(ctx->encoder, &args);
1754
1755 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1756 }
1757
vn_dispatch_vkGetDeviceImageMemoryRequirements(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1758 static inline void vn_dispatch_vkGetDeviceImageMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1759 {
1760 struct vn_command_vkGetDeviceImageMemoryRequirements args;
1761
1762 if (!ctx->dispatch_vkGetDeviceImageMemoryRequirements) {
1763 vn_cs_decoder_set_fatal(ctx->decoder);
1764 return;
1765 }
1766
1767 vn_decode_vkGetDeviceImageMemoryRequirements_args_temp(ctx->decoder, &args);
1768 if (!args.device) {
1769 vn_cs_decoder_set_fatal(ctx->decoder);
1770 return;
1771 }
1772
1773 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1774 ctx->dispatch_vkGetDeviceImageMemoryRequirements(ctx, &args);
1775
1776
1777 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1778 vn_encode_vkGetDeviceImageMemoryRequirements_reply(ctx->encoder, &args);
1779
1780 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1781 }
1782
vn_dispatch_vkGetDeviceImageSparseMemoryRequirements(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1783 static inline void vn_dispatch_vkGetDeviceImageSparseMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1784 {
1785 struct vn_command_vkGetDeviceImageSparseMemoryRequirements args;
1786
1787 if (!ctx->dispatch_vkGetDeviceImageSparseMemoryRequirements) {
1788 vn_cs_decoder_set_fatal(ctx->decoder);
1789 return;
1790 }
1791
1792 vn_decode_vkGetDeviceImageSparseMemoryRequirements_args_temp(ctx->decoder, &args);
1793 if (!args.device) {
1794 vn_cs_decoder_set_fatal(ctx->decoder);
1795 return;
1796 }
1797
1798 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1799 ctx->dispatch_vkGetDeviceImageSparseMemoryRequirements(ctx, &args);
1800
1801
1802 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1803 vn_encode_vkGetDeviceImageSparseMemoryRequirements_reply(ctx->encoder, &args);
1804
1805 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1806 }
1807
vn_dispatch_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_dispatch_context * ctx,VkCommandFlagsEXT flags)1808 static inline void vn_dispatch_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
1809 {
1810 struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT args;
1811
1812 if (!ctx->dispatch_vkGetImageDrmFormatModifierPropertiesEXT) {
1813 vn_cs_decoder_set_fatal(ctx->decoder);
1814 return;
1815 }
1816
1817 vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(ctx->decoder, &args);
1818 if (!args.device) {
1819 vn_cs_decoder_set_fatal(ctx->decoder);
1820 return;
1821 }
1822
1823 if (!vn_cs_decoder_get_fatal(ctx->decoder))
1824 ctx->dispatch_vkGetImageDrmFormatModifierPropertiesEXT(ctx, &args);
1825
1826 #ifdef DEBUG
1827 if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
1828 vn_dispatch_debug_log(ctx, "vkGetImageDrmFormatModifierPropertiesEXT returned %d", args.ret);
1829 #endif
1830
1831 if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
1832 vn_encode_vkGetImageDrmFormatModifierPropertiesEXT_reply(ctx->encoder, &args);
1833
1834 vn_cs_decoder_reset_temp_pool(ctx->decoder);
1835 }
1836
1837 #pragma GCC diagnostic pop
1838
1839 #endif /* VN_PROTOCOL_RENDERER_IMAGE_H */
1840