CoCalc -- vn_protocol_driver_descriptor

GitHub Repository: PojavLauncherTeam/mesa
Path: blob/21.2-virgl/src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h
⁴⁵⁶⁰ views
1
/* This file is generated by venus-protocol.  See vn_protocol_driver.h. */
2

3
/*
4
 * Copyright 2020 Google LLC
5
 * SPDX-License-Identifier: MIT
6
 */
7

8
#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H
9
#define VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H
10

11
#include "vn_device.h"
12
#include "vn_protocol_driver_structs.h"
13

14
/* struct VkDescriptorPoolSize */
15

16
static inline size_t
17
vn_sizeof_VkDescriptorPoolSize(const VkDescriptorPoolSize *val)
18
{
19
    size_t size = 0;
20
    size += vn_sizeof_VkDescriptorType(&val->type);
21
    size += vn_sizeof_uint32_t(&val->descriptorCount);
22
    return size;
23
}
24

25
static inline void
26
vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPoolSize *val)
27
{
28
    vn_encode_VkDescriptorType(enc, &val->type);
29
    vn_encode_uint32_t(enc, &val->descriptorCount);
30
}
31

32
/* struct VkDescriptorPoolCreateInfo chain */
33

34
static inline size_t
35
vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val)
36
{
37
    /* no known/supported struct */
38
    return vn_sizeof_simple_pointer(NULL);
39
}
40

41
static inline size_t
42
vn_sizeof_VkDescriptorPoolCreateInfo_self(const VkDescriptorPoolCreateInfo *val)
43
{
44
    size_t size = 0;
45
    /* skip val->{sType,pNext} */
46
    size += vn_sizeof_VkFlags(&val->flags);
47
    size += vn_sizeof_uint32_t(&val->maxSets);
48
    size += vn_sizeof_uint32_t(&val->poolSizeCount);
49
    if (val->pPoolSizes) {
50
        size += vn_sizeof_array_size(val->poolSizeCount);
51
        for (uint32_t i = 0; i < val->poolSizeCount; i++)
52
            size += vn_sizeof_VkDescriptorPoolSize(&val->pPoolSizes[i]);
53
    } else {
54
        size += vn_sizeof_array_size(0);
55
    }
56
    return size;
57
}
58

59
static inline size_t
60
vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val)
61
{
62
    size_t size = 0;
63

64
    size += vn_sizeof_VkStructureType(&val->sType);
65
    size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(val->pNext);
66
    size += vn_sizeof_VkDescriptorPoolCreateInfo_self(val);
67

68
    return size;
69
}
70

71
static inline void
72
vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
73
{
74
    /* no known/supported struct */
75
    vn_encode_simple_pointer(enc, NULL);
76
}
77

78
static inline void
79
vn_encode_VkDescriptorPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
80
{
81
    /* skip val->{sType,pNext} */
82
    vn_encode_VkFlags(enc, &val->flags);
83
    vn_encode_uint32_t(enc, &val->maxSets);
84
    vn_encode_uint32_t(enc, &val->poolSizeCount);
85
    if (val->pPoolSizes) {
86
        vn_encode_array_size(enc, val->poolSizeCount);
87
        for (uint32_t i = 0; i < val->poolSizeCount; i++)
88
            vn_encode_VkDescriptorPoolSize(enc, &val->pPoolSizes[i]);
89
    } else {
90
        vn_encode_array_size(enc, 0);
91
    }
92
}
93

94
static inline void
95
vn_encode_VkDescriptorPoolCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
96
{
97
    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO);
98
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO });
99
    vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, val->pNext);
100
    vn_encode_VkDescriptorPoolCreateInfo_self(enc, val);
101
}
102

103
static inline size_t vn_sizeof_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
104
{
105
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
106
    const VkFlags cmd_flags = 0;
107
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
108

109
    cmd_size += vn_sizeof_VkDevice(&device);
110
    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
111
    if (pCreateInfo)
112
        cmd_size += vn_sizeof_VkDescriptorPoolCreateInfo(pCreateInfo);
113
    cmd_size += vn_sizeof_simple_pointer(pAllocator);
114
    if (pAllocator)
115
        assert(false);
116
    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
117
    if (pDescriptorPool)
118
        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
119

120
    return cmd_size;
121
}
122

123
static inline void vn_encode_vkCreateDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
124
{
125
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
126

127
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
128
    vn_encode_VkFlags(enc, &cmd_flags);
129

130
    vn_encode_VkDevice(enc, &device);
131
    if (vn_encode_simple_pointer(enc, pCreateInfo))
132
        vn_encode_VkDescriptorPoolCreateInfo(enc, pCreateInfo);
133
    if (vn_encode_simple_pointer(enc, pAllocator))
134
        assert(false);
135
    if (vn_encode_simple_pointer(enc, pDescriptorPool))
136
        vn_encode_VkDescriptorPool(enc, pDescriptorPool);
137
}
138

139
static inline size_t vn_sizeof_vkCreateDescriptorPool_reply(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
140
{
141
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
142
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
143

144
    VkResult ret;
145
    cmd_size += vn_sizeof_VkResult(&ret);
146
    /* skip device */
147
    /* skip pCreateInfo */
148
    /* skip pAllocator */
149
    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
150
    if (pDescriptorPool)
151
        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
152

153
    return cmd_size;
154
}
155

156
static inline VkResult vn_decode_vkCreateDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
157
{
158
    VkCommandTypeEXT command_type;
159
    vn_decode_VkCommandTypeEXT(dec, &command_type);
160
    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT);
161

162
    VkResult ret;
163
    vn_decode_VkResult(dec, &ret);
164
    /* skip device */
165
    /* skip pCreateInfo */
166
    /* skip pAllocator */
167
    if (vn_decode_simple_pointer(dec)) {
168
        vn_decode_VkDescriptorPool(dec, pDescriptorPool);
169
    } else {
170
        pDescriptorPool = NULL;
171
    }
172

173
    return ret;
174
}
175

176
static inline size_t vn_sizeof_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
177
{
178
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
179
    const VkFlags cmd_flags = 0;
180
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
181

182
    cmd_size += vn_sizeof_VkDevice(&device);
183
    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
184
    cmd_size += vn_sizeof_simple_pointer(pAllocator);
185
    if (pAllocator)
186
        assert(false);
187

188
    return cmd_size;
189
}
190

191
static inline void vn_encode_vkDestroyDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
192
{
193
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
194

195
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
196
    vn_encode_VkFlags(enc, &cmd_flags);
197

198
    vn_encode_VkDevice(enc, &device);
199
    vn_encode_VkDescriptorPool(enc, &descriptorPool);
200
    if (vn_encode_simple_pointer(enc, pAllocator))
201
        assert(false);
202
}
203

204
static inline size_t vn_sizeof_vkDestroyDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
205
{
206
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
207
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
208

209
    /* skip device */
210
    /* skip descriptorPool */
211
    /* skip pAllocator */
212

213
    return cmd_size;
214
}
215

216
static inline void vn_decode_vkDestroyDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
217
{
218
    VkCommandTypeEXT command_type;
219
    vn_decode_VkCommandTypeEXT(dec, &command_type);
220
    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT);
221

222
    /* skip device */
223
    /* skip descriptorPool */
224
    /* skip pAllocator */
225
}
226

227
static inline size_t vn_sizeof_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
228
{
229
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
230
    const VkFlags cmd_flags = 0;
231
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
232

233
    cmd_size += vn_sizeof_VkDevice(&device);
234
    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
235
    cmd_size += vn_sizeof_VkFlags(&flags);
236

237
    return cmd_size;
238
}
239

240
static inline void vn_encode_vkResetDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
241
{
242
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
243

244
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
245
    vn_encode_VkFlags(enc, &cmd_flags);
246

247
    vn_encode_VkDevice(enc, &device);
248
    vn_encode_VkDescriptorPool(enc, &descriptorPool);
249
    vn_encode_VkFlags(enc, &flags);
250
}
251

252
static inline size_t vn_sizeof_vkResetDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
253
{
254
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
255
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
256

257
    VkResult ret;
258
    cmd_size += vn_sizeof_VkResult(&ret);
259
    /* skip device */
260
    /* skip descriptorPool */
261
    /* skip flags */
262

263
    return cmd_size;
264
}
265

266
static inline VkResult vn_decode_vkResetDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
267
{
268
    VkCommandTypeEXT command_type;
269
    vn_decode_VkCommandTypeEXT(dec, &command_type);
270
    assert(command_type == VK_COMMAND_TYPE_vkResetDescriptorPool_EXT);
271

272
    VkResult ret;
273
    vn_decode_VkResult(dec, &ret);
274
    /* skip device */
275
    /* skip descriptorPool */
276
    /* skip flags */
277

278
    return ret;
279
}
280

