Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
PojavLauncherTeam
GitHub Repository: PojavLauncherTeam/mesa
 Path: blob/21.2-virgl/src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h
4560 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_BUFFER_VIEW_H

9
#define VN_PROTOCOL_DRIVER_BUFFER_VIEW_H

10


11
#include "vn_device.h"

12
#include "vn_protocol_driver_structs.h"

13


14
/* struct VkBufferViewCreateInfo chain */

15


16
static inline size_t

17
vn_sizeof_VkBufferViewCreateInfo_pnext(const void *val)

18
{

19
    /* no known/supported struct */

20
    return vn_sizeof_simple_pointer(NULL);

21
}

22


23
static inline size_t

24
vn_sizeof_VkBufferViewCreateInfo_self(const VkBufferViewCreateInfo *val)

25
{

26
    size_t size = 0;

27
    /* skip val->{sType,pNext} */

28
    size += vn_sizeof_VkFlags(&val->flags);

29
    size += vn_sizeof_VkBuffer(&val->buffer);

30
    size += vn_sizeof_VkFormat(&val->format);

31
    size += vn_sizeof_VkDeviceSize(&val->offset);

32
    size += vn_sizeof_VkDeviceSize(&val->range);

33
    return size;

34
}

35


36
static inline size_t

37
vn_sizeof_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *val)

38
{

39
    size_t size = 0;

40


41
    size += vn_sizeof_VkStructureType(&val->sType);

42
    size += vn_sizeof_VkBufferViewCreateInfo_pnext(val->pNext);

43
    size += vn_sizeof_VkBufferViewCreateInfo_self(val);

44


45
    return size;

46
}

47


48
static inline void

49
vn_encode_VkBufferViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)

50
{

51
    /* no known/supported struct */

52
    vn_encode_simple_pointer(enc, NULL);

53
}

54


55
static inline void

56
vn_encode_VkBufferViewCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)

57
{

58
    /* skip val->{sType,pNext} */

59
    vn_encode_VkFlags(enc, &val->flags);

60
    vn_encode_VkBuffer(enc, &val->buffer);

61
    vn_encode_VkFormat(enc, &val->format);

62
    vn_encode_VkDeviceSize(enc, &val->offset);

63
    vn_encode_VkDeviceSize(enc, &val->range);

64
}

65


66
static inline void

67
vn_encode_VkBufferViewCreateInfo(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)

68
{

69
    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);

70
    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO });

71
    vn_encode_VkBufferViewCreateInfo_pnext(enc, val->pNext);

72
    vn_encode_VkBufferViewCreateInfo_self(enc, val);

73
}

74


75
static inline size_t vn_sizeof_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)

76
{

77
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;

78
    const VkFlags cmd_flags = 0;

79
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);

80


81
    cmd_size += vn_sizeof_VkDevice(&device);

82
    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);

83
    if (pCreateInfo)

84
        cmd_size += vn_sizeof_VkBufferViewCreateInfo(pCreateInfo);

85
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

86
    if (pAllocator)

87
        assert(false);

88
    cmd_size += vn_sizeof_simple_pointer(pView);

89
    if (pView)

90
        cmd_size += vn_sizeof_VkBufferView(pView);

91


92
    return cmd_size;

93
}

94


95
static inline void vn_encode_vkCreateBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)

96
{

97
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;

98


99
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

100
    vn_encode_VkFlags(enc, &cmd_flags);

101


102
    vn_encode_VkDevice(enc, &device);

103
    if (vn_encode_simple_pointer(enc, pCreateInfo))

104
        vn_encode_VkBufferViewCreateInfo(enc, pCreateInfo);

105
    if (vn_encode_simple_pointer(enc, pAllocator))

106
        assert(false);

107
    if (vn_encode_simple_pointer(enc, pView))

108
        vn_encode_VkBufferView(enc, pView);

109
}

110


111
static inline size_t vn_sizeof_vkCreateBufferView_reply(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)

112
{

113
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;

114
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

115


116
    VkResult ret;

117
    cmd_size += vn_sizeof_VkResult(&ret);

118
    /* skip device */

119
    /* skip pCreateInfo */

120
    /* skip pAllocator */

121
    cmd_size += vn_sizeof_simple_pointer(pView);

122
    if (pView)

123
        cmd_size += vn_sizeof_VkBufferView(pView);

124


125
    return cmd_size;

126
}

127


128
static inline VkResult vn_decode_vkCreateBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)

129
{

130
    VkCommandTypeEXT command_type;

131
    vn_decode_VkCommandTypeEXT(dec, &command_type);

132
    assert(command_type == VK_COMMAND_TYPE_vkCreateBufferView_EXT);

133


134
    VkResult ret;

135
    vn_decode_VkResult(dec, &ret);

136
    /* skip device */

137
    /* skip pCreateInfo */

138
    /* skip pAllocator */

139
    if (vn_decode_simple_pointer(dec)) {

140
        vn_decode_VkBufferView(dec, pView);

141
    } else {

142
        pView = NULL;

143
    }

144


145
    return ret;

146
}