281
static inline void vn_submit_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, struct vn_instance_submit_command *submit)
282
{
283
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
284
    void *cmd_data = local_cmd_data;
285
    size_t cmd_size = vn_sizeof_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
286
    if (cmd_size > sizeof(local_cmd_data)) {
287
        cmd_data = malloc(cmd_size);
288
        if (!cmd_data)
289
            cmd_size = 0;
290
    }
291
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0;
292

293
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
294
    if (cmd_size) {
295
        vn_encode_vkCreateDescriptorPool(enc, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool);
296
        vn_instance_submit_command(vn_instance, submit);
297
        if (cmd_data != local_cmd_data)
298
            free(cmd_data);
299
    }
300
}
301

302
static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
303
{
304
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
305
    void *cmd_data = local_cmd_data;
306
    size_t cmd_size = vn_sizeof_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
307
    if (cmd_size > sizeof(local_cmd_data)) {
308
        cmd_data = malloc(cmd_size);
309
        if (!cmd_data)
310
            cmd_size = 0;
311
    }
312
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0;
313

314
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
315
    if (cmd_size) {
316
        vn_encode_vkDestroyDescriptorPool(enc, cmd_flags, device, descriptorPool, pAllocator);
317
        vn_instance_submit_command(vn_instance, submit);
318
        if (cmd_data != local_cmd_data)
319
            free(cmd_data);
320
    }
321
}
322

323
static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, struct vn_instance_submit_command *submit)
324
{
325
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
326
    void *cmd_data = local_cmd_data;
327
    size_t cmd_size = vn_sizeof_vkResetDescriptorPool(device, descriptorPool, flags);
328
    if (cmd_size > sizeof(local_cmd_data)) {
329
        cmd_data = malloc(cmd_size);
330
        if (!cmd_data)
331
            cmd_size = 0;
332
    }
333
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0;
334

335
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);
336
    if (cmd_size) {
337
        vn_encode_vkResetDescriptorPool(enc, cmd_flags, device, descriptorPool, flags);
338
        vn_instance_submit_command(vn_instance, submit);
339
        if (cmd_data != local_cmd_data)
340
            free(cmd_data);
341
    }
342
}
343

344
static inline VkResult vn_call_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
345
{
346
    struct vn_instance_submit_command submit;
347
    vn_submit_vkCreateDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
348
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
349
    if (dec) {
350
        const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(dec, device, pCreateInfo, pAllocator, pDescriptorPool);
351
        vn_instance_free_command_reply(vn_instance, &submit);
352
        return ret;
353
    } else {
354
        return VK_ERROR_OUT_OF_HOST_MEMORY;
355
    }
356
}
357

358
static inline void vn_async_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
359
{
360
    struct vn_instance_submit_command submit;
361
    vn_submit_vkCreateDescriptorPool(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
362
}
363

364
static inline void vn_call_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
365
{
366
    struct vn_instance_submit_command submit;
367
    vn_submit_vkDestroyDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, pAllocator, &submit);
368
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
369
    if (dec) {
370
        vn_decode_vkDestroyDescriptorPool_reply(dec, device, descriptorPool, pAllocator);
371
        vn_instance_free_command_reply(vn_instance, &submit);
372
    }
373
}
374

375
static inline void vn_async_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
376
{
377
    struct vn_instance_submit_command submit;
378
    vn_submit_vkDestroyDescriptorPool(vn_instance, 0, device, descriptorPool, pAllocator, &submit);
379
}
380

381
static inline VkResult vn_call_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
382
{
383
    struct vn_instance_submit_command submit;
384
    vn_submit_vkResetDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, flags, &submit);
385
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);
386
    if (dec) {
387
        const VkResult ret = vn_decode_vkResetDescriptorPool_reply(dec, device, descriptorPool, flags);
388
        vn_instance_free_command_reply(vn_instance, &submit);
389
        return ret;
390
    } else {
391
        return VK_ERROR_OUT_OF_HOST_MEMORY;
392
    }
393
}
394

395
static inline void vn_async_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
396
{
397
    struct vn_instance_submit_command submit;
398
    vn_submit_vkResetDescriptorPool(vn_instance, 0, device, descriptorPool, flags, &submit);
399
}
400

401
#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H */
402

403
Product

Resources

Company