147


148
static inline size_t vn_sizeof_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)

149
{

150
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;

151
    const VkFlags cmd_flags = 0;

152
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);

153


154
    cmd_size += vn_sizeof_VkDevice(&device);

155
    cmd_size += vn_sizeof_VkBufferView(&bufferView);

156
    cmd_size += vn_sizeof_simple_pointer(pAllocator);

157
    if (pAllocator)

158
        assert(false);

159


160
    return cmd_size;

161
}

162


163
static inline void vn_encode_vkDestroyBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)

164
{

165
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;

166


167
    vn_encode_VkCommandTypeEXT(enc, &cmd_type);

168
    vn_encode_VkFlags(enc, &cmd_flags);

169


170
    vn_encode_VkDevice(enc, &device);

171
    vn_encode_VkBufferView(enc, &bufferView);

172
    if (vn_encode_simple_pointer(enc, pAllocator))

173
        assert(false);

174
}

175


176
static inline size_t vn_sizeof_vkDestroyBufferView_reply(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)

177
{

178
    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;

179
    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);

180


181
    /* skip device */

182
    /* skip bufferView */

183
    /* skip pAllocator */

184


185
    return cmd_size;

186
}

187


188
static inline void vn_decode_vkDestroyBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)

189
{

190
    VkCommandTypeEXT command_type;

191
    vn_decode_VkCommandTypeEXT(dec, &command_type);

192
    assert(command_type == VK_COMMAND_TYPE_vkDestroyBufferView_EXT);

193


194
    /* skip device */

195
    /* skip bufferView */

196
    /* skip pAllocator */

197
}

198


199
static inline void vn_submit_vkCreateBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, struct vn_instance_submit_command *submit)

200
{

201
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

202
    void *cmd_data = local_cmd_data;

203
    size_t cmd_size = vn_sizeof_vkCreateBufferView(device, pCreateInfo, pAllocator, pView);

204
    if (cmd_size > sizeof(local_cmd_data)) {

205
        cmd_data = malloc(cmd_size);

206
        if (!cmd_data)

207
            cmd_size = 0;

208
    }

209
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0;

210


211
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);

212
    if (cmd_size) {

213
        vn_encode_vkCreateBufferView(enc, cmd_flags, device, pCreateInfo, pAllocator, pView);

214
        vn_instance_submit_command(vn_instance, submit);

215
        if (cmd_data != local_cmd_data)

216
            free(cmd_data);

217
    }

218
}

219


220
static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)

221
{

222
    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];

223
    void *cmd_data = local_cmd_data;

224
    size_t cmd_size = vn_sizeof_vkDestroyBufferView(device, bufferView, pAllocator);

225
    if (cmd_size > sizeof(local_cmd_data)) {

226
        cmd_data = malloc(cmd_size);

227
        if (!cmd_data)

228
            cmd_size = 0;

229
    }

230
    const size_t reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0;

231


232
    struct vn_cs_encoder *enc = vn_instance_submit_command_init(vn_instance, submit, cmd_data, cmd_size, reply_size);

233
    if (cmd_size) {

234
        vn_encode_vkDestroyBufferView(enc, cmd_flags, device, bufferView, pAllocator);

235
        vn_instance_submit_command(vn_instance, submit);

236
        if (cmd_data != local_cmd_data)

237
            free(cmd_data);

238
    }

239
}

240


241
static inline VkResult vn_call_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)

242
{

243
    struct vn_instance_submit_command submit;

244
    vn_submit_vkCreateBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);

245
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);

246
    if (dec) {

247
        const VkResult ret = vn_decode_vkCreateBufferView_reply(dec, device, pCreateInfo, pAllocator, pView);

248
        vn_instance_free_command_reply(vn_instance, &submit);

249
        return ret;

250
    } else {

251
        return VK_ERROR_OUT_OF_HOST_MEMORY;

252
    }

253
}

254


255
static inline void vn_async_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)

256
{

257
    struct vn_instance_submit_command submit;

258
    vn_submit_vkCreateBufferView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);

259
}

260


261
static inline void vn_call_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)

262
{

263
    struct vn_instance_submit_command submit;

264
    vn_submit_vkDestroyBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bufferView, pAllocator, &submit);

265
    struct vn_cs_decoder *dec = vn_instance_get_command_reply(vn_instance, &submit);

266
    if (dec) {

267
        vn_decode_vkDestroyBufferView_reply(dec, device, bufferView, pAllocator);

268
        vn_instance_free_command_reply(vn_instance, &submit);

269
    }

270
}

271


272
static inline void vn_async_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)

273
{

274
    struct vn_instance_submit_command submit;

275
    vn_submit_vkDestroyBufferView(vn_instance, 0, device, bufferView, pAllocator, &submit);

276
}

277


278
#endif /* VN_PROTOCOL_DRIVER_BUFFER_VIEW_H */

279


280