1 // Copyright (C) 2018 The Android Open Source Project
2 // Copyright (C) 2018 Google Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15
16 // Autogenerated module VkSubDecoder
17 //
18 // (impl) generated by scripts/genvk.py -registry
19 // ../../../../../hardware/google/gfxstream/codegen/vulkan/vulkan-docs-next/xml/vk.xml
20 // -registryGfxstream xml/vk_gfxstream.xml cereal -o
21 // ../../../../../hardware/google/gfxstream/host/vulkan/cereal
22 //
23 // Please do not modify directly;
24 // re-run mesa3d/src/gfxstream/codegen/generate-gfxstream-vulkan.sh,
25 // or directly from Python by defining:
26 // VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
27 // VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
28 // CEREAL_OUTPUT_DIR: Where to put the generated sources.
29 //
30 // python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
31 // $CEREAL_OUTPUT_DIR
32 //
33 #define MAX_STACK_ITEMS 16
34 #define MAX_PACKET_LENGTH (400 * 1024 * 1024) // 400MB
subDecode(VulkanMemReadingStream * readStream,VulkanDispatch * vk,void * boxed_dispatchHandle,void * dispatchHandle,VkDeviceSize dataSize,const void * pData,const VkDecoderContext & context)35 size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* boxed_dispatchHandle,
36 void* dispatchHandle, VkDeviceSize dataSize, const void* pData,
37 const VkDecoderContext& context) {
38 auto& metricsLogger = *context.metricsLogger;
39 uint32_t count = 0;
40 unsigned char* buf = (unsigned char*)pData;
41 android::base::BumpPool* pool = readStream->pool();
42 unsigned char* ptr = (unsigned char*)pData;
43 const unsigned char* const end = (const unsigned char*)buf + dataSize;
44 VkDecoderGlobalState* globalstate = VkDecoderGlobalState::get();
45 while (end - ptr >= 8) {
46 uint32_t opcode = *(uint32_t*)ptr;
47 uint32_t packetLen = *(uint32_t*)(ptr + 4);
48
49 // packetLen should be at least 8 (op code and packet length) and should not be excessively
50 // large
51 if (packetLen < 8 || packetLen > MAX_PACKET_LENGTH) {
52 WARN("Bad packet length %d detected, subdecode may fail", packetLen);
53 metricsLogger.logMetricEvent(MetricEventBadPacketLength{.len = packetLen});
54 }
55
56 if (end - ptr < packetLen) return ptr - (unsigned char*)buf;
57 readStream->setBuf((uint8_t*)(ptr + 8));
58 uint8_t* readStreamPtr = readStream->getBuf();
59 uint8_t** readStreamPtrPtr = &readStreamPtr;
60 switch (opcode) {
61 #ifdef VK_VERSION_1_0
62 case OP_vkBeginCommandBuffer: {
63 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
64 "VkSubDecoder vkBeginCommandBuffer");
65 const VkCommandBufferBeginInfo* pBeginInfo;
66 VkCommandBufferBeginInfo stack_pBeginInfo[1];
67 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
68 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
69 (VkCommandBufferBeginInfo*)(pBeginInfo),
70 readStreamPtrPtr);
71 if (pBeginInfo) {
72 transform_tohost_VkCommandBufferBeginInfo(
73 globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
74 }
75 VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
76 vkBeginCommandBuffer_VkResult_return = this->on_vkBeginCommandBuffer(
77 pool, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo, context);
78 if ((vkBeginCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
79 this->on_DeviceLost();
80 this->on_CheckOutOfMemory(vkBeginCommandBuffer_VkResult_return, opcode, context);
81 break;
82 }
83 case OP_vkEndCommandBuffer: {
84 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
85 "VkSubDecoder vkEndCommandBuffer");
86 VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
87 vkEndCommandBuffer_VkResult_return = this->on_vkEndCommandBuffer(
88 pool, (VkCommandBuffer)(boxed_dispatchHandle), context);
89 if ((vkEndCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
90 this->on_DeviceLost();
91 this->on_CheckOutOfMemory(vkEndCommandBuffer_VkResult_return, opcode, context);
92 break;
93 }
94 case OP_vkResetCommandBuffer: {
95 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
96 "VkSubDecoder vkResetCommandBuffer");
97 VkCommandBufferResetFlags flags;
98 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
99 sizeof(VkCommandBufferResetFlags));
100 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
101 VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
102 vkResetCommandBuffer_VkResult_return = this->on_vkResetCommandBuffer(
103 pool, (VkCommandBuffer)(boxed_dispatchHandle), flags);
104 if ((vkResetCommandBuffer_VkResult_return) == VK_ERROR_DEVICE_LOST)
105 this->on_DeviceLost();
106 this->on_CheckOutOfMemory(vkResetCommandBuffer_VkResult_return, opcode, context);
107 break;
108 }
109 case OP_vkCmdBindPipeline: {
110 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
111 "VkSubDecoder vkCmdBindPipeline");
112 VkPipelineBindPoint pipelineBindPoint;
113 VkPipeline pipeline;
114 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
115 sizeof(VkPipelineBindPoint));
116 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
117 uint64_t cgen_var_0;
118 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
119 *readStreamPtrPtr += 1 * 8;
120 *(VkPipeline*)&pipeline = (VkPipeline)unbox_VkPipeline((VkPipeline)(*&cgen_var_0));
121 this->on_vkCmdBindPipeline(pool, (VkCommandBuffer)(boxed_dispatchHandle),
122 pipelineBindPoint, pipeline);
123 break;
124 }
125 case OP_vkCmdSetViewport: {
126 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
127 "VkSubDecoder vkCmdSetViewport");
128 uint32_t firstViewport;
129 uint32_t viewportCount;
130 const VkViewport* pViewports;
131 VkViewport stack_pViewports[MAX_STACK_ITEMS];
132 memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
133 *readStreamPtrPtr += sizeof(uint32_t);
134 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
135 *readStreamPtrPtr += sizeof(uint32_t);
136 if (((viewportCount)) <= MAX_STACK_ITEMS) {
137 pViewports = (VkViewport*)stack_pViewports;
138 } else {
139 readStream->alloc((void**)&pViewports,
140 ((viewportCount)) * sizeof(const VkViewport));
141 }
142 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
143 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
144 (VkViewport*)(pViewports + i), readStreamPtrPtr);
145 }
146 if (pViewports) {
147 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
148 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
149 }
150 }
151 vk->vkCmdSetViewport((VkCommandBuffer)dispatchHandle, firstViewport, viewportCount,
152 pViewports);
153 break;
154 }
155 case OP_vkCmdSetScissor: {
156 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
157 "VkSubDecoder vkCmdSetScissor");
158 uint32_t firstScissor;
159 uint32_t scissorCount;
160 const VkRect2D* pScissors;
161 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
162 memcpy((uint32_t*)&firstScissor, *readStreamPtrPtr, sizeof(uint32_t));
163 *readStreamPtrPtr += sizeof(uint32_t);
164 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
165 *readStreamPtrPtr += sizeof(uint32_t);
166 if (((scissorCount)) <= MAX_STACK_ITEMS) {
167 pScissors = (VkRect2D*)stack_pScissors;
168 } else {
169 readStream->alloc((void**)&pScissors,
170 ((scissorCount)) * sizeof(const VkRect2D));
171 }
172 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
173 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
174 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
175 }
176 if (pScissors) {
177 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
178 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
179 }
180 }
181 vk->vkCmdSetScissor((VkCommandBuffer)dispatchHandle, firstScissor, scissorCount,
182 pScissors);
183 break;
184 }
185 case OP_vkCmdSetLineWidth: {
186 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
187 "VkSubDecoder vkCmdSetLineWidth");
188 float lineWidth;
189 memcpy((float*)&lineWidth, *readStreamPtrPtr, sizeof(float));
190 *readStreamPtrPtr += sizeof(float);
191 vk->vkCmdSetLineWidth((VkCommandBuffer)dispatchHandle, lineWidth);
192 break;
193 }
194 case OP_vkCmdSetDepthBias: {
195 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
196 "VkSubDecoder vkCmdSetDepthBias");
197 float depthBiasConstantFactor;
198 float depthBiasClamp;
199 float depthBiasSlopeFactor;
200 memcpy((float*)&depthBiasConstantFactor, *readStreamPtrPtr, sizeof(float));
201 *readStreamPtrPtr += sizeof(float);
202 memcpy((float*)&depthBiasClamp, *readStreamPtrPtr, sizeof(float));
203 *readStreamPtrPtr += sizeof(float);
204 memcpy((float*)&depthBiasSlopeFactor, *readStreamPtrPtr, sizeof(float));
205 *readStreamPtrPtr += sizeof(float);
206 vk->vkCmdSetDepthBias((VkCommandBuffer)dispatchHandle, depthBiasConstantFactor,
207 depthBiasClamp, depthBiasSlopeFactor);
208 break;
209 }
210 case OP_vkCmdSetBlendConstants: {
211 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
212 "VkSubDecoder vkCmdSetBlendConstants");
213 float blendConstants[4];
214 memcpy((float*)blendConstants, *readStreamPtrPtr, 4 * sizeof(const float));
215 *readStreamPtrPtr += 4 * sizeof(const float);
216 vk->vkCmdSetBlendConstants((VkCommandBuffer)dispatchHandle, blendConstants);
217 break;
218 }
219 case OP_vkCmdSetDepthBounds: {
220 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
221 "VkSubDecoder vkCmdSetDepthBounds");
222 float minDepthBounds;
223 float maxDepthBounds;
224 memcpy((float*)&minDepthBounds, *readStreamPtrPtr, sizeof(float));
225 *readStreamPtrPtr += sizeof(float);
226 memcpy((float*)&maxDepthBounds, *readStreamPtrPtr, sizeof(float));
227 *readStreamPtrPtr += sizeof(float);
228 vk->vkCmdSetDepthBounds((VkCommandBuffer)dispatchHandle, minDepthBounds,
229 maxDepthBounds);
230 break;
231 }
232 case OP_vkCmdSetStencilCompareMask: {
233 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
234 "VkSubDecoder vkCmdSetStencilCompareMask");
235 VkStencilFaceFlags faceMask;
236 uint32_t compareMask;
237 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
238 sizeof(VkStencilFaceFlags));
239 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
240 memcpy((uint32_t*)&compareMask, *readStreamPtrPtr, sizeof(uint32_t));
241 *readStreamPtrPtr += sizeof(uint32_t);
242 vk->vkCmdSetStencilCompareMask((VkCommandBuffer)dispatchHandle, faceMask,
243 compareMask);
244 break;
245 }
246 case OP_vkCmdSetStencilWriteMask: {
247 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
248 "VkSubDecoder vkCmdSetStencilWriteMask");
249 VkStencilFaceFlags faceMask;
250 uint32_t writeMask;
251 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
252 sizeof(VkStencilFaceFlags));
253 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
254 memcpy((uint32_t*)&writeMask, *readStreamPtrPtr, sizeof(uint32_t));
255 *readStreamPtrPtr += sizeof(uint32_t);
256 vk->vkCmdSetStencilWriteMask((VkCommandBuffer)dispatchHandle, faceMask, writeMask);
257 break;
258 }
259 case OP_vkCmdSetStencilReference: {
260 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
261 "VkSubDecoder vkCmdSetStencilReference");
262 VkStencilFaceFlags faceMask;
263 uint32_t reference;
264 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
265 sizeof(VkStencilFaceFlags));
266 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
267 memcpy((uint32_t*)&reference, *readStreamPtrPtr, sizeof(uint32_t));
268 *readStreamPtrPtr += sizeof(uint32_t);
269 vk->vkCmdSetStencilReference((VkCommandBuffer)dispatchHandle, faceMask, reference);
270 break;
271 }
272 case OP_vkCmdBindDescriptorSets: {
273 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
274 "VkSubDecoder vkCmdBindDescriptorSets");
275 VkPipelineBindPoint pipelineBindPoint;
276 VkPipelineLayout layout;
277 uint32_t firstSet;
278 uint32_t descriptorSetCount;
279 const VkDescriptorSet* pDescriptorSets;
280 VkDescriptorSet stack_pDescriptorSets[MAX_STACK_ITEMS];
281 uint32_t dynamicOffsetCount;
282 const uint32_t* pDynamicOffsets;
283 uint32_t stack_pDynamicOffsets[MAX_STACK_ITEMS];
284 memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
285 sizeof(VkPipelineBindPoint));
286 *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
287 uint64_t cgen_var_0;
288 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
289 *readStreamPtrPtr += 1 * 8;
290 *(VkPipelineLayout*)&layout =
291 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
292 memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
293 *readStreamPtrPtr += sizeof(uint32_t);
294 memcpy((uint32_t*)&descriptorSetCount, *readStreamPtrPtr, sizeof(uint32_t));
295 *readStreamPtrPtr += sizeof(uint32_t);
296 if (((descriptorSetCount)) <= MAX_STACK_ITEMS) {
297 pDescriptorSets = (VkDescriptorSet*)stack_pDescriptorSets;
298 } else {
299 readStream->alloc((void**)&pDescriptorSets,
300 ((descriptorSetCount)) * sizeof(const VkDescriptorSet));
301 }
302 if (((descriptorSetCount))) {
303 uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
304 *readStreamPtrPtr += 8 * ((descriptorSetCount));
305 for (uint32_t k = 0; k < ((descriptorSetCount)); ++k) {
306 uint64_t tmpval;
307 memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
308 *(((VkDescriptorSet*)pDescriptorSets) + k) =
309 tmpval ? (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)tmpval)
310 : VK_NULL_HANDLE;
311 }
312 }
313 memcpy((uint32_t*)&dynamicOffsetCount, *readStreamPtrPtr, sizeof(uint32_t));
314 *readStreamPtrPtr += sizeof(uint32_t);
315 if (((dynamicOffsetCount)) <= MAX_STACK_ITEMS) {
316 pDynamicOffsets = (uint32_t*)stack_pDynamicOffsets;
317 } else {
318 readStream->alloc((void**)&pDynamicOffsets,
319 ((dynamicOffsetCount)) * sizeof(const uint32_t));
320 }
321 memcpy((uint32_t*)pDynamicOffsets, *readStreamPtrPtr,
322 ((dynamicOffsetCount)) * sizeof(const uint32_t));
323 *readStreamPtrPtr += ((dynamicOffsetCount)) * sizeof(const uint32_t);
324 this->on_vkCmdBindDescriptorSets(pool, (VkCommandBuffer)(boxed_dispatchHandle),
325 pipelineBindPoint, layout, firstSet,
326 descriptorSetCount, pDescriptorSets,
327 dynamicOffsetCount, pDynamicOffsets);
328 break;
329 }
330 case OP_vkCmdBindIndexBuffer: {
331 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
332 "VkSubDecoder vkCmdBindIndexBuffer");
333 VkBuffer buffer;
334 VkDeviceSize offset;
335 VkIndexType indexType;
336 uint64_t cgen_var_0;
337 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
338 *readStreamPtrPtr += 1 * 8;
339 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
340 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
341 *readStreamPtrPtr += sizeof(VkDeviceSize);
342 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
343 *readStreamPtrPtr += sizeof(VkIndexType);
344 vk->vkCmdBindIndexBuffer((VkCommandBuffer)dispatchHandle, buffer, offset,
345 indexType);
346 break;
347 }
348 case OP_vkCmdBindVertexBuffers: {
349 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
350 "VkSubDecoder vkCmdBindVertexBuffers");
351 uint32_t firstBinding;
352 uint32_t bindingCount;
353 const VkBuffer* pBuffers;
354 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
355 const VkDeviceSize* pOffsets;
356 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
357 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
358 *readStreamPtrPtr += sizeof(uint32_t);
359 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
360 *readStreamPtrPtr += sizeof(uint32_t);
361 if (((bindingCount)) <= MAX_STACK_ITEMS) {
362 pBuffers = (VkBuffer*)stack_pBuffers;
363 } else {
364 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
365 }
366 if (((bindingCount))) {
367 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
368 *readStreamPtrPtr += 8 * ((bindingCount));
369 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
370 uint64_t tmpval;
371 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
372 *(((VkBuffer*)pBuffers) + k) =
373 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval) : VK_NULL_HANDLE;
374 }
375 }
376 if (((bindingCount)) <= MAX_STACK_ITEMS) {
377 pOffsets = (VkDeviceSize*)stack_pOffsets;
378 } else {
379 readStream->alloc((void**)&pOffsets,
380 ((bindingCount)) * sizeof(const VkDeviceSize));
381 }
382 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
383 ((bindingCount)) * sizeof(const VkDeviceSize));
384 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
385 vk->vkCmdBindVertexBuffers((VkCommandBuffer)dispatchHandle, firstBinding,
386 bindingCount, pBuffers, pOffsets);
387 break;
388 }
389 case OP_vkCmdDraw: {
390 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY, "VkSubDecoder vkCmdDraw");
391 uint32_t vertexCount;
392 uint32_t instanceCount;
393 uint32_t firstVertex;
394 uint32_t firstInstance;
395 memcpy((uint32_t*)&vertexCount, *readStreamPtrPtr, sizeof(uint32_t));
396 *readStreamPtrPtr += sizeof(uint32_t);
397 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
398 *readStreamPtrPtr += sizeof(uint32_t);
399 memcpy((uint32_t*)&firstVertex, *readStreamPtrPtr, sizeof(uint32_t));
400 *readStreamPtrPtr += sizeof(uint32_t);
401 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
402 *readStreamPtrPtr += sizeof(uint32_t);
403 vk->vkCmdDraw((VkCommandBuffer)dispatchHandle, vertexCount, instanceCount,
404 firstVertex, firstInstance);
405 break;
406 }
407 case OP_vkCmdDrawIndexed: {
408 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
409 "VkSubDecoder vkCmdDrawIndexed");
410 uint32_t indexCount;
411 uint32_t instanceCount;
412 uint32_t firstIndex;
413 int32_t vertexOffset;
414 uint32_t firstInstance;
415 memcpy((uint32_t*)&indexCount, *readStreamPtrPtr, sizeof(uint32_t));
416 *readStreamPtrPtr += sizeof(uint32_t);
417 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
418 *readStreamPtrPtr += sizeof(uint32_t);
419 memcpy((uint32_t*)&firstIndex, *readStreamPtrPtr, sizeof(uint32_t));
420 *readStreamPtrPtr += sizeof(uint32_t);
421 memcpy((int32_t*)&vertexOffset, *readStreamPtrPtr, sizeof(int32_t));
422 *readStreamPtrPtr += sizeof(int32_t);
423 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
424 *readStreamPtrPtr += sizeof(uint32_t);
425 vk->vkCmdDrawIndexed((VkCommandBuffer)dispatchHandle, indexCount, instanceCount,
426 firstIndex, vertexOffset, firstInstance);
427 break;
428 }
429 case OP_vkCmdDrawIndirect: {
430 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
431 "VkSubDecoder vkCmdDrawIndirect");
432 VkBuffer buffer;
433 VkDeviceSize offset;
434 uint32_t drawCount;
435 uint32_t stride;
436 uint64_t cgen_var_0;
437 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
438 *readStreamPtrPtr += 1 * 8;
439 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
440 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
441 *readStreamPtrPtr += sizeof(VkDeviceSize);
442 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
443 *readStreamPtrPtr += sizeof(uint32_t);
444 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
445 *readStreamPtrPtr += sizeof(uint32_t);
446 vk->vkCmdDrawIndirect((VkCommandBuffer)dispatchHandle, buffer, offset, drawCount,
447 stride);
448 break;
449 }
450 case OP_vkCmdDrawIndexedIndirect: {
451 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
452 "VkSubDecoder vkCmdDrawIndexedIndirect");
453 VkBuffer buffer;
454 VkDeviceSize offset;
455 uint32_t drawCount;
456 uint32_t stride;
457 uint64_t cgen_var_0;
458 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
459 *readStreamPtrPtr += 1 * 8;
460 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
461 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
462 *readStreamPtrPtr += sizeof(VkDeviceSize);
463 memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
464 *readStreamPtrPtr += sizeof(uint32_t);
465 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
466 *readStreamPtrPtr += sizeof(uint32_t);
467 vk->vkCmdDrawIndexedIndirect((VkCommandBuffer)dispatchHandle, buffer, offset,
468 drawCount, stride);
469 break;
470 }
471 case OP_vkCmdDispatch: {
472 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
473 "VkSubDecoder vkCmdDispatch");
474 uint32_t groupCountX;
475 uint32_t groupCountY;
476 uint32_t groupCountZ;
477 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
478 *readStreamPtrPtr += sizeof(uint32_t);
479 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
480 *readStreamPtrPtr += sizeof(uint32_t);
481 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
482 *readStreamPtrPtr += sizeof(uint32_t);
483 vk->vkCmdDispatch((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
484 groupCountZ);
485 break;
486 }
487 case OP_vkCmdDispatchIndirect: {
488 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
489 "VkSubDecoder vkCmdDispatchIndirect");
490 VkBuffer buffer;
491 VkDeviceSize offset;
492 uint64_t cgen_var_0;
493 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
494 *readStreamPtrPtr += 1 * 8;
495 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
496 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
497 *readStreamPtrPtr += sizeof(VkDeviceSize);
498 vk->vkCmdDispatchIndirect((VkCommandBuffer)dispatchHandle, buffer, offset);
499 break;
500 }
501 case OP_vkCmdCopyBuffer: {
502 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
503 "VkSubDecoder vkCmdCopyBuffer");
504 VkBuffer srcBuffer;
505 VkBuffer dstBuffer;
506 uint32_t regionCount;
507 const VkBufferCopy* pRegions;
508 VkBufferCopy stack_pRegions[MAX_STACK_ITEMS];
509 uint64_t cgen_var_0;
510 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
511 *readStreamPtrPtr += 1 * 8;
512 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
513 uint64_t cgen_var_1;
514 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
515 *readStreamPtrPtr += 1 * 8;
516 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
517 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
518 *readStreamPtrPtr += sizeof(uint32_t);
519 if (((regionCount)) <= MAX_STACK_ITEMS) {
520 pRegions = (VkBufferCopy*)stack_pRegions;
521 } else {
522 readStream->alloc((void**)&pRegions,
523 ((regionCount)) * sizeof(const VkBufferCopy));
524 }
525 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
526 reservedunmarshal_VkBufferCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
527 (VkBufferCopy*)(pRegions + i), readStreamPtrPtr);
528 }
529 if (pRegions) {
530 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
531 transform_tohost_VkBufferCopy(globalstate, (VkBufferCopy*)(pRegions + i));
532 }
533 }
534 vk->vkCmdCopyBuffer((VkCommandBuffer)dispatchHandle, srcBuffer, dstBuffer,
535 regionCount, pRegions);
536 break;
537 }
538 case OP_vkCmdCopyImage: {
539 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
540 "VkSubDecoder vkCmdCopyImage");
541 VkImage srcImage;
542 VkImageLayout srcImageLayout;
543 VkImage dstImage;
544 VkImageLayout dstImageLayout;
545 uint32_t regionCount;
546 const VkImageCopy* pRegions;
547 VkImageCopy stack_pRegions[MAX_STACK_ITEMS];
548 uint64_t cgen_var_0;
549 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
550 *readStreamPtrPtr += 1 * 8;
551 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
552 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
553 *readStreamPtrPtr += sizeof(VkImageLayout);
554 uint64_t cgen_var_1;
555 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
556 *readStreamPtrPtr += 1 * 8;
557 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
558 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
559 *readStreamPtrPtr += sizeof(VkImageLayout);
560 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
561 *readStreamPtrPtr += sizeof(uint32_t);
562 if (((regionCount)) <= MAX_STACK_ITEMS) {
563 pRegions = (VkImageCopy*)stack_pRegions;
564 } else {
565 readStream->alloc((void**)&pRegions,
566 ((regionCount)) * sizeof(const VkImageCopy));
567 }
568 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
569 reservedunmarshal_VkImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
570 (VkImageCopy*)(pRegions + i), readStreamPtrPtr);
571 }
572 if (pRegions) {
573 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
574 transform_tohost_VkImageCopy(globalstate, (VkImageCopy*)(pRegions + i));
575 }
576 }
577 this->on_vkCmdCopyImage(pool, (VkCommandBuffer)(boxed_dispatchHandle), srcImage,
578 srcImageLayout, dstImage, dstImageLayout, regionCount,
579 pRegions);
580 break;
581 }
582 case OP_vkCmdBlitImage: {
583 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
584 "VkSubDecoder vkCmdBlitImage");
585 VkImage srcImage;
586 VkImageLayout srcImageLayout;
587 VkImage dstImage;
588 VkImageLayout dstImageLayout;
589 uint32_t regionCount;
590 const VkImageBlit* pRegions;
591 VkImageBlit stack_pRegions[MAX_STACK_ITEMS];
592 VkFilter filter;
593 uint64_t cgen_var_0;
594 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
595 *readStreamPtrPtr += 1 * 8;
596 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
597 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
598 *readStreamPtrPtr += sizeof(VkImageLayout);
599 uint64_t cgen_var_1;
600 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
601 *readStreamPtrPtr += 1 * 8;
602 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
603 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
604 *readStreamPtrPtr += sizeof(VkImageLayout);
605 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
606 *readStreamPtrPtr += sizeof(uint32_t);
607 if (((regionCount)) <= MAX_STACK_ITEMS) {
608 pRegions = (VkImageBlit*)stack_pRegions;
609 } else {
610 readStream->alloc((void**)&pRegions,
611 ((regionCount)) * sizeof(const VkImageBlit));
612 }
613 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
614 reservedunmarshal_VkImageBlit(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
615 (VkImageBlit*)(pRegions + i), readStreamPtrPtr);
616 }
617 memcpy((VkFilter*)&filter, *readStreamPtrPtr, sizeof(VkFilter));
618 *readStreamPtrPtr += sizeof(VkFilter);
619 if (pRegions) {
620 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
621 transform_tohost_VkImageBlit(globalstate, (VkImageBlit*)(pRegions + i));
622 }
623 }
624 vk->vkCmdBlitImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout,
625 dstImage, dstImageLayout, regionCount, pRegions, filter);
626 break;
627 }
628 case OP_vkCmdCopyBufferToImage: {
629 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
630 "VkSubDecoder vkCmdCopyBufferToImage");
631 VkBuffer srcBuffer;
632 VkImage dstImage;
633 VkImageLayout dstImageLayout;
634 uint32_t regionCount;
635 const VkBufferImageCopy* pRegions;
636 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
637 uint64_t cgen_var_0;
638 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
639 *readStreamPtrPtr += 1 * 8;
640 *(VkBuffer*)&srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
641 uint64_t cgen_var_1;
642 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
643 *readStreamPtrPtr += 1 * 8;
644 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
645 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
646 *readStreamPtrPtr += sizeof(VkImageLayout);
647 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
648 *readStreamPtrPtr += sizeof(uint32_t);
649 if (((regionCount)) <= MAX_STACK_ITEMS) {
650 pRegions = (VkBufferImageCopy*)stack_pRegions;
651 } else {
652 readStream->alloc((void**)&pRegions,
653 ((regionCount)) * sizeof(const VkBufferImageCopy));
654 }
655 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
656 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
657 (VkBufferImageCopy*)(pRegions + i),
658 readStreamPtrPtr);
659 }
660 if (pRegions) {
661 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
662 transform_tohost_VkBufferImageCopy(globalstate,
663 (VkBufferImageCopy*)(pRegions + i));
664 }
665 }
666 this->on_vkCmdCopyBufferToImage(pool, (VkCommandBuffer)(boxed_dispatchHandle),
667 srcBuffer, dstImage, dstImageLayout, regionCount,
668 pRegions, context);
669 break;
670 }
671 case OP_vkCmdCopyImageToBuffer: {
672 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
673 "VkSubDecoder vkCmdCopyImageToBuffer");
674 VkImage srcImage;
675 VkImageLayout srcImageLayout;
676 VkBuffer dstBuffer;
677 uint32_t regionCount;
678 const VkBufferImageCopy* pRegions;
679 VkBufferImageCopy stack_pRegions[MAX_STACK_ITEMS];
680 uint64_t cgen_var_0;
681 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
682 *readStreamPtrPtr += 1 * 8;
683 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
684 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
685 *readStreamPtrPtr += sizeof(VkImageLayout);
686 uint64_t cgen_var_1;
687 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
688 *readStreamPtrPtr += 1 * 8;
689 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
690 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
691 *readStreamPtrPtr += sizeof(uint32_t);
692 if (((regionCount)) <= MAX_STACK_ITEMS) {
693 pRegions = (VkBufferImageCopy*)stack_pRegions;
694 } else {
695 readStream->alloc((void**)&pRegions,
696 ((regionCount)) * sizeof(const VkBufferImageCopy));
697 }
698 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
699 reservedunmarshal_VkBufferImageCopy(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
700 (VkBufferImageCopy*)(pRegions + i),
701 readStreamPtrPtr);
702 }
703 if (pRegions) {
704 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
705 transform_tohost_VkBufferImageCopy(globalstate,
706 (VkBufferImageCopy*)(pRegions + i));
707 }
708 }
709 this->on_vkCmdCopyImageToBuffer(pool, (VkCommandBuffer)(boxed_dispatchHandle),
710 srcImage, srcImageLayout, dstBuffer, regionCount,
711 pRegions);
712 break;
713 }
714 case OP_vkCmdUpdateBuffer: {
715 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
716 "VkSubDecoder vkCmdUpdateBuffer");
717 VkBuffer dstBuffer;
718 VkDeviceSize dstOffset;
719 VkDeviceSize dataSize;
720 const void* pData;
721 uint8_t* stack_pData[MAX_STACK_ITEMS];
722 uint64_t cgen_var_0;
723 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
724 *readStreamPtrPtr += 1 * 8;
725 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
726 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
727 *readStreamPtrPtr += sizeof(VkDeviceSize);
728 memcpy((VkDeviceSize*)&dataSize, *readStreamPtrPtr, sizeof(VkDeviceSize));
729 *readStreamPtrPtr += sizeof(VkDeviceSize);
730 if (((dataSize)) <= MAX_STACK_ITEMS) {
731 pData = (void*)stack_pData;
732 } else {
733 readStream->alloc((void**)&pData, ((dataSize)) * sizeof(const uint8_t));
734 }
735 memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(const uint8_t));
736 *readStreamPtrPtr += ((dataSize)) * sizeof(const uint8_t);
737 vk->vkCmdUpdateBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset,
738 dataSize, pData);
739 break;
740 }
741 case OP_vkCmdFillBuffer: {
742 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
743 "VkSubDecoder vkCmdFillBuffer");
744 VkBuffer dstBuffer;
745 VkDeviceSize dstOffset;
746 VkDeviceSize size;
747 uint32_t data;
748 uint64_t cgen_var_0;
749 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
750 *readStreamPtrPtr += 1 * 8;
751 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
752 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
753 *readStreamPtrPtr += sizeof(VkDeviceSize);
754 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
755 *readStreamPtrPtr += sizeof(VkDeviceSize);
756 memcpy((uint32_t*)&data, *readStreamPtrPtr, sizeof(uint32_t));
757 *readStreamPtrPtr += sizeof(uint32_t);
758 vk->vkCmdFillBuffer((VkCommandBuffer)dispatchHandle, dstBuffer, dstOffset, size,
759 data);
760 break;
761 }
762 case OP_vkCmdClearColorImage: {
763 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
764 "VkSubDecoder vkCmdClearColorImage");
765 VkImage image;
766 VkImageLayout imageLayout;
767 const VkClearColorValue* pColor;
768 VkClearColorValue stack_pColor[1];
769 uint32_t rangeCount;
770 const VkImageSubresourceRange* pRanges;
771 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
772 uint64_t cgen_var_0;
773 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
774 *readStreamPtrPtr += 1 * 8;
775 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
776 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
777 *readStreamPtrPtr += sizeof(VkImageLayout);
778 pColor = (VkClearColorValue*)stack_pColor;
779 reservedunmarshal_VkClearColorValue(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
780 (VkClearColorValue*)(pColor), readStreamPtrPtr);
781 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
782 *readStreamPtrPtr += sizeof(uint32_t);
783 if (((rangeCount)) <= MAX_STACK_ITEMS) {
784 pRanges = (VkImageSubresourceRange*)stack_pRanges;
785 } else {
786 readStream->alloc((void**)&pRanges,
787 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
788 }
789 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
790 reservedunmarshal_VkImageSubresourceRange(
791 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
792 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
793 }
794 if (pColor) {
795 transform_tohost_VkClearColorValue(globalstate, (VkClearColorValue*)(pColor));
796 }
797 if (pRanges) {
798 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
799 transform_tohost_VkImageSubresourceRange(
800 globalstate, (VkImageSubresourceRange*)(pRanges + i));
801 }
802 }
803 vk->vkCmdClearColorImage((VkCommandBuffer)dispatchHandle, image, imageLayout,
804 pColor, rangeCount, pRanges);
805 break;
806 }
807 case OP_vkCmdClearDepthStencilImage: {
808 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
809 "VkSubDecoder vkCmdClearDepthStencilImage");
810 VkImage image;
811 VkImageLayout imageLayout;
812 const VkClearDepthStencilValue* pDepthStencil;
813 VkClearDepthStencilValue stack_pDepthStencil[1];
814 uint32_t rangeCount;
815 const VkImageSubresourceRange* pRanges;
816 VkImageSubresourceRange stack_pRanges[MAX_STACK_ITEMS];
817 uint64_t cgen_var_0;
818 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
819 *readStreamPtrPtr += 1 * 8;
820 *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
821 memcpy((VkImageLayout*)&imageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
822 *readStreamPtrPtr += sizeof(VkImageLayout);
823 pDepthStencil = (VkClearDepthStencilValue*)stack_pDepthStencil;
824 reservedunmarshal_VkClearDepthStencilValue(
825 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
826 (VkClearDepthStencilValue*)(pDepthStencil), readStreamPtrPtr);
827 memcpy((uint32_t*)&rangeCount, *readStreamPtrPtr, sizeof(uint32_t));
828 *readStreamPtrPtr += sizeof(uint32_t);
829 if (((rangeCount)) <= MAX_STACK_ITEMS) {
830 pRanges = (VkImageSubresourceRange*)stack_pRanges;
831 } else {
832 readStream->alloc((void**)&pRanges,
833 ((rangeCount)) * sizeof(const VkImageSubresourceRange));
834 }
835 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
836 reservedunmarshal_VkImageSubresourceRange(
837 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
838 (VkImageSubresourceRange*)(pRanges + i), readStreamPtrPtr);
839 }
840 if (pDepthStencil) {
841 transform_tohost_VkClearDepthStencilValue(
842 globalstate, (VkClearDepthStencilValue*)(pDepthStencil));
843 }
844 if (pRanges) {
845 for (uint32_t i = 0; i < (uint32_t)((rangeCount)); ++i) {
846 transform_tohost_VkImageSubresourceRange(
847 globalstate, (VkImageSubresourceRange*)(pRanges + i));
848 }
849 }
850 vk->vkCmdClearDepthStencilImage((VkCommandBuffer)dispatchHandle, image, imageLayout,
851 pDepthStencil, rangeCount, pRanges);
852 break;
853 }
854 case OP_vkCmdClearAttachments: {
855 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
856 "VkSubDecoder vkCmdClearAttachments");
857 uint32_t attachmentCount;
858 const VkClearAttachment* pAttachments;
859 VkClearAttachment stack_pAttachments[MAX_STACK_ITEMS];
860 uint32_t rectCount;
861 const VkClearRect* pRects;
862 VkClearRect stack_pRects[MAX_STACK_ITEMS];
863 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
864 *readStreamPtrPtr += sizeof(uint32_t);
865 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
866 pAttachments = (VkClearAttachment*)stack_pAttachments;
867 } else {
868 readStream->alloc((void**)&pAttachments,
869 ((attachmentCount)) * sizeof(const VkClearAttachment));
870 }
871 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
872 reservedunmarshal_VkClearAttachment(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
873 (VkClearAttachment*)(pAttachments + i),
874 readStreamPtrPtr);
875 }
876 memcpy((uint32_t*)&rectCount, *readStreamPtrPtr, sizeof(uint32_t));
877 *readStreamPtrPtr += sizeof(uint32_t);
878 if (((rectCount)) <= MAX_STACK_ITEMS) {
879 pRects = (VkClearRect*)stack_pRects;
880 } else {
881 readStream->alloc((void**)&pRects, ((rectCount)) * sizeof(const VkClearRect));
882 }
883 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
884 reservedunmarshal_VkClearRect(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
885 (VkClearRect*)(pRects + i), readStreamPtrPtr);
886 }
887 if (pAttachments) {
888 for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
889 transform_tohost_VkClearAttachment(globalstate,
890 (VkClearAttachment*)(pAttachments + i));
891 }
892 }
893 if (pRects) {
894 for (uint32_t i = 0; i < (uint32_t)((rectCount)); ++i) {
895 transform_tohost_VkClearRect(globalstate, (VkClearRect*)(pRects + i));
896 }
897 }
898 vk->vkCmdClearAttachments((VkCommandBuffer)dispatchHandle, attachmentCount,
899 pAttachments, rectCount, pRects);
900 break;
901 }
902 case OP_vkCmdResolveImage: {
903 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
904 "VkSubDecoder vkCmdResolveImage");
905 VkImage srcImage;
906 VkImageLayout srcImageLayout;
907 VkImage dstImage;
908 VkImageLayout dstImageLayout;
909 uint32_t regionCount;
910 const VkImageResolve* pRegions;
911 VkImageResolve stack_pRegions[MAX_STACK_ITEMS];
912 uint64_t cgen_var_0;
913 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
914 *readStreamPtrPtr += 1 * 8;
915 *(VkImage*)&srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
916 memcpy((VkImageLayout*)&srcImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
917 *readStreamPtrPtr += sizeof(VkImageLayout);
918 uint64_t cgen_var_1;
919 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
920 *readStreamPtrPtr += 1 * 8;
921 *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
922 memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
923 *readStreamPtrPtr += sizeof(VkImageLayout);
924 memcpy((uint32_t*)®ionCount, *readStreamPtrPtr, sizeof(uint32_t));
925 *readStreamPtrPtr += sizeof(uint32_t);
926 if (((regionCount)) <= MAX_STACK_ITEMS) {
927 pRegions = (VkImageResolve*)stack_pRegions;
928 } else {
929 readStream->alloc((void**)&pRegions,
930 ((regionCount)) * sizeof(const VkImageResolve));
931 }
932 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
933 reservedunmarshal_VkImageResolve(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
934 (VkImageResolve*)(pRegions + i),
935 readStreamPtrPtr);
936 }
937 if (pRegions) {
938 for (uint32_t i = 0; i < (uint32_t)((regionCount)); ++i) {
939 transform_tohost_VkImageResolve(globalstate,
940 (VkImageResolve*)(pRegions + i));
941 }
942 }
943 vk->vkCmdResolveImage((VkCommandBuffer)dispatchHandle, srcImage, srcImageLayout,
944 dstImage, dstImageLayout, regionCount, pRegions);
945 break;
946 }
947 case OP_vkCmdSetEvent: {
948 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
949 "VkSubDecoder vkCmdSetEvent");
950 VkEvent event;
951 VkPipelineStageFlags stageMask;
952 uint64_t cgen_var_0;
953 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
954 *readStreamPtrPtr += 1 * 8;
955 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
956 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
957 sizeof(VkPipelineStageFlags));
958 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
959 vk->vkCmdSetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
960 break;
961 }
962 case OP_vkCmdResetEvent: {
963 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
964 "VkSubDecoder vkCmdResetEvent");
965 VkEvent event;
966 VkPipelineStageFlags stageMask;
967 uint64_t cgen_var_0;
968 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
969 *readStreamPtrPtr += 1 * 8;
970 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
971 memcpy((VkPipelineStageFlags*)&stageMask, *readStreamPtrPtr,
972 sizeof(VkPipelineStageFlags));
973 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
974 vk->vkCmdResetEvent((VkCommandBuffer)dispatchHandle, event, stageMask);
975 break;
976 }
977 case OP_vkCmdWaitEvents: {
978 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
979 "VkSubDecoder vkCmdWaitEvents");
980 uint32_t eventCount;
981 const VkEvent* pEvents;
982 VkEvent stack_pEvents[MAX_STACK_ITEMS];
983 VkPipelineStageFlags srcStageMask;
984 VkPipelineStageFlags dstStageMask;
985 uint32_t memoryBarrierCount;
986 const VkMemoryBarrier* pMemoryBarriers;
987 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
988 uint32_t bufferMemoryBarrierCount;
989 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
990 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
991 uint32_t imageMemoryBarrierCount;
992 const VkImageMemoryBarrier* pImageMemoryBarriers;
993 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
994 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
995 *readStreamPtrPtr += sizeof(uint32_t);
996 if (((eventCount)) <= MAX_STACK_ITEMS) {
997 pEvents = (VkEvent*)stack_pEvents;
998 } else {
999 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
1000 }
1001 if (((eventCount))) {
1002 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1003 *readStreamPtrPtr += 8 * ((eventCount));
1004 for (uint32_t k = 0; k < ((eventCount)); ++k) {
1005 uint64_t tmpval;
1006 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1007 *(((VkEvent*)pEvents) + k) =
1008 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
1009 }
1010 }
1011 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
1012 sizeof(VkPipelineStageFlags));
1013 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1014 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
1015 sizeof(VkPipelineStageFlags));
1016 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1017 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1018 *readStreamPtrPtr += sizeof(uint32_t);
1019 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS) {
1020 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1021 } else {
1022 readStream->alloc((void**)&pMemoryBarriers,
1023 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1024 }
1025 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1026 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1027 (VkMemoryBarrier*)(pMemoryBarriers + i),
1028 readStreamPtrPtr);
1029 }
1030 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1031 *readStreamPtrPtr += sizeof(uint32_t);
1032 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1033 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1034 } else {
1035 readStream->alloc(
1036 (void**)&pBufferMemoryBarriers,
1037 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1038 }
1039 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1040 reservedunmarshal_VkBufferMemoryBarrier(
1041 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1042 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1043 }
1044 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1045 *readStreamPtrPtr += sizeof(uint32_t);
1046 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1047 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1048 } else {
1049 readStream->alloc(
1050 (void**)&pImageMemoryBarriers,
1051 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1052 }
1053 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1054 reservedunmarshal_VkImageMemoryBarrier(
1055 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1056 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1057 }
1058 if (pMemoryBarriers) {
1059 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1060 transform_tohost_VkMemoryBarrier(globalstate,
1061 (VkMemoryBarrier*)(pMemoryBarriers + i));
1062 }
1063 }
1064 if (pBufferMemoryBarriers) {
1065 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1066 transform_tohost_VkBufferMemoryBarrier(
1067 globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1068 }
1069 }
1070 if (pImageMemoryBarriers) {
1071 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1072 transform_tohost_VkImageMemoryBarrier(
1073 globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1074 }
1075 }
1076 vk->vkCmdWaitEvents((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
1077 srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers,
1078 bufferMemoryBarrierCount, pBufferMemoryBarriers,
1079 imageMemoryBarrierCount, pImageMemoryBarriers);
1080 break;
1081 }
1082 case OP_vkCmdPipelineBarrier: {
1083 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1084 "VkSubDecoder vkCmdPipelineBarrier");
1085 VkPipelineStageFlags srcStageMask;
1086 VkPipelineStageFlags dstStageMask;
1087 VkDependencyFlags dependencyFlags;
1088 uint32_t memoryBarrierCount;
1089 const VkMemoryBarrier* pMemoryBarriers;
1090 VkMemoryBarrier stack_pMemoryBarriers[MAX_STACK_ITEMS];
1091 uint32_t bufferMemoryBarrierCount;
1092 const VkBufferMemoryBarrier* pBufferMemoryBarriers;
1093 VkBufferMemoryBarrier stack_pBufferMemoryBarriers[MAX_STACK_ITEMS];
1094 uint32_t imageMemoryBarrierCount;
1095 const VkImageMemoryBarrier* pImageMemoryBarriers;
1096 VkImageMemoryBarrier stack_pImageMemoryBarriers[MAX_STACK_ITEMS];
1097 memcpy((VkPipelineStageFlags*)&srcStageMask, *readStreamPtrPtr,
1098 sizeof(VkPipelineStageFlags));
1099 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1100 memcpy((VkPipelineStageFlags*)&dstStageMask, *readStreamPtrPtr,
1101 sizeof(VkPipelineStageFlags));
1102 *readStreamPtrPtr += sizeof(VkPipelineStageFlags);
1103 memcpy((VkDependencyFlags*)&dependencyFlags, *readStreamPtrPtr,
1104 sizeof(VkDependencyFlags));
1105 *readStreamPtrPtr += sizeof(VkDependencyFlags);
1106 memcpy((uint32_t*)&memoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1107 *readStreamPtrPtr += sizeof(uint32_t);
1108 if (((memoryBarrierCount)) <= MAX_STACK_ITEMS) {
1109 pMemoryBarriers = (VkMemoryBarrier*)stack_pMemoryBarriers;
1110 } else {
1111 readStream->alloc((void**)&pMemoryBarriers,
1112 ((memoryBarrierCount)) * sizeof(const VkMemoryBarrier));
1113 }
1114 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1115 reservedunmarshal_VkMemoryBarrier(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1116 (VkMemoryBarrier*)(pMemoryBarriers + i),
1117 readStreamPtrPtr);
1118 }
1119 memcpy((uint32_t*)&bufferMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1120 *readStreamPtrPtr += sizeof(uint32_t);
1121 if (((bufferMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1122 pBufferMemoryBarriers = (VkBufferMemoryBarrier*)stack_pBufferMemoryBarriers;
1123 } else {
1124 readStream->alloc(
1125 (void**)&pBufferMemoryBarriers,
1126 ((bufferMemoryBarrierCount)) * sizeof(const VkBufferMemoryBarrier));
1127 }
1128 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1129 reservedunmarshal_VkBufferMemoryBarrier(
1130 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1131 (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i), readStreamPtrPtr);
1132 }
1133 memcpy((uint32_t*)&imageMemoryBarrierCount, *readStreamPtrPtr, sizeof(uint32_t));
1134 *readStreamPtrPtr += sizeof(uint32_t);
1135 if (((imageMemoryBarrierCount)) <= MAX_STACK_ITEMS) {
1136 pImageMemoryBarriers = (VkImageMemoryBarrier*)stack_pImageMemoryBarriers;
1137 } else {
1138 readStream->alloc(
1139 (void**)&pImageMemoryBarriers,
1140 ((imageMemoryBarrierCount)) * sizeof(const VkImageMemoryBarrier));
1141 }
1142 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1143 reservedunmarshal_VkImageMemoryBarrier(
1144 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1145 (VkImageMemoryBarrier*)(pImageMemoryBarriers + i), readStreamPtrPtr);
1146 }
1147 if (pMemoryBarriers) {
1148 for (uint32_t i = 0; i < (uint32_t)((memoryBarrierCount)); ++i) {
1149 transform_tohost_VkMemoryBarrier(globalstate,
1150 (VkMemoryBarrier*)(pMemoryBarriers + i));
1151 }
1152 }
1153 if (pBufferMemoryBarriers) {
1154 for (uint32_t i = 0; i < (uint32_t)((bufferMemoryBarrierCount)); ++i) {
1155 transform_tohost_VkBufferMemoryBarrier(
1156 globalstate, (VkBufferMemoryBarrier*)(pBufferMemoryBarriers + i));
1157 }
1158 }
1159 if (pImageMemoryBarriers) {
1160 for (uint32_t i = 0; i < (uint32_t)((imageMemoryBarrierCount)); ++i) {
1161 transform_tohost_VkImageMemoryBarrier(
1162 globalstate, (VkImageMemoryBarrier*)(pImageMemoryBarriers + i));
1163 }
1164 }
1165 this->on_vkCmdPipelineBarrier(
1166 pool, (VkCommandBuffer)(boxed_dispatchHandle), srcStageMask, dstStageMask,
1167 dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
1168 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1169 break;
1170 }
1171 case OP_vkCmdBeginQuery: {
1172 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1173 "VkSubDecoder vkCmdBeginQuery");
1174 VkQueryPool queryPool;
1175 uint32_t query;
1176 VkQueryControlFlags flags;
1177 uint64_t cgen_var_0;
1178 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1179 *readStreamPtrPtr += 1 * 8;
1180 *(VkQueryPool*)&queryPool =
1181 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1182 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1183 *readStreamPtrPtr += sizeof(uint32_t);
1184 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
1185 sizeof(VkQueryControlFlags));
1186 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
1187 vk->vkCmdBeginQuery((VkCommandBuffer)dispatchHandle, queryPool, query, flags);
1188 break;
1189 }
1190 case OP_vkCmdEndQuery: {
1191 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1192 "VkSubDecoder vkCmdEndQuery");
1193 VkQueryPool queryPool;
1194 uint32_t query;
1195 uint64_t cgen_var_0;
1196 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1197 *readStreamPtrPtr += 1 * 8;
1198 *(VkQueryPool*)&queryPool =
1199 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1200 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1201 *readStreamPtrPtr += sizeof(uint32_t);
1202 vk->vkCmdEndQuery((VkCommandBuffer)dispatchHandle, queryPool, query);
1203 break;
1204 }
1205 case OP_vkCmdResetQueryPool: {
1206 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1207 "VkSubDecoder vkCmdResetQueryPool");
1208 VkQueryPool queryPool;
1209 uint32_t firstQuery;
1210 uint32_t queryCount;
1211 uint64_t cgen_var_0;
1212 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1213 *readStreamPtrPtr += 1 * 8;
1214 *(VkQueryPool*)&queryPool =
1215 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1216 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1217 *readStreamPtrPtr += sizeof(uint32_t);
1218 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1219 *readStreamPtrPtr += sizeof(uint32_t);
1220 vk->vkCmdResetQueryPool((VkCommandBuffer)dispatchHandle, queryPool, firstQuery,
1221 queryCount);
1222 break;
1223 }
1224 case OP_vkCmdWriteTimestamp: {
1225 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1226 "VkSubDecoder vkCmdWriteTimestamp");
1227 VkPipelineStageFlagBits pipelineStage;
1228 VkQueryPool queryPool;
1229 uint32_t query;
1230 memcpy((VkPipelineStageFlagBits*)&pipelineStage, *readStreamPtrPtr,
1231 sizeof(VkPipelineStageFlagBits));
1232 *readStreamPtrPtr += sizeof(VkPipelineStageFlagBits);
1233 uint64_t cgen_var_0;
1234 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1235 *readStreamPtrPtr += 1 * 8;
1236 *(VkQueryPool*)&queryPool =
1237 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1238 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1239 *readStreamPtrPtr += sizeof(uint32_t);
1240 vk->vkCmdWriteTimestamp((VkCommandBuffer)dispatchHandle, pipelineStage, queryPool,
1241 query);
1242 break;
1243 }
1244 case OP_vkCmdCopyQueryPoolResults: {
1245 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1246 "VkSubDecoder vkCmdCopyQueryPoolResults");
1247 VkQueryPool queryPool;
1248 uint32_t firstQuery;
1249 uint32_t queryCount;
1250 VkBuffer dstBuffer;
1251 VkDeviceSize dstOffset;
1252 VkDeviceSize stride;
1253 VkQueryResultFlags flags;
1254 uint64_t cgen_var_0;
1255 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1256 *readStreamPtrPtr += 1 * 8;
1257 *(VkQueryPool*)&queryPool =
1258 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1259 memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
1260 *readStreamPtrPtr += sizeof(uint32_t);
1261 memcpy((uint32_t*)&queryCount, *readStreamPtrPtr, sizeof(uint32_t));
1262 *readStreamPtrPtr += sizeof(uint32_t);
1263 uint64_t cgen_var_1;
1264 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1265 *readStreamPtrPtr += 1 * 8;
1266 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1267 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1268 *readStreamPtrPtr += sizeof(VkDeviceSize);
1269 memcpy((VkDeviceSize*)&stride, *readStreamPtrPtr, sizeof(VkDeviceSize));
1270 *readStreamPtrPtr += sizeof(VkDeviceSize);
1271 memcpy((VkQueryResultFlags*)&flags, *readStreamPtrPtr, sizeof(VkQueryResultFlags));
1272 *readStreamPtrPtr += sizeof(VkQueryResultFlags);
1273 this->on_vkCmdCopyQueryPoolResults(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1274 queryPool, firstQuery, queryCount, dstBuffer,
1275 dstOffset, stride, flags);
1276 break;
1277 }
1278 case OP_vkCmdPushConstants: {
1279 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1280 "VkSubDecoder vkCmdPushConstants");
1281 VkPipelineLayout layout;
1282 VkShaderStageFlags stageFlags;
1283 uint32_t offset;
1284 uint32_t size;
1285 const void* pValues;
1286 uint8_t* stack_pValues[MAX_STACK_ITEMS];
1287 uint64_t cgen_var_0;
1288 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1289 *readStreamPtrPtr += 1 * 8;
1290 *(VkPipelineLayout*)&layout =
1291 (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
1292 memcpy((VkShaderStageFlags*)&stageFlags, *readStreamPtrPtr,
1293 sizeof(VkShaderStageFlags));
1294 *readStreamPtrPtr += sizeof(VkShaderStageFlags);
1295 memcpy((uint32_t*)&offset, *readStreamPtrPtr, sizeof(uint32_t));
1296 *readStreamPtrPtr += sizeof(uint32_t);
1297 memcpy((uint32_t*)&size, *readStreamPtrPtr, sizeof(uint32_t));
1298 *readStreamPtrPtr += sizeof(uint32_t);
1299 if (((size)) <= MAX_STACK_ITEMS) {
1300 pValues = (void*)stack_pValues;
1301 } else {
1302 readStream->alloc((void**)&pValues, ((size)) * sizeof(const uint8_t));
1303 }
1304 memcpy((void*)pValues, *readStreamPtrPtr, ((size)) * sizeof(const uint8_t));
1305 *readStreamPtrPtr += ((size)) * sizeof(const uint8_t);
1306 vk->vkCmdPushConstants((VkCommandBuffer)dispatchHandle, layout, stageFlags, offset,
1307 size, pValues);
1308 break;
1309 }
1310 case OP_vkCmdBeginRenderPass: {
1311 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1312 "VkSubDecoder vkCmdBeginRenderPass");
1313 const VkRenderPassBeginInfo* pRenderPassBegin;
1314 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1315 VkSubpassContents contents;
1316 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1317 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1318 (VkRenderPassBeginInfo*)(pRenderPassBegin),
1319 readStreamPtrPtr);
1320 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1321 *readStreamPtrPtr += sizeof(VkSubpassContents);
1322 if (pRenderPassBegin) {
1323 transform_tohost_VkRenderPassBeginInfo(
1324 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1325 }
1326 this->on_vkCmdBeginRenderPass(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1327 pRenderPassBegin, contents);
1328 break;
1329 }
1330 case OP_vkCmdNextSubpass: {
1331 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1332 "VkSubDecoder vkCmdNextSubpass");
1333 VkSubpassContents contents;
1334 memcpy((VkSubpassContents*)&contents, *readStreamPtrPtr, sizeof(VkSubpassContents));
1335 *readStreamPtrPtr += sizeof(VkSubpassContents);
1336 vk->vkCmdNextSubpass((VkCommandBuffer)dispatchHandle, contents);
1337 break;
1338 }
1339 case OP_vkCmdEndRenderPass: {
1340 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1341 "VkSubDecoder vkCmdEndRenderPass");
1342 vk->vkCmdEndRenderPass((VkCommandBuffer)dispatchHandle);
1343 break;
1344 }
1345 case OP_vkCmdExecuteCommands: {
1346 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1347 "VkSubDecoder vkCmdExecuteCommands");
1348 uint32_t commandBufferCount;
1349 const VkCommandBuffer* pCommandBuffers;
1350 VkCommandBuffer stack_pCommandBuffers[MAX_STACK_ITEMS];
1351 memcpy((uint32_t*)&commandBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
1352 *readStreamPtrPtr += sizeof(uint32_t);
1353 if (((commandBufferCount)) <= MAX_STACK_ITEMS) {
1354 pCommandBuffers = (VkCommandBuffer*)stack_pCommandBuffers;
1355 } else {
1356 readStream->alloc((void**)&pCommandBuffers,
1357 ((commandBufferCount)) * sizeof(const VkCommandBuffer));
1358 }
1359 if (((commandBufferCount))) {
1360 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1361 *readStreamPtrPtr += 8 * ((commandBufferCount));
1362 for (uint32_t k = 0; k < ((commandBufferCount)); ++k) {
1363 uint64_t tmpval;
1364 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1365 *(((VkCommandBuffer*)pCommandBuffers) + k) =
1366 tmpval ? (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)tmpval)
1367 : VK_NULL_HANDLE;
1368 }
1369 }
1370 this->on_vkCmdExecuteCommands(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1371 commandBufferCount, pCommandBuffers);
1372 break;
1373 }
1374 #endif
1375 #ifdef VK_VERSION_1_1
1376 case OP_vkCmdSetDeviceMask: {
1377 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1378 "VkSubDecoder vkCmdSetDeviceMask");
1379 uint32_t deviceMask;
1380 memcpy((uint32_t*)&deviceMask, *readStreamPtrPtr, sizeof(uint32_t));
1381 *readStreamPtrPtr += sizeof(uint32_t);
1382 vk->vkCmdSetDeviceMask((VkCommandBuffer)dispatchHandle, deviceMask);
1383 break;
1384 }
1385 case OP_vkCmdDispatchBase: {
1386 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1387 "VkSubDecoder vkCmdDispatchBase");
1388 uint32_t baseGroupX;
1389 uint32_t baseGroupY;
1390 uint32_t baseGroupZ;
1391 uint32_t groupCountX;
1392 uint32_t groupCountY;
1393 uint32_t groupCountZ;
1394 memcpy((uint32_t*)&baseGroupX, *readStreamPtrPtr, sizeof(uint32_t));
1395 *readStreamPtrPtr += sizeof(uint32_t);
1396 memcpy((uint32_t*)&baseGroupY, *readStreamPtrPtr, sizeof(uint32_t));
1397 *readStreamPtrPtr += sizeof(uint32_t);
1398 memcpy((uint32_t*)&baseGroupZ, *readStreamPtrPtr, sizeof(uint32_t));
1399 *readStreamPtrPtr += sizeof(uint32_t);
1400 memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
1401 *readStreamPtrPtr += sizeof(uint32_t);
1402 memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
1403 *readStreamPtrPtr += sizeof(uint32_t);
1404 memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
1405 *readStreamPtrPtr += sizeof(uint32_t);
1406 vk->vkCmdDispatchBase((VkCommandBuffer)dispatchHandle, baseGroupX, baseGroupY,
1407 baseGroupZ, groupCountX, groupCountY, groupCountZ);
1408 break;
1409 }
1410 #endif
1411 #ifdef VK_VERSION_1_2
1412 case OP_vkCmdDrawIndirectCount: {
1413 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1414 "VkSubDecoder vkCmdDrawIndirectCount");
1415 VkBuffer buffer;
1416 VkDeviceSize offset;
1417 VkBuffer countBuffer;
1418 VkDeviceSize countBufferOffset;
1419 uint32_t maxDrawCount;
1420 uint32_t stride;
1421 uint64_t cgen_var_0;
1422 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1423 *readStreamPtrPtr += 1 * 8;
1424 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1425 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1426 *readStreamPtrPtr += sizeof(VkDeviceSize);
1427 uint64_t cgen_var_1;
1428 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1429 *readStreamPtrPtr += 1 * 8;
1430 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1431 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1432 *readStreamPtrPtr += sizeof(VkDeviceSize);
1433 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1434 *readStreamPtrPtr += sizeof(uint32_t);
1435 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1436 *readStreamPtrPtr += sizeof(uint32_t);
1437 vk->vkCmdDrawIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset,
1438 countBuffer, countBufferOffset, maxDrawCount, stride);
1439 break;
1440 }
1441 case OP_vkCmdDrawIndexedIndirectCount: {
1442 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1443 "VkSubDecoder vkCmdDrawIndexedIndirectCount");
1444 VkBuffer buffer;
1445 VkDeviceSize offset;
1446 VkBuffer countBuffer;
1447 VkDeviceSize countBufferOffset;
1448 uint32_t maxDrawCount;
1449 uint32_t stride;
1450 uint64_t cgen_var_0;
1451 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1452 *readStreamPtrPtr += 1 * 8;
1453 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
1454 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1455 *readStreamPtrPtr += sizeof(VkDeviceSize);
1456 uint64_t cgen_var_1;
1457 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
1458 *readStreamPtrPtr += 1 * 8;
1459 *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
1460 memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
1461 *readStreamPtrPtr += sizeof(VkDeviceSize);
1462 memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
1463 *readStreamPtrPtr += sizeof(uint32_t);
1464 memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
1465 *readStreamPtrPtr += sizeof(uint32_t);
1466 vk->vkCmdDrawIndexedIndirectCount((VkCommandBuffer)dispatchHandle, buffer, offset,
1467 countBuffer, countBufferOffset, maxDrawCount,
1468 stride);
1469 break;
1470 }
1471 case OP_vkCmdBeginRenderPass2: {
1472 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1473 "VkSubDecoder vkCmdBeginRenderPass2");
1474 const VkRenderPassBeginInfo* pRenderPassBegin;
1475 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
1476 const VkSubpassBeginInfo* pSubpassBeginInfo;
1477 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1478 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
1479 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1480 (VkRenderPassBeginInfo*)(pRenderPassBegin),
1481 readStreamPtrPtr);
1482 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1483 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1484 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
1485 readStreamPtrPtr);
1486 if (pRenderPassBegin) {
1487 transform_tohost_VkRenderPassBeginInfo(
1488 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
1489 }
1490 if (pSubpassBeginInfo) {
1491 transform_tohost_VkSubpassBeginInfo(globalstate,
1492 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1493 }
1494 this->on_vkCmdBeginRenderPass2(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1495 pRenderPassBegin, pSubpassBeginInfo);
1496 break;
1497 }
1498 case OP_vkCmdNextSubpass2: {
1499 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1500 "VkSubDecoder vkCmdNextSubpass2");
1501 const VkSubpassBeginInfo* pSubpassBeginInfo;
1502 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
1503 const VkSubpassEndInfo* pSubpassEndInfo;
1504 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1505 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
1506 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1507 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
1508 readStreamPtrPtr);
1509 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1510 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1511 (VkSubpassEndInfo*)(pSubpassEndInfo),
1512 readStreamPtrPtr);
1513 if (pSubpassBeginInfo) {
1514 transform_tohost_VkSubpassBeginInfo(globalstate,
1515 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
1516 }
1517 if (pSubpassEndInfo) {
1518 transform_tohost_VkSubpassEndInfo(globalstate,
1519 (VkSubpassEndInfo*)(pSubpassEndInfo));
1520 }
1521 vk->vkCmdNextSubpass2((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo,
1522 pSubpassEndInfo);
1523 break;
1524 }
1525 case OP_vkCmdEndRenderPass2: {
1526 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1527 "VkSubDecoder vkCmdEndRenderPass2");
1528 const VkSubpassEndInfo* pSubpassEndInfo;
1529 VkSubpassEndInfo stack_pSubpassEndInfo[1];
1530 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
1531 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1532 (VkSubpassEndInfo*)(pSubpassEndInfo),
1533 readStreamPtrPtr);
1534 if (pSubpassEndInfo) {
1535 transform_tohost_VkSubpassEndInfo(globalstate,
1536 (VkSubpassEndInfo*)(pSubpassEndInfo));
1537 }
1538 vk->vkCmdEndRenderPass2((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
1539 break;
1540 }
1541 #endif
1542 #ifdef VK_VERSION_1_3
1543 case OP_vkCmdSetEvent2: {
1544 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1545 "VkSubDecoder vkCmdSetEvent2");
1546 VkEvent event;
1547 const VkDependencyInfo* pDependencyInfo;
1548 VkDependencyInfo stack_pDependencyInfo[1];
1549 uint64_t cgen_var_0;
1550 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1551 *readStreamPtrPtr += 1 * 8;
1552 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1553 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
1554 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1555 (VkDependencyInfo*)(pDependencyInfo),
1556 readStreamPtrPtr);
1557 if (pDependencyInfo) {
1558 transform_tohost_VkDependencyInfo(globalstate,
1559 (VkDependencyInfo*)(pDependencyInfo));
1560 }
1561 vk->vkCmdSetEvent2((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
1562 break;
1563 }
1564 case OP_vkCmdResetEvent2: {
1565 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1566 "VkSubDecoder vkCmdResetEvent2");
1567 VkEvent event;
1568 VkPipelineStageFlags2 stageMask;
1569 uint64_t cgen_var_0;
1570 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1571 *readStreamPtrPtr += 1 * 8;
1572 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
1573 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
1574 sizeof(VkPipelineStageFlags2));
1575 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
1576 vk->vkCmdResetEvent2((VkCommandBuffer)dispatchHandle, event, stageMask);
1577 break;
1578 }
1579 case OP_vkCmdWaitEvents2: {
1580 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1581 "VkSubDecoder vkCmdWaitEvents2");
1582 uint32_t eventCount;
1583 const VkEvent* pEvents;
1584 VkEvent stack_pEvents[MAX_STACK_ITEMS];
1585 const VkDependencyInfo* pDependencyInfos;
1586 VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
1587 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
1588 *readStreamPtrPtr += sizeof(uint32_t);
1589 if (((eventCount)) <= MAX_STACK_ITEMS) {
1590 pEvents = (VkEvent*)stack_pEvents;
1591 } else {
1592 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
1593 }
1594 if (((eventCount))) {
1595 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1596 *readStreamPtrPtr += 8 * ((eventCount));
1597 for (uint32_t k = 0; k < ((eventCount)); ++k) {
1598 uint64_t tmpval;
1599 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
1600 *(((VkEvent*)pEvents) + k) =
1601 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
1602 }
1603 }
1604 if (((eventCount)) <= MAX_STACK_ITEMS) {
1605 pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
1606 } else {
1607 readStream->alloc((void**)&pDependencyInfos,
1608 ((eventCount)) * sizeof(const VkDependencyInfo));
1609 }
1610 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
1611 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1612 (VkDependencyInfo*)(pDependencyInfos + i),
1613 readStreamPtrPtr);
1614 }
1615 if (pDependencyInfos) {
1616 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
1617 transform_tohost_VkDependencyInfo(
1618 globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
1619 }
1620 }
1621 vk->vkCmdWaitEvents2((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
1622 pDependencyInfos);
1623 break;
1624 }
1625 case OP_vkCmdPipelineBarrier2: {
1626 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1627 "VkSubDecoder vkCmdPipelineBarrier2");
1628 const VkDependencyInfo* pDependencyInfo;
1629 VkDependencyInfo stack_pDependencyInfo[1];
1630 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
1631 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1632 (VkDependencyInfo*)(pDependencyInfo),
1633 readStreamPtrPtr);
1634 if (pDependencyInfo) {
1635 transform_tohost_VkDependencyInfo(globalstate,
1636 (VkDependencyInfo*)(pDependencyInfo));
1637 }
1638 this->on_vkCmdPipelineBarrier2(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1639 pDependencyInfo);
1640 break;
1641 }
1642 case OP_vkCmdWriteTimestamp2: {
1643 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1644 "VkSubDecoder vkCmdWriteTimestamp2");
1645 VkPipelineStageFlags2 stage;
1646 VkQueryPool queryPool;
1647 uint32_t query;
1648 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
1649 sizeof(VkPipelineStageFlags2));
1650 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
1651 uint64_t cgen_var_0;
1652 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
1653 *readStreamPtrPtr += 1 * 8;
1654 *(VkQueryPool*)&queryPool =
1655 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
1656 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
1657 *readStreamPtrPtr += sizeof(uint32_t);
1658 vk->vkCmdWriteTimestamp2((VkCommandBuffer)dispatchHandle, stage, queryPool, query);
1659 break;
1660 }
1661 case OP_vkCmdCopyBuffer2: {
1662 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1663 "VkSubDecoder vkCmdCopyBuffer2");
1664 const VkCopyBufferInfo2* pCopyBufferInfo;
1665 VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
1666 pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
1667 reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1668 (VkCopyBufferInfo2*)(pCopyBufferInfo),
1669 readStreamPtrPtr);
1670 if (pCopyBufferInfo) {
1671 transform_tohost_VkCopyBufferInfo2(globalstate,
1672 (VkCopyBufferInfo2*)(pCopyBufferInfo));
1673 }
1674 vk->vkCmdCopyBuffer2((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
1675 break;
1676 }
1677 case OP_vkCmdCopyImage2: {
1678 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1679 "VkSubDecoder vkCmdCopyImage2");
1680 const VkCopyImageInfo2* pCopyImageInfo;
1681 VkCopyImageInfo2 stack_pCopyImageInfo[1];
1682 pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
1683 reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1684 (VkCopyImageInfo2*)(pCopyImageInfo),
1685 readStreamPtrPtr);
1686 if (pCopyImageInfo) {
1687 transform_tohost_VkCopyImageInfo2(globalstate,
1688 (VkCopyImageInfo2*)(pCopyImageInfo));
1689 }
1690 this->on_vkCmdCopyImage2(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1691 pCopyImageInfo);
1692 break;
1693 }
1694 case OP_vkCmdCopyBufferToImage2: {
1695 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1696 "VkSubDecoder vkCmdCopyBufferToImage2");
1697 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
1698 VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
1699 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
1700 reservedunmarshal_VkCopyBufferToImageInfo2(
1701 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1702 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
1703 if (pCopyBufferToImageInfo) {
1704 transform_tohost_VkCopyBufferToImageInfo2(
1705 globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
1706 }
1707 this->on_vkCmdCopyBufferToImage2(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1708 pCopyBufferToImageInfo, context);
1709 break;
1710 }
1711 case OP_vkCmdCopyImageToBuffer2: {
1712 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1713 "VkSubDecoder vkCmdCopyImageToBuffer2");
1714 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
1715 VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
1716 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
1717 reservedunmarshal_VkCopyImageToBufferInfo2(
1718 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1719 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
1720 if (pCopyImageToBufferInfo) {
1721 transform_tohost_VkCopyImageToBufferInfo2(
1722 globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
1723 }
1724 this->on_vkCmdCopyImageToBuffer2(pool, (VkCommandBuffer)(boxed_dispatchHandle),
1725 pCopyImageToBufferInfo);
1726 break;
1727 }
1728 case OP_vkCmdBlitImage2: {
1729 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1730 "VkSubDecoder vkCmdBlitImage2");
1731 const VkBlitImageInfo2* pBlitImageInfo;
1732 VkBlitImageInfo2 stack_pBlitImageInfo[1];
1733 pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
1734 reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1735 (VkBlitImageInfo2*)(pBlitImageInfo),
1736 readStreamPtrPtr);
1737 if (pBlitImageInfo) {
1738 transform_tohost_VkBlitImageInfo2(globalstate,
1739 (VkBlitImageInfo2*)(pBlitImageInfo));
1740 }
1741 vk->vkCmdBlitImage2((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
1742 break;
1743 }
1744 case OP_vkCmdResolveImage2: {
1745 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1746 "VkSubDecoder vkCmdResolveImage2");
1747 const VkResolveImageInfo2* pResolveImageInfo;
1748 VkResolveImageInfo2 stack_pResolveImageInfo[1];
1749 pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
1750 reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1751 (VkResolveImageInfo2*)(pResolveImageInfo),
1752 readStreamPtrPtr);
1753 if (pResolveImageInfo) {
1754 transform_tohost_VkResolveImageInfo2(globalstate,
1755 (VkResolveImageInfo2*)(pResolveImageInfo));
1756 }
1757 vk->vkCmdResolveImage2((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
1758 break;
1759 }
1760 case OP_vkCmdBeginRendering: {
1761 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1762 "VkSubDecoder vkCmdBeginRendering");
1763 const VkRenderingInfo* pRenderingInfo;
1764 VkRenderingInfo stack_pRenderingInfo[1];
1765 pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
1766 reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1767 (VkRenderingInfo*)(pRenderingInfo),
1768 readStreamPtrPtr);
1769 if (pRenderingInfo) {
1770 transform_tohost_VkRenderingInfo(globalstate,
1771 (VkRenderingInfo*)(pRenderingInfo));
1772 }
1773 vk->vkCmdBeginRendering((VkCommandBuffer)dispatchHandle, pRenderingInfo);
1774 break;
1775 }
1776 case OP_vkCmdEndRendering: {
1777 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1778 "VkSubDecoder vkCmdEndRendering");
1779 vk->vkCmdEndRendering((VkCommandBuffer)dispatchHandle);
1780 break;
1781 }
1782 case OP_vkCmdSetCullMode: {
1783 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1784 "VkSubDecoder vkCmdSetCullMode");
1785 VkCullModeFlags cullMode;
1786 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
1787 *readStreamPtrPtr += sizeof(VkCullModeFlags);
1788 vk->vkCmdSetCullMode((VkCommandBuffer)dispatchHandle, cullMode);
1789 break;
1790 }
1791 case OP_vkCmdSetFrontFace: {
1792 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1793 "VkSubDecoder vkCmdSetFrontFace");
1794 VkFrontFace frontFace;
1795 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
1796 *readStreamPtrPtr += sizeof(VkFrontFace);
1797 vk->vkCmdSetFrontFace((VkCommandBuffer)dispatchHandle, frontFace);
1798 break;
1799 }
1800 case OP_vkCmdSetPrimitiveTopology: {
1801 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1802 "VkSubDecoder vkCmdSetPrimitiveTopology");
1803 VkPrimitiveTopology primitiveTopology;
1804 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
1805 sizeof(VkPrimitiveTopology));
1806 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
1807 vk->vkCmdSetPrimitiveTopology((VkCommandBuffer)dispatchHandle, primitiveTopology);
1808 break;
1809 }
1810 case OP_vkCmdSetViewportWithCount: {
1811 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1812 "VkSubDecoder vkCmdSetViewportWithCount");
1813 uint32_t viewportCount;
1814 const VkViewport* pViewports;
1815 VkViewport stack_pViewports[MAX_STACK_ITEMS];
1816 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
1817 *readStreamPtrPtr += sizeof(uint32_t);
1818 if (((viewportCount)) <= MAX_STACK_ITEMS) {
1819 pViewports = (VkViewport*)stack_pViewports;
1820 } else {
1821 readStream->alloc((void**)&pViewports,
1822 ((viewportCount)) * sizeof(const VkViewport));
1823 }
1824 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
1825 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1826 (VkViewport*)(pViewports + i), readStreamPtrPtr);
1827 }
1828 if (pViewports) {
1829 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
1830 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
1831 }
1832 }
1833 vk->vkCmdSetViewportWithCount((VkCommandBuffer)dispatchHandle, viewportCount,
1834 pViewports);
1835 break;
1836 }
1837 case OP_vkCmdSetScissorWithCount: {
1838 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1839 "VkSubDecoder vkCmdSetScissorWithCount");
1840 uint32_t scissorCount;
1841 const VkRect2D* pScissors;
1842 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
1843 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
1844 *readStreamPtrPtr += sizeof(uint32_t);
1845 if (((scissorCount)) <= MAX_STACK_ITEMS) {
1846 pScissors = (VkRect2D*)stack_pScissors;
1847 } else {
1848 readStream->alloc((void**)&pScissors,
1849 ((scissorCount)) * sizeof(const VkRect2D));
1850 }
1851 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
1852 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
1853 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
1854 }
1855 if (pScissors) {
1856 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
1857 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
1858 }
1859 }
1860 vk->vkCmdSetScissorWithCount((VkCommandBuffer)dispatchHandle, scissorCount,
1861 pScissors);
1862 break;
1863 }
1864 case OP_vkCmdBindVertexBuffers2: {
1865 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1866 "VkSubDecoder vkCmdBindVertexBuffers2");
1867 uint32_t firstBinding;
1868 uint32_t bindingCount;
1869 const VkBuffer* pBuffers;
1870 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
1871 const VkDeviceSize* pOffsets;
1872 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
1873 const VkDeviceSize* pSizes;
1874 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
1875 const VkDeviceSize* pStrides;
1876 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
1877 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
1878 *readStreamPtrPtr += sizeof(uint32_t);
1879 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
1880 *readStreamPtrPtr += sizeof(uint32_t);
1881 // WARNING PTR CHECK
1882 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
1883 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
1884 *readStreamPtrPtr += 8;
1885 if (pBuffers) {
1886 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1887 pBuffers = (VkBuffer*)stack_pBuffers;
1888 } else {
1889 readStream->alloc((void**)&pBuffers,
1890 ((bindingCount)) * sizeof(const VkBuffer));
1891 }
1892 if (((bindingCount))) {
1893 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
1894 *readStreamPtrPtr += 8 * ((bindingCount));
1895 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
1896 uint64_t tmpval;
1897 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
1898 *(((VkBuffer*)pBuffers) + k) =
1899 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
1900 : VK_NULL_HANDLE;
1901 }
1902 }
1903 }
1904 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1905 pOffsets = (VkDeviceSize*)stack_pOffsets;
1906 } else {
1907 readStream->alloc((void**)&pOffsets,
1908 ((bindingCount)) * sizeof(const VkDeviceSize));
1909 }
1910 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
1911 ((bindingCount)) * sizeof(const VkDeviceSize));
1912 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
1913 // WARNING PTR CHECK
1914 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
1915 android::base::Stream::fromBe64((uint8_t*)&pSizes);
1916 *readStreamPtrPtr += 8;
1917 if (pSizes) {
1918 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1919 pSizes = (VkDeviceSize*)stack_pSizes;
1920 } else {
1921 readStream->alloc((void**)&pSizes,
1922 ((bindingCount)) * sizeof(const VkDeviceSize));
1923 }
1924 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
1925 ((bindingCount)) * sizeof(const VkDeviceSize));
1926 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
1927 }
1928 // WARNING PTR CHECK
1929 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
1930 android::base::Stream::fromBe64((uint8_t*)&pStrides);
1931 *readStreamPtrPtr += 8;
1932 if (pStrides) {
1933 if (((bindingCount)) <= MAX_STACK_ITEMS) {
1934 pStrides = (VkDeviceSize*)stack_pStrides;
1935 } else {
1936 readStream->alloc((void**)&pStrides,
1937 ((bindingCount)) * sizeof(const VkDeviceSize));
1938 }
1939 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
1940 ((bindingCount)) * sizeof(const VkDeviceSize));
1941 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
1942 }
1943 vk->vkCmdBindVertexBuffers2((VkCommandBuffer)dispatchHandle, firstBinding,
1944 bindingCount, pBuffers, pOffsets, pSizes, pStrides);
1945 break;
1946 }
1947 case OP_vkCmdSetDepthTestEnable: {
1948 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1949 "VkSubDecoder vkCmdSetDepthTestEnable");
1950 VkBool32 depthTestEnable;
1951 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
1952 *readStreamPtrPtr += sizeof(VkBool32);
1953 vk->vkCmdSetDepthTestEnable((VkCommandBuffer)dispatchHandle, depthTestEnable);
1954 break;
1955 }
1956 case OP_vkCmdSetDepthWriteEnable: {
1957 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1958 "VkSubDecoder vkCmdSetDepthWriteEnable");
1959 VkBool32 depthWriteEnable;
1960 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
1961 *readStreamPtrPtr += sizeof(VkBool32);
1962 vk->vkCmdSetDepthWriteEnable((VkCommandBuffer)dispatchHandle, depthWriteEnable);
1963 break;
1964 }
1965 case OP_vkCmdSetDepthCompareOp: {
1966 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1967 "VkSubDecoder vkCmdSetDepthCompareOp");
1968 VkCompareOp depthCompareOp;
1969 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
1970 *readStreamPtrPtr += sizeof(VkCompareOp);
1971 vk->vkCmdSetDepthCompareOp((VkCommandBuffer)dispatchHandle, depthCompareOp);
1972 break;
1973 }
1974 case OP_vkCmdSetDepthBoundsTestEnable: {
1975 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1976 "VkSubDecoder vkCmdSetDepthBoundsTestEnable");
1977 VkBool32 depthBoundsTestEnable;
1978 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
1979 *readStreamPtrPtr += sizeof(VkBool32);
1980 vk->vkCmdSetDepthBoundsTestEnable((VkCommandBuffer)dispatchHandle,
1981 depthBoundsTestEnable);
1982 break;
1983 }
1984 case OP_vkCmdSetStencilTestEnable: {
1985 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1986 "VkSubDecoder vkCmdSetStencilTestEnable");
1987 VkBool32 stencilTestEnable;
1988 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
1989 *readStreamPtrPtr += sizeof(VkBool32);
1990 vk->vkCmdSetStencilTestEnable((VkCommandBuffer)dispatchHandle, stencilTestEnable);
1991 break;
1992 }
1993 case OP_vkCmdSetStencilOp: {
1994 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
1995 "VkSubDecoder vkCmdSetStencilOp");
1996 VkStencilFaceFlags faceMask;
1997 VkStencilOp failOp;
1998 VkStencilOp passOp;
1999 VkStencilOp depthFailOp;
2000 VkCompareOp compareOp;
2001 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
2002 sizeof(VkStencilFaceFlags));
2003 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
2004 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2005 *readStreamPtrPtr += sizeof(VkStencilOp);
2006 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2007 *readStreamPtrPtr += sizeof(VkStencilOp);
2008 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2009 *readStreamPtrPtr += sizeof(VkStencilOp);
2010 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
2011 *readStreamPtrPtr += sizeof(VkCompareOp);
2012 vk->vkCmdSetStencilOp((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
2013 depthFailOp, compareOp);
2014 break;
2015 }
2016 case OP_vkCmdSetRasterizerDiscardEnable: {
2017 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2018 "VkSubDecoder vkCmdSetRasterizerDiscardEnable");
2019 VkBool32 rasterizerDiscardEnable;
2020 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
2021 *readStreamPtrPtr += sizeof(VkBool32);
2022 vk->vkCmdSetRasterizerDiscardEnable((VkCommandBuffer)dispatchHandle,
2023 rasterizerDiscardEnable);
2024 break;
2025 }
2026 case OP_vkCmdSetDepthBiasEnable: {
2027 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2028 "VkSubDecoder vkCmdSetDepthBiasEnable");
2029 VkBool32 depthBiasEnable;
2030 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
2031 *readStreamPtrPtr += sizeof(VkBool32);
2032 vk->vkCmdSetDepthBiasEnable((VkCommandBuffer)dispatchHandle, depthBiasEnable);
2033 break;
2034 }
2035 case OP_vkCmdSetPrimitiveRestartEnable: {
2036 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2037 "VkSubDecoder vkCmdSetPrimitiveRestartEnable");
2038 VkBool32 primitiveRestartEnable;
2039 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
2040 *readStreamPtrPtr += sizeof(VkBool32);
2041 vk->vkCmdSetPrimitiveRestartEnable((VkCommandBuffer)dispatchHandle,
2042 primitiveRestartEnable);
2043 break;
2044 }
2045 #endif
2046 #ifdef VK_KHR_dynamic_rendering
2047 case OP_vkCmdBeginRenderingKHR: {
2048 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2049 "VkSubDecoder vkCmdBeginRenderingKHR");
2050 const VkRenderingInfo* pRenderingInfo;
2051 VkRenderingInfo stack_pRenderingInfo[1];
2052 pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
2053 reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2054 (VkRenderingInfo*)(pRenderingInfo),
2055 readStreamPtrPtr);
2056 if (pRenderingInfo) {
2057 transform_tohost_VkRenderingInfo(globalstate,
2058 (VkRenderingInfo*)(pRenderingInfo));
2059 }
2060 vk->vkCmdBeginRenderingKHR((VkCommandBuffer)dispatchHandle, pRenderingInfo);
2061 break;
2062 }
2063 case OP_vkCmdEndRenderingKHR: {
2064 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2065 "VkSubDecoder vkCmdEndRenderingKHR");
2066 vk->vkCmdEndRenderingKHR((VkCommandBuffer)dispatchHandle);
2067 break;
2068 }
2069 #endif
2070 #ifdef VK_KHR_create_renderpass2
2071 case OP_vkCmdBeginRenderPass2KHR: {
2072 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2073 "VkSubDecoder vkCmdBeginRenderPass2KHR");
2074 const VkRenderPassBeginInfo* pRenderPassBegin;
2075 VkRenderPassBeginInfo stack_pRenderPassBegin[1];
2076 const VkSubpassBeginInfo* pSubpassBeginInfo;
2077 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
2078 pRenderPassBegin = (VkRenderPassBeginInfo*)stack_pRenderPassBegin;
2079 reservedunmarshal_VkRenderPassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2080 (VkRenderPassBeginInfo*)(pRenderPassBegin),
2081 readStreamPtrPtr);
2082 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
2083 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2084 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
2085 readStreamPtrPtr);
2086 if (pRenderPassBegin) {
2087 transform_tohost_VkRenderPassBeginInfo(
2088 globalstate, (VkRenderPassBeginInfo*)(pRenderPassBegin));
2089 }
2090 if (pSubpassBeginInfo) {
2091 transform_tohost_VkSubpassBeginInfo(globalstate,
2092 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
2093 }
2094 this->on_vkCmdBeginRenderPass2KHR(pool, (VkCommandBuffer)(boxed_dispatchHandle),
2095 pRenderPassBegin, pSubpassBeginInfo);
2096 break;
2097 }
2098 case OP_vkCmdNextSubpass2KHR: {
2099 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2100 "VkSubDecoder vkCmdNextSubpass2KHR");
2101 const VkSubpassBeginInfo* pSubpassBeginInfo;
2102 VkSubpassBeginInfo stack_pSubpassBeginInfo[1];
2103 const VkSubpassEndInfo* pSubpassEndInfo;
2104 VkSubpassEndInfo stack_pSubpassEndInfo[1];
2105 pSubpassBeginInfo = (VkSubpassBeginInfo*)stack_pSubpassBeginInfo;
2106 reservedunmarshal_VkSubpassBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2107 (VkSubpassBeginInfo*)(pSubpassBeginInfo),
2108 readStreamPtrPtr);
2109 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
2110 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2111 (VkSubpassEndInfo*)(pSubpassEndInfo),
2112 readStreamPtrPtr);
2113 if (pSubpassBeginInfo) {
2114 transform_tohost_VkSubpassBeginInfo(globalstate,
2115 (VkSubpassBeginInfo*)(pSubpassBeginInfo));
2116 }
2117 if (pSubpassEndInfo) {
2118 transform_tohost_VkSubpassEndInfo(globalstate,
2119 (VkSubpassEndInfo*)(pSubpassEndInfo));
2120 }
2121 vk->vkCmdNextSubpass2KHR((VkCommandBuffer)dispatchHandle, pSubpassBeginInfo,
2122 pSubpassEndInfo);
2123 break;
2124 }
2125 case OP_vkCmdEndRenderPass2KHR: {
2126 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2127 "VkSubDecoder vkCmdEndRenderPass2KHR");
2128 const VkSubpassEndInfo* pSubpassEndInfo;
2129 VkSubpassEndInfo stack_pSubpassEndInfo[1];
2130 pSubpassEndInfo = (VkSubpassEndInfo*)stack_pSubpassEndInfo;
2131 reservedunmarshal_VkSubpassEndInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2132 (VkSubpassEndInfo*)(pSubpassEndInfo),
2133 readStreamPtrPtr);
2134 if (pSubpassEndInfo) {
2135 transform_tohost_VkSubpassEndInfo(globalstate,
2136 (VkSubpassEndInfo*)(pSubpassEndInfo));
2137 }
2138 vk->vkCmdEndRenderPass2KHR((VkCommandBuffer)dispatchHandle, pSubpassEndInfo);
2139 break;
2140 }
2141 #endif
2142 #ifdef VK_KHR_synchronization2
2143 case OP_vkCmdSetEvent2KHR: {
2144 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2145 "VkSubDecoder vkCmdSetEvent2KHR");
2146 VkEvent event;
2147 const VkDependencyInfo* pDependencyInfo;
2148 VkDependencyInfo stack_pDependencyInfo[1];
2149 uint64_t cgen_var_0;
2150 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2151 *readStreamPtrPtr += 1 * 8;
2152 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
2153 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
2154 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2155 (VkDependencyInfo*)(pDependencyInfo),
2156 readStreamPtrPtr);
2157 if (pDependencyInfo) {
2158 transform_tohost_VkDependencyInfo(globalstate,
2159 (VkDependencyInfo*)(pDependencyInfo));
2160 }
2161 vk->vkCmdSetEvent2KHR((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
2162 break;
2163 }
2164 case OP_vkCmdResetEvent2KHR: {
2165 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2166 "VkSubDecoder vkCmdResetEvent2KHR");
2167 VkEvent event;
2168 VkPipelineStageFlags2 stageMask;
2169 uint64_t cgen_var_0;
2170 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2171 *readStreamPtrPtr += 1 * 8;
2172 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
2173 memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
2174 sizeof(VkPipelineStageFlags2));
2175 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2176 vk->vkCmdResetEvent2KHR((VkCommandBuffer)dispatchHandle, event, stageMask);
2177 break;
2178 }
2179 case OP_vkCmdWaitEvents2KHR: {
2180 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2181 "VkSubDecoder vkCmdWaitEvents2KHR");
2182 uint32_t eventCount;
2183 const VkEvent* pEvents;
2184 VkEvent stack_pEvents[MAX_STACK_ITEMS];
2185 const VkDependencyInfo* pDependencyInfos;
2186 VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
2187 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
2188 *readStreamPtrPtr += sizeof(uint32_t);
2189 if (((eventCount)) <= MAX_STACK_ITEMS) {
2190 pEvents = (VkEvent*)stack_pEvents;
2191 } else {
2192 readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
2193 }
2194 if (((eventCount))) {
2195 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2196 *readStreamPtrPtr += 8 * ((eventCount));
2197 for (uint32_t k = 0; k < ((eventCount)); ++k) {
2198 uint64_t tmpval;
2199 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2200 *(((VkEvent*)pEvents) + k) =
2201 tmpval ? (VkEvent)unbox_VkEvent((VkEvent)tmpval) : VK_NULL_HANDLE;
2202 }
2203 }
2204 if (((eventCount)) <= MAX_STACK_ITEMS) {
2205 pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
2206 } else {
2207 readStream->alloc((void**)&pDependencyInfos,
2208 ((eventCount)) * sizeof(const VkDependencyInfo));
2209 }
2210 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
2211 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2212 (VkDependencyInfo*)(pDependencyInfos + i),
2213 readStreamPtrPtr);
2214 }
2215 if (pDependencyInfos) {
2216 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
2217 transform_tohost_VkDependencyInfo(
2218 globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
2219 }
2220 }
2221 vk->vkCmdWaitEvents2KHR((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
2222 pDependencyInfos);
2223 break;
2224 }
2225 case OP_vkCmdPipelineBarrier2KHR: {
2226 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2227 "VkSubDecoder vkCmdPipelineBarrier2KHR");
2228 const VkDependencyInfo* pDependencyInfo;
2229 VkDependencyInfo stack_pDependencyInfo[1];
2230 pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
2231 reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2232 (VkDependencyInfo*)(pDependencyInfo),
2233 readStreamPtrPtr);
2234 if (pDependencyInfo) {
2235 transform_tohost_VkDependencyInfo(globalstate,
2236 (VkDependencyInfo*)(pDependencyInfo));
2237 }
2238 vk->vkCmdPipelineBarrier2KHR((VkCommandBuffer)dispatchHandle, pDependencyInfo);
2239 break;
2240 }
2241 case OP_vkCmdWriteTimestamp2KHR: {
2242 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2243 "VkSubDecoder vkCmdWriteTimestamp2KHR");
2244 VkPipelineStageFlags2 stage;
2245 VkQueryPool queryPool;
2246 uint32_t query;
2247 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
2248 sizeof(VkPipelineStageFlags2));
2249 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2250 uint64_t cgen_var_0;
2251 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2252 *readStreamPtrPtr += 1 * 8;
2253 *(VkQueryPool*)&queryPool =
2254 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2255 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2256 *readStreamPtrPtr += sizeof(uint32_t);
2257 vk->vkCmdWriteTimestamp2KHR((VkCommandBuffer)dispatchHandle, stage, queryPool,
2258 query);
2259 break;
2260 }
2261 case OP_vkCmdWriteBufferMarker2AMD: {
2262 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2263 "VkSubDecoder vkCmdWriteBufferMarker2AMD");
2264 VkPipelineStageFlags2 stage;
2265 VkBuffer dstBuffer;
2266 VkDeviceSize dstOffset;
2267 uint32_t marker;
2268 memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
2269 sizeof(VkPipelineStageFlags2));
2270 *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
2271 uint64_t cgen_var_0;
2272 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2273 *readStreamPtrPtr += 1 * 8;
2274 *(VkBuffer*)&dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2275 memcpy((VkDeviceSize*)&dstOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2276 *readStreamPtrPtr += sizeof(VkDeviceSize);
2277 memcpy((uint32_t*)&marker, *readStreamPtrPtr, sizeof(uint32_t));
2278 *readStreamPtrPtr += sizeof(uint32_t);
2279 vk->vkCmdWriteBufferMarker2AMD((VkCommandBuffer)dispatchHandle, stage, dstBuffer,
2280 dstOffset, marker);
2281 break;
2282 }
2283 #endif
2284 #ifdef VK_KHR_copy_commands2
2285 case OP_vkCmdCopyBuffer2KHR: {
2286 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2287 "VkSubDecoder vkCmdCopyBuffer2KHR");
2288 const VkCopyBufferInfo2* pCopyBufferInfo;
2289 VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
2290 pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
2291 reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2292 (VkCopyBufferInfo2*)(pCopyBufferInfo),
2293 readStreamPtrPtr);
2294 if (pCopyBufferInfo) {
2295 transform_tohost_VkCopyBufferInfo2(globalstate,
2296 (VkCopyBufferInfo2*)(pCopyBufferInfo));
2297 }
2298 vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
2299 break;
2300 }
2301 case OP_vkCmdCopyImage2KHR: {
2302 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2303 "VkSubDecoder vkCmdCopyImage2KHR");
2304 const VkCopyImageInfo2* pCopyImageInfo;
2305 VkCopyImageInfo2 stack_pCopyImageInfo[1];
2306 pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
2307 reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2308 (VkCopyImageInfo2*)(pCopyImageInfo),
2309 readStreamPtrPtr);
2310 if (pCopyImageInfo) {
2311 transform_tohost_VkCopyImageInfo2(globalstate,
2312 (VkCopyImageInfo2*)(pCopyImageInfo));
2313 }
2314 this->on_vkCmdCopyImage2KHR(pool, (VkCommandBuffer)(boxed_dispatchHandle),
2315 pCopyImageInfo);
2316 break;
2317 }
2318 case OP_vkCmdCopyBufferToImage2KHR: {
2319 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2320 "VkSubDecoder vkCmdCopyBufferToImage2KHR");
2321 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
2322 VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
2323 pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
2324 reservedunmarshal_VkCopyBufferToImageInfo2(
2325 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2326 (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
2327 if (pCopyBufferToImageInfo) {
2328 transform_tohost_VkCopyBufferToImageInfo2(
2329 globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
2330 }
2331 this->on_vkCmdCopyBufferToImage2KHR(pool, (VkCommandBuffer)(boxed_dispatchHandle),
2332 pCopyBufferToImageInfo, context);
2333 break;
2334 }
2335 case OP_vkCmdCopyImageToBuffer2KHR: {
2336 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2337 "VkSubDecoder vkCmdCopyImageToBuffer2KHR");
2338 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
2339 VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
2340 pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
2341 reservedunmarshal_VkCopyImageToBufferInfo2(
2342 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2343 (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
2344 if (pCopyImageToBufferInfo) {
2345 transform_tohost_VkCopyImageToBufferInfo2(
2346 globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
2347 }
2348 this->on_vkCmdCopyImageToBuffer2KHR(pool, (VkCommandBuffer)(boxed_dispatchHandle),
2349 pCopyImageToBufferInfo);
2350 break;
2351 }
2352 case OP_vkCmdBlitImage2KHR: {
2353 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2354 "VkSubDecoder vkCmdBlitImage2KHR");
2355 const VkBlitImageInfo2* pBlitImageInfo;
2356 VkBlitImageInfo2 stack_pBlitImageInfo[1];
2357 pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
2358 reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2359 (VkBlitImageInfo2*)(pBlitImageInfo),
2360 readStreamPtrPtr);
2361 if (pBlitImageInfo) {
2362 transform_tohost_VkBlitImageInfo2(globalstate,
2363 (VkBlitImageInfo2*)(pBlitImageInfo));
2364 }
2365 vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
2366 break;
2367 }
2368 case OP_vkCmdResolveImage2KHR: {
2369 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2370 "VkSubDecoder vkCmdResolveImage2KHR");
2371 const VkResolveImageInfo2* pResolveImageInfo;
2372 VkResolveImageInfo2 stack_pResolveImageInfo[1];
2373 pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
2374 reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2375 (VkResolveImageInfo2*)(pResolveImageInfo),
2376 readStreamPtrPtr);
2377 if (pResolveImageInfo) {
2378 transform_tohost_VkResolveImageInfo2(globalstate,
2379 (VkResolveImageInfo2*)(pResolveImageInfo));
2380 }
2381 vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
2382 break;
2383 }
2384 #endif
2385 #ifdef VK_KHR_maintenance5
2386 case OP_vkCmdBindIndexBuffer2KHR: {
2387 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2388 "VkSubDecoder vkCmdBindIndexBuffer2KHR");
2389 VkBuffer buffer;
2390 VkDeviceSize offset;
2391 VkDeviceSize size;
2392 VkIndexType indexType;
2393 uint64_t cgen_var_0;
2394 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2395 *readStreamPtrPtr += 1 * 8;
2396 *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2397 memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
2398 *readStreamPtrPtr += sizeof(VkDeviceSize);
2399 memcpy((VkDeviceSize*)&size, *readStreamPtrPtr, sizeof(VkDeviceSize));
2400 *readStreamPtrPtr += sizeof(VkDeviceSize);
2401 memcpy((VkIndexType*)&indexType, *readStreamPtrPtr, sizeof(VkIndexType));
2402 *readStreamPtrPtr += sizeof(VkIndexType);
2403 vk->vkCmdBindIndexBuffer2KHR((VkCommandBuffer)dispatchHandle, buffer, offset, size,
2404 indexType);
2405 break;
2406 }
2407 #endif
2408 #ifdef VK_KHR_line_rasterization
2409 case OP_vkCmdSetLineStippleKHR: {
2410 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2411 "VkSubDecoder vkCmdSetLineStippleKHR");
2412 uint32_t lineStippleFactor;
2413 uint16_t lineStipplePattern;
2414 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
2415 *readStreamPtrPtr += sizeof(uint32_t);
2416 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
2417 *readStreamPtrPtr += sizeof(uint16_t);
2418 vk->vkCmdSetLineStippleKHR((VkCommandBuffer)dispatchHandle, lineStippleFactor,
2419 lineStipplePattern);
2420 break;
2421 }
2422 #endif
2423 #ifdef VK_EXT_transform_feedback
2424 case OP_vkCmdBindTransformFeedbackBuffersEXT: {
2425 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2426 "VkSubDecoder vkCmdBindTransformFeedbackBuffersEXT");
2427 uint32_t firstBinding;
2428 uint32_t bindingCount;
2429 const VkBuffer* pBuffers;
2430 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
2431 const VkDeviceSize* pOffsets;
2432 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
2433 const VkDeviceSize* pSizes;
2434 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
2435 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
2436 *readStreamPtrPtr += sizeof(uint32_t);
2437 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
2438 *readStreamPtrPtr += sizeof(uint32_t);
2439 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2440 pBuffers = (VkBuffer*)stack_pBuffers;
2441 } else {
2442 readStream->alloc((void**)&pBuffers, ((bindingCount)) * sizeof(const VkBuffer));
2443 }
2444 if (((bindingCount))) {
2445 uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2446 *readStreamPtrPtr += 8 * ((bindingCount));
2447 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
2448 uint64_t tmpval;
2449 memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
2450 *(((VkBuffer*)pBuffers) + k) =
2451 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval) : VK_NULL_HANDLE;
2452 }
2453 }
2454 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2455 pOffsets = (VkDeviceSize*)stack_pOffsets;
2456 } else {
2457 readStream->alloc((void**)&pOffsets,
2458 ((bindingCount)) * sizeof(const VkDeviceSize));
2459 }
2460 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
2461 ((bindingCount)) * sizeof(const VkDeviceSize));
2462 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2463 // WARNING PTR CHECK
2464 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
2465 android::base::Stream::fromBe64((uint8_t*)&pSizes);
2466 *readStreamPtrPtr += 8;
2467 if (pSizes) {
2468 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2469 pSizes = (VkDeviceSize*)stack_pSizes;
2470 } else {
2471 readStream->alloc((void**)&pSizes,
2472 ((bindingCount)) * sizeof(const VkDeviceSize));
2473 }
2474 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
2475 ((bindingCount)) * sizeof(const VkDeviceSize));
2476 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2477 }
2478 vk->vkCmdBindTransformFeedbackBuffersEXT((VkCommandBuffer)dispatchHandle,
2479 firstBinding, bindingCount, pBuffers,
2480 pOffsets, pSizes);
2481 break;
2482 }
2483 case OP_vkCmdBeginTransformFeedbackEXT: {
2484 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2485 "VkSubDecoder vkCmdBeginTransformFeedbackEXT");
2486 uint32_t firstCounterBuffer;
2487 uint32_t counterBufferCount;
2488 const VkBuffer* pCounterBuffers;
2489 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2490 const VkDeviceSize* pCounterBufferOffsets;
2491 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2492 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2493 *readStreamPtrPtr += sizeof(uint32_t);
2494 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2495 *readStreamPtrPtr += sizeof(uint32_t);
2496 // WARNING PTR CHECK
2497 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2498 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2499 *readStreamPtrPtr += 8;
2500 if (pCounterBuffers) {
2501 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2502 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2503 } else {
2504 readStream->alloc((void**)&pCounterBuffers,
2505 ((counterBufferCount)) * sizeof(const VkBuffer));
2506 }
2507 if (((counterBufferCount))) {
2508 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2509 *readStreamPtrPtr += 8 * ((counterBufferCount));
2510 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
2511 uint64_t tmpval;
2512 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2513 *(((VkBuffer*)pCounterBuffers) + k) =
2514 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
2515 : VK_NULL_HANDLE;
2516 }
2517 }
2518 }
2519 // WARNING PTR CHECK
2520 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2521 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2522 *readStreamPtrPtr += 8;
2523 if (pCounterBufferOffsets) {
2524 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2525 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2526 } else {
2527 readStream->alloc((void**)&pCounterBufferOffsets,
2528 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2529 }
2530 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
2531 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2532 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
2533 }
2534 vk->vkCmdBeginTransformFeedbackEXT((VkCommandBuffer)dispatchHandle,
2535 firstCounterBuffer, counterBufferCount,
2536 pCounterBuffers, pCounterBufferOffsets);
2537 break;
2538 }
2539 case OP_vkCmdEndTransformFeedbackEXT: {
2540 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2541 "VkSubDecoder vkCmdEndTransformFeedbackEXT");
2542 uint32_t firstCounterBuffer;
2543 uint32_t counterBufferCount;
2544 const VkBuffer* pCounterBuffers;
2545 VkBuffer stack_pCounterBuffers[MAX_STACK_ITEMS];
2546 const VkDeviceSize* pCounterBufferOffsets;
2547 VkDeviceSize stack_pCounterBufferOffsets[MAX_STACK_ITEMS];
2548 memcpy((uint32_t*)&firstCounterBuffer, *readStreamPtrPtr, sizeof(uint32_t));
2549 *readStreamPtrPtr += sizeof(uint32_t);
2550 memcpy((uint32_t*)&counterBufferCount, *readStreamPtrPtr, sizeof(uint32_t));
2551 *readStreamPtrPtr += sizeof(uint32_t);
2552 // WARNING PTR CHECK
2553 memcpy((VkBuffer**)&pCounterBuffers, (*readStreamPtrPtr), 8);
2554 android::base::Stream::fromBe64((uint8_t*)&pCounterBuffers);
2555 *readStreamPtrPtr += 8;
2556 if (pCounterBuffers) {
2557 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2558 pCounterBuffers = (VkBuffer*)stack_pCounterBuffers;
2559 } else {
2560 readStream->alloc((void**)&pCounterBuffers,
2561 ((counterBufferCount)) * sizeof(const VkBuffer));
2562 }
2563 if (((counterBufferCount))) {
2564 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2565 *readStreamPtrPtr += 8 * ((counterBufferCount));
2566 for (uint32_t k = 0; k < ((counterBufferCount)); ++k) {
2567 uint64_t tmpval;
2568 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2569 *(((VkBuffer*)pCounterBuffers) + k) =
2570 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
2571 : VK_NULL_HANDLE;
2572 }
2573 }
2574 }
2575 // WARNING PTR CHECK
2576 memcpy((VkDeviceSize**)&pCounterBufferOffsets, (*readStreamPtrPtr), 8);
2577 android::base::Stream::fromBe64((uint8_t*)&pCounterBufferOffsets);
2578 *readStreamPtrPtr += 8;
2579 if (pCounterBufferOffsets) {
2580 if (((counterBufferCount)) <= MAX_STACK_ITEMS) {
2581 pCounterBufferOffsets = (VkDeviceSize*)stack_pCounterBufferOffsets;
2582 } else {
2583 readStream->alloc((void**)&pCounterBufferOffsets,
2584 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2585 }
2586 memcpy((VkDeviceSize*)pCounterBufferOffsets, *readStreamPtrPtr,
2587 ((counterBufferCount)) * sizeof(const VkDeviceSize));
2588 *readStreamPtrPtr += ((counterBufferCount)) * sizeof(const VkDeviceSize);
2589 }
2590 vk->vkCmdEndTransformFeedbackEXT((VkCommandBuffer)dispatchHandle,
2591 firstCounterBuffer, counterBufferCount,
2592 pCounterBuffers, pCounterBufferOffsets);
2593 break;
2594 }
2595 case OP_vkCmdBeginQueryIndexedEXT: {
2596 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2597 "VkSubDecoder vkCmdBeginQueryIndexedEXT");
2598 VkQueryPool queryPool;
2599 uint32_t query;
2600 VkQueryControlFlags flags;
2601 uint32_t index;
2602 uint64_t cgen_var_0;
2603 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2604 *readStreamPtrPtr += 1 * 8;
2605 *(VkQueryPool*)&queryPool =
2606 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2607 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2608 *readStreamPtrPtr += sizeof(uint32_t);
2609 memcpy((VkQueryControlFlags*)&flags, *readStreamPtrPtr,
2610 sizeof(VkQueryControlFlags));
2611 *readStreamPtrPtr += sizeof(VkQueryControlFlags);
2612 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
2613 *readStreamPtrPtr += sizeof(uint32_t);
2614 vk->vkCmdBeginQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query,
2615 flags, index);
2616 break;
2617 }
2618 case OP_vkCmdEndQueryIndexedEXT: {
2619 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2620 "VkSubDecoder vkCmdEndQueryIndexedEXT");
2621 VkQueryPool queryPool;
2622 uint32_t query;
2623 uint32_t index;
2624 uint64_t cgen_var_0;
2625 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2626 *readStreamPtrPtr += 1 * 8;
2627 *(VkQueryPool*)&queryPool =
2628 (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
2629 memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
2630 *readStreamPtrPtr += sizeof(uint32_t);
2631 memcpy((uint32_t*)&index, *readStreamPtrPtr, sizeof(uint32_t));
2632 *readStreamPtrPtr += sizeof(uint32_t);
2633 vk->vkCmdEndQueryIndexedEXT((VkCommandBuffer)dispatchHandle, queryPool, query,
2634 index);
2635 break;
2636 }
2637 case OP_vkCmdDrawIndirectByteCountEXT: {
2638 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2639 "VkSubDecoder vkCmdDrawIndirectByteCountEXT");
2640 uint32_t instanceCount;
2641 uint32_t firstInstance;
2642 VkBuffer counterBuffer;
2643 VkDeviceSize counterBufferOffset;
2644 uint32_t counterOffset;
2645 uint32_t vertexStride;
2646 memcpy((uint32_t*)&instanceCount, *readStreamPtrPtr, sizeof(uint32_t));
2647 *readStreamPtrPtr += sizeof(uint32_t);
2648 memcpy((uint32_t*)&firstInstance, *readStreamPtrPtr, sizeof(uint32_t));
2649 *readStreamPtrPtr += sizeof(uint32_t);
2650 uint64_t cgen_var_0;
2651 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
2652 *readStreamPtrPtr += 1 * 8;
2653 *(VkBuffer*)&counterBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
2654 memcpy((VkDeviceSize*)&counterBufferOffset, *readStreamPtrPtr,
2655 sizeof(VkDeviceSize));
2656 *readStreamPtrPtr += sizeof(VkDeviceSize);
2657 memcpy((uint32_t*)&counterOffset, *readStreamPtrPtr, sizeof(uint32_t));
2658 *readStreamPtrPtr += sizeof(uint32_t);
2659 memcpy((uint32_t*)&vertexStride, *readStreamPtrPtr, sizeof(uint32_t));
2660 *readStreamPtrPtr += sizeof(uint32_t);
2661 vk->vkCmdDrawIndirectByteCountEXT((VkCommandBuffer)dispatchHandle, instanceCount,
2662 firstInstance, counterBuffer, counterBufferOffset,
2663 counterOffset, vertexStride);
2664 break;
2665 }
2666 #endif
2667 #ifdef VK_EXT_debug_utils
2668 case OP_vkCmdBeginDebugUtilsLabelEXT: {
2669 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2670 "VkSubDecoder vkCmdBeginDebugUtilsLabelEXT");
2671 const VkDebugUtilsLabelEXT* pLabelInfo;
2672 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
2673 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
2674 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2675 (VkDebugUtilsLabelEXT*)(pLabelInfo),
2676 readStreamPtrPtr);
2677 if (pLabelInfo) {
2678 transform_tohost_VkDebugUtilsLabelEXT(globalstate,
2679 (VkDebugUtilsLabelEXT*)(pLabelInfo));
2680 }
2681 vk->vkCmdBeginDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
2682 break;
2683 }
2684 case OP_vkCmdEndDebugUtilsLabelEXT: {
2685 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2686 "VkSubDecoder vkCmdEndDebugUtilsLabelEXT");
2687 vk->vkCmdEndDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle);
2688 break;
2689 }
2690 case OP_vkCmdInsertDebugUtilsLabelEXT: {
2691 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2692 "VkSubDecoder vkCmdInsertDebugUtilsLabelEXT");
2693 const VkDebugUtilsLabelEXT* pLabelInfo;
2694 VkDebugUtilsLabelEXT stack_pLabelInfo[1];
2695 pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
2696 reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2697 (VkDebugUtilsLabelEXT*)(pLabelInfo),
2698 readStreamPtrPtr);
2699 if (pLabelInfo) {
2700 transform_tohost_VkDebugUtilsLabelEXT(globalstate,
2701 (VkDebugUtilsLabelEXT*)(pLabelInfo));
2702 }
2703 vk->vkCmdInsertDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
2704 break;
2705 }
2706 #endif
2707 #ifdef VK_EXT_line_rasterization
2708 case OP_vkCmdSetLineStippleEXT: {
2709 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2710 "VkSubDecoder vkCmdSetLineStippleEXT");
2711 uint32_t lineStippleFactor;
2712 uint16_t lineStipplePattern;
2713 memcpy((uint32_t*)&lineStippleFactor, *readStreamPtrPtr, sizeof(uint32_t));
2714 *readStreamPtrPtr += sizeof(uint32_t);
2715 memcpy((uint16_t*)&lineStipplePattern, *readStreamPtrPtr, sizeof(uint16_t));
2716 *readStreamPtrPtr += sizeof(uint16_t);
2717 vk->vkCmdSetLineStippleEXT((VkCommandBuffer)dispatchHandle, lineStippleFactor,
2718 lineStipplePattern);
2719 break;
2720 }
2721 #endif
2722 #ifdef VK_EXT_extended_dynamic_state
2723 case OP_vkCmdSetCullModeEXT: {
2724 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2725 "VkSubDecoder vkCmdSetCullModeEXT");
2726 VkCullModeFlags cullMode;
2727 memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
2728 *readStreamPtrPtr += sizeof(VkCullModeFlags);
2729 vk->vkCmdSetCullModeEXT((VkCommandBuffer)dispatchHandle, cullMode);
2730 break;
2731 }
2732 case OP_vkCmdSetFrontFaceEXT: {
2733 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2734 "VkSubDecoder vkCmdSetFrontFaceEXT");
2735 VkFrontFace frontFace;
2736 memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
2737 *readStreamPtrPtr += sizeof(VkFrontFace);
2738 vk->vkCmdSetFrontFaceEXT((VkCommandBuffer)dispatchHandle, frontFace);
2739 break;
2740 }
2741 case OP_vkCmdSetPrimitiveTopologyEXT: {
2742 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2743 "VkSubDecoder vkCmdSetPrimitiveTopologyEXT");
2744 VkPrimitiveTopology primitiveTopology;
2745 memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
2746 sizeof(VkPrimitiveTopology));
2747 *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
2748 vk->vkCmdSetPrimitiveTopologyEXT((VkCommandBuffer)dispatchHandle,
2749 primitiveTopology);
2750 break;
2751 }
2752 case OP_vkCmdSetViewportWithCountEXT: {
2753 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2754 "VkSubDecoder vkCmdSetViewportWithCountEXT");
2755 uint32_t viewportCount;
2756 const VkViewport* pViewports;
2757 VkViewport stack_pViewports[MAX_STACK_ITEMS];
2758 memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
2759 *readStreamPtrPtr += sizeof(uint32_t);
2760 if (((viewportCount)) <= MAX_STACK_ITEMS) {
2761 pViewports = (VkViewport*)stack_pViewports;
2762 } else {
2763 readStream->alloc((void**)&pViewports,
2764 ((viewportCount)) * sizeof(const VkViewport));
2765 }
2766 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
2767 reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2768 (VkViewport*)(pViewports + i), readStreamPtrPtr);
2769 }
2770 if (pViewports) {
2771 for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
2772 transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
2773 }
2774 }
2775 vk->vkCmdSetViewportWithCountEXT((VkCommandBuffer)dispatchHandle, viewportCount,
2776 pViewports);
2777 break;
2778 }
2779 case OP_vkCmdSetScissorWithCountEXT: {
2780 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2781 "VkSubDecoder vkCmdSetScissorWithCountEXT");
2782 uint32_t scissorCount;
2783 const VkRect2D* pScissors;
2784 VkRect2D stack_pScissors[MAX_STACK_ITEMS];
2785 memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
2786 *readStreamPtrPtr += sizeof(uint32_t);
2787 if (((scissorCount)) <= MAX_STACK_ITEMS) {
2788 pScissors = (VkRect2D*)stack_pScissors;
2789 } else {
2790 readStream->alloc((void**)&pScissors,
2791 ((scissorCount)) * sizeof(const VkRect2D));
2792 }
2793 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
2794 reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
2795 (VkRect2D*)(pScissors + i), readStreamPtrPtr);
2796 }
2797 if (pScissors) {
2798 for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
2799 transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
2800 }
2801 }
2802 vk->vkCmdSetScissorWithCountEXT((VkCommandBuffer)dispatchHandle, scissorCount,
2803 pScissors);
2804 break;
2805 }
2806 case OP_vkCmdBindVertexBuffers2EXT: {
2807 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2808 "VkSubDecoder vkCmdBindVertexBuffers2EXT");
2809 uint32_t firstBinding;
2810 uint32_t bindingCount;
2811 const VkBuffer* pBuffers;
2812 VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
2813 const VkDeviceSize* pOffsets;
2814 VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
2815 const VkDeviceSize* pSizes;
2816 VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
2817 const VkDeviceSize* pStrides;
2818 VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
2819 memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
2820 *readStreamPtrPtr += sizeof(uint32_t);
2821 memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
2822 *readStreamPtrPtr += sizeof(uint32_t);
2823 // WARNING PTR CHECK
2824 memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
2825 android::base::Stream::fromBe64((uint8_t*)&pBuffers);
2826 *readStreamPtrPtr += 8;
2827 if (pBuffers) {
2828 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2829 pBuffers = (VkBuffer*)stack_pBuffers;
2830 } else {
2831 readStream->alloc((void**)&pBuffers,
2832 ((bindingCount)) * sizeof(const VkBuffer));
2833 }
2834 if (((bindingCount))) {
2835 uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
2836 *readStreamPtrPtr += 8 * ((bindingCount));
2837 for (uint32_t k = 0; k < ((bindingCount)); ++k) {
2838 uint64_t tmpval;
2839 memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
2840 *(((VkBuffer*)pBuffers) + k) =
2841 tmpval ? (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval)
2842 : VK_NULL_HANDLE;
2843 }
2844 }
2845 }
2846 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2847 pOffsets = (VkDeviceSize*)stack_pOffsets;
2848 } else {
2849 readStream->alloc((void**)&pOffsets,
2850 ((bindingCount)) * sizeof(const VkDeviceSize));
2851 }
2852 memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
2853 ((bindingCount)) * sizeof(const VkDeviceSize));
2854 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2855 // WARNING PTR CHECK
2856 memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
2857 android::base::Stream::fromBe64((uint8_t*)&pSizes);
2858 *readStreamPtrPtr += 8;
2859 if (pSizes) {
2860 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2861 pSizes = (VkDeviceSize*)stack_pSizes;
2862 } else {
2863 readStream->alloc((void**)&pSizes,
2864 ((bindingCount)) * sizeof(const VkDeviceSize));
2865 }
2866 memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
2867 ((bindingCount)) * sizeof(const VkDeviceSize));
2868 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2869 }
2870 // WARNING PTR CHECK
2871 memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
2872 android::base::Stream::fromBe64((uint8_t*)&pStrides);
2873 *readStreamPtrPtr += 8;
2874 if (pStrides) {
2875 if (((bindingCount)) <= MAX_STACK_ITEMS) {
2876 pStrides = (VkDeviceSize*)stack_pStrides;
2877 } else {
2878 readStream->alloc((void**)&pStrides,
2879 ((bindingCount)) * sizeof(const VkDeviceSize));
2880 }
2881 memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
2882 ((bindingCount)) * sizeof(const VkDeviceSize));
2883 *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
2884 }
2885 vk->vkCmdBindVertexBuffers2EXT((VkCommandBuffer)dispatchHandle, firstBinding,
2886 bindingCount, pBuffers, pOffsets, pSizes, pStrides);
2887 break;
2888 }
2889 case OP_vkCmdSetDepthTestEnableEXT: {
2890 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2891 "VkSubDecoder vkCmdSetDepthTestEnableEXT");
2892 VkBool32 depthTestEnable;
2893 memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
2894 *readStreamPtrPtr += sizeof(VkBool32);
2895 vk->vkCmdSetDepthTestEnableEXT((VkCommandBuffer)dispatchHandle, depthTestEnable);
2896 break;
2897 }
2898 case OP_vkCmdSetDepthWriteEnableEXT: {
2899 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2900 "VkSubDecoder vkCmdSetDepthWriteEnableEXT");
2901 VkBool32 depthWriteEnable;
2902 memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
2903 *readStreamPtrPtr += sizeof(VkBool32);
2904 vk->vkCmdSetDepthWriteEnableEXT((VkCommandBuffer)dispatchHandle, depthWriteEnable);
2905 break;
2906 }
2907 case OP_vkCmdSetDepthCompareOpEXT: {
2908 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2909 "VkSubDecoder vkCmdSetDepthCompareOpEXT");
2910 VkCompareOp depthCompareOp;
2911 memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
2912 *readStreamPtrPtr += sizeof(VkCompareOp);
2913 vk->vkCmdSetDepthCompareOpEXT((VkCommandBuffer)dispatchHandle, depthCompareOp);
2914 break;
2915 }
2916 case OP_vkCmdSetDepthBoundsTestEnableEXT: {
2917 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2918 "VkSubDecoder vkCmdSetDepthBoundsTestEnableEXT");
2919 VkBool32 depthBoundsTestEnable;
2920 memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
2921 *readStreamPtrPtr += sizeof(VkBool32);
2922 vk->vkCmdSetDepthBoundsTestEnableEXT((VkCommandBuffer)dispatchHandle,
2923 depthBoundsTestEnable);
2924 break;
2925 }
2926 case OP_vkCmdSetStencilTestEnableEXT: {
2927 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2928 "VkSubDecoder vkCmdSetStencilTestEnableEXT");
2929 VkBool32 stencilTestEnable;
2930 memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
2931 *readStreamPtrPtr += sizeof(VkBool32);
2932 vk->vkCmdSetStencilTestEnableEXT((VkCommandBuffer)dispatchHandle,
2933 stencilTestEnable);
2934 break;
2935 }
2936 case OP_vkCmdSetStencilOpEXT: {
2937 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2938 "VkSubDecoder vkCmdSetStencilOpEXT");
2939 VkStencilFaceFlags faceMask;
2940 VkStencilOp failOp;
2941 VkStencilOp passOp;
2942 VkStencilOp depthFailOp;
2943 VkCompareOp compareOp;
2944 memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
2945 sizeof(VkStencilFaceFlags));
2946 *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
2947 memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2948 *readStreamPtrPtr += sizeof(VkStencilOp);
2949 memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2950 *readStreamPtrPtr += sizeof(VkStencilOp);
2951 memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
2952 *readStreamPtrPtr += sizeof(VkStencilOp);
2953 memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
2954 *readStreamPtrPtr += sizeof(VkCompareOp);
2955 vk->vkCmdSetStencilOpEXT((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
2956 depthFailOp, compareOp);
2957 break;
2958 }
2959 #endif
2960 #ifdef VK_EXT_extended_dynamic_state2
2961 case OP_vkCmdSetPatchControlPointsEXT: {
2962 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2963 "VkSubDecoder vkCmdSetPatchControlPointsEXT");
2964 uint32_t patchControlPoints;
2965 memcpy((uint32_t*)&patchControlPoints, *readStreamPtrPtr, sizeof(uint32_t));
2966 *readStreamPtrPtr += sizeof(uint32_t);
2967 vk->vkCmdSetPatchControlPointsEXT((VkCommandBuffer)dispatchHandle,
2968 patchControlPoints);
2969 break;
2970 }
2971 case OP_vkCmdSetRasterizerDiscardEnableEXT: {
2972 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2973 "VkSubDecoder vkCmdSetRasterizerDiscardEnableEXT");
2974 VkBool32 rasterizerDiscardEnable;
2975 memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
2976 *readStreamPtrPtr += sizeof(VkBool32);
2977 vk->vkCmdSetRasterizerDiscardEnableEXT((VkCommandBuffer)dispatchHandle,
2978 rasterizerDiscardEnable);
2979 break;
2980 }
2981 case OP_vkCmdSetDepthBiasEnableEXT: {
2982 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2983 "VkSubDecoder vkCmdSetDepthBiasEnableEXT");
2984 VkBool32 depthBiasEnable;
2985 memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
2986 *readStreamPtrPtr += sizeof(VkBool32);
2987 vk->vkCmdSetDepthBiasEnableEXT((VkCommandBuffer)dispatchHandle, depthBiasEnable);
2988 break;
2989 }
2990 case OP_vkCmdSetLogicOpEXT: {
2991 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
2992 "VkSubDecoder vkCmdSetLogicOpEXT");
2993 VkLogicOp logicOp;
2994 memcpy((VkLogicOp*)&logicOp, *readStreamPtrPtr, sizeof(VkLogicOp));
2995 *readStreamPtrPtr += sizeof(VkLogicOp);
2996 vk->vkCmdSetLogicOpEXT((VkCommandBuffer)dispatchHandle, logicOp);
2997 break;
2998 }
2999 case OP_vkCmdSetPrimitiveRestartEnableEXT: {
3000 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3001 "VkSubDecoder vkCmdSetPrimitiveRestartEnableEXT");
3002 VkBool32 primitiveRestartEnable;
3003 memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
3004 *readStreamPtrPtr += sizeof(VkBool32);
3005 vk->vkCmdSetPrimitiveRestartEnableEXT((VkCommandBuffer)dispatchHandle,
3006 primitiveRestartEnable);
3007 break;
3008 }
3009 #endif
3010 #ifdef VK_EXT_color_write_enable
3011 case OP_vkCmdSetColorWriteEnableEXT: {
3012 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3013 "VkSubDecoder vkCmdSetColorWriteEnableEXT");
3014 uint32_t attachmentCount;
3015 const VkBool32* pColorWriteEnables;
3016 VkBool32 stack_pColorWriteEnables[MAX_STACK_ITEMS];
3017 memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
3018 *readStreamPtrPtr += sizeof(uint32_t);
3019 if (((attachmentCount)) <= MAX_STACK_ITEMS) {
3020 pColorWriteEnables = (VkBool32*)stack_pColorWriteEnables;
3021 } else {
3022 readStream->alloc((void**)&pColorWriteEnables,
3023 ((attachmentCount)) * sizeof(const VkBool32));
3024 }
3025 memcpy((VkBool32*)pColorWriteEnables, *readStreamPtrPtr,
3026 ((attachmentCount)) * sizeof(const VkBool32));
3027 *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
3028 vk->vkCmdSetColorWriteEnableEXT((VkCommandBuffer)dispatchHandle, attachmentCount,
3029 pColorWriteEnables);
3030 break;
3031 }
3032 #endif
3033 #ifdef VK_GOOGLE_gfxstream
3034 case OP_vkBeginCommandBufferAsyncGOOGLE: {
3035 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3036 "VkSubDecoder vkBeginCommandBufferAsyncGOOGLE");
3037 const VkCommandBufferBeginInfo* pBeginInfo;
3038 VkCommandBufferBeginInfo stack_pBeginInfo[1];
3039 pBeginInfo = (VkCommandBufferBeginInfo*)stack_pBeginInfo;
3040 reservedunmarshal_VkCommandBufferBeginInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3041 (VkCommandBufferBeginInfo*)(pBeginInfo),
3042 readStreamPtrPtr);
3043 if (pBeginInfo) {
3044 transform_tohost_VkCommandBufferBeginInfo(
3045 globalstate, (VkCommandBufferBeginInfo*)(pBeginInfo));
3046 }
3047 this->on_vkBeginCommandBufferAsyncGOOGLE(
3048 pool, (VkCommandBuffer)(boxed_dispatchHandle), pBeginInfo, context);
3049 break;
3050 }
3051 case OP_vkEndCommandBufferAsyncGOOGLE: {
3052 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3053 "VkSubDecoder vkEndCommandBufferAsyncGOOGLE");
3054 this->on_vkEndCommandBufferAsyncGOOGLE(
3055 pool, (VkCommandBuffer)(boxed_dispatchHandle), context);
3056 break;
3057 }
3058 case OP_vkResetCommandBufferAsyncGOOGLE: {
3059 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3060 "VkSubDecoder vkResetCommandBufferAsyncGOOGLE");
3061 VkCommandBufferResetFlags flags;
3062 memcpy((VkCommandBufferResetFlags*)&flags, *readStreamPtrPtr,
3063 sizeof(VkCommandBufferResetFlags));
3064 *readStreamPtrPtr += sizeof(VkCommandBufferResetFlags);
3065 this->on_vkResetCommandBufferAsyncGOOGLE(
3066 pool, (VkCommandBuffer)(boxed_dispatchHandle), flags);
3067 break;
3068 }
3069 case OP_vkCommandBufferHostSyncGOOGLE: {
3070 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3071 "VkSubDecoder vkCommandBufferHostSyncGOOGLE");
3072 uint32_t needHostSync;
3073 uint32_t sequenceNumber;
3074 memcpy((uint32_t*)&needHostSync, *readStreamPtrPtr, sizeof(uint32_t));
3075 *readStreamPtrPtr += sizeof(uint32_t);
3076 memcpy((uint32_t*)&sequenceNumber, *readStreamPtrPtr, sizeof(uint32_t));
3077 *readStreamPtrPtr += sizeof(uint32_t);
3078 this->on_vkCommandBufferHostSyncGOOGLE(
3079 pool, (VkCommandBuffer)(boxed_dispatchHandle), needHostSync, sequenceNumber);
3080 break;
3081 }
3082 #endif
3083 #ifdef VK_KHR_ray_tracing_pipeline
3084 case OP_vkCmdTraceRaysKHR: {
3085 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3086 "VkSubDecoder vkCmdTraceRaysKHR");
3087 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
3088 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
3089 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
3090 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
3091 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
3092 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
3093 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
3094 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
3095 uint32_t width;
3096 uint32_t height;
3097 uint32_t depth;
3098 pRaygenShaderBindingTable =
3099 (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
3100 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3101 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3102 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
3103 readStreamPtrPtr);
3104 pMissShaderBindingTable =
3105 (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
3106 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3107 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3108 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
3109 pHitShaderBindingTable =
3110 (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
3111 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3112 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3113 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
3114 pCallableShaderBindingTable =
3115 (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
3116 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3117 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3118 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
3119 readStreamPtrPtr);
3120 memcpy((uint32_t*)&width, *readStreamPtrPtr, sizeof(uint32_t));
3121 *readStreamPtrPtr += sizeof(uint32_t);
3122 memcpy((uint32_t*)&height, *readStreamPtrPtr, sizeof(uint32_t));
3123 *readStreamPtrPtr += sizeof(uint32_t);
3124 memcpy((uint32_t*)&depth, *readStreamPtrPtr, sizeof(uint32_t));
3125 *readStreamPtrPtr += sizeof(uint32_t);
3126 if (pRaygenShaderBindingTable) {
3127 transform_tohost_VkStridedDeviceAddressRegionKHR(
3128 globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
3129 }
3130 if (pMissShaderBindingTable) {
3131 transform_tohost_VkStridedDeviceAddressRegionKHR(
3132 globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
3133 }
3134 if (pHitShaderBindingTable) {
3135 transform_tohost_VkStridedDeviceAddressRegionKHR(
3136 globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
3137 }
3138 if (pCallableShaderBindingTable) {
3139 transform_tohost_VkStridedDeviceAddressRegionKHR(
3140 globalstate,
3141 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
3142 }
3143 vk->vkCmdTraceRaysKHR((VkCommandBuffer)dispatchHandle, pRaygenShaderBindingTable,
3144 pMissShaderBindingTable, pHitShaderBindingTable,
3145 pCallableShaderBindingTable, width, height, depth);
3146 break;
3147 }
3148 case OP_vkCmdTraceRaysIndirectKHR: {
3149 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3150 "VkSubDecoder vkCmdTraceRaysIndirectKHR");
3151 const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable;
3152 VkStridedDeviceAddressRegionKHR stack_pRaygenShaderBindingTable[1];
3153 const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable;
3154 VkStridedDeviceAddressRegionKHR stack_pMissShaderBindingTable[1];
3155 const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable;
3156 VkStridedDeviceAddressRegionKHR stack_pHitShaderBindingTable[1];
3157 const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable;
3158 VkStridedDeviceAddressRegionKHR stack_pCallableShaderBindingTable[1];
3159 VkDeviceAddress indirectDeviceAddress;
3160 pRaygenShaderBindingTable =
3161 (VkStridedDeviceAddressRegionKHR*)stack_pRaygenShaderBindingTable;
3162 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3163 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3164 (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable),
3165 readStreamPtrPtr);
3166 pMissShaderBindingTable =
3167 (VkStridedDeviceAddressRegionKHR*)stack_pMissShaderBindingTable;
3168 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3169 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3170 (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable), readStreamPtrPtr);
3171 pHitShaderBindingTable =
3172 (VkStridedDeviceAddressRegionKHR*)stack_pHitShaderBindingTable;
3173 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3174 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3175 (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable), readStreamPtrPtr);
3176 pCallableShaderBindingTable =
3177 (VkStridedDeviceAddressRegionKHR*)stack_pCallableShaderBindingTable;
3178 reservedunmarshal_VkStridedDeviceAddressRegionKHR(
3179 readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
3180 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable),
3181 readStreamPtrPtr);
3182 memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
3183 sizeof(VkDeviceAddress));
3184 *readStreamPtrPtr += sizeof(VkDeviceAddress);
3185 if (pRaygenShaderBindingTable) {
3186 transform_tohost_VkStridedDeviceAddressRegionKHR(
3187 globalstate, (VkStridedDeviceAddressRegionKHR*)(pRaygenShaderBindingTable));
3188 }
3189 if (pMissShaderBindingTable) {
3190 transform_tohost_VkStridedDeviceAddressRegionKHR(
3191 globalstate, (VkStridedDeviceAddressRegionKHR*)(pMissShaderBindingTable));
3192 }
3193 if (pHitShaderBindingTable) {
3194 transform_tohost_VkStridedDeviceAddressRegionKHR(
3195 globalstate, (VkStridedDeviceAddressRegionKHR*)(pHitShaderBindingTable));
3196 }
3197 if (pCallableShaderBindingTable) {
3198 transform_tohost_VkStridedDeviceAddressRegionKHR(
3199 globalstate,
3200 (VkStridedDeviceAddressRegionKHR*)(pCallableShaderBindingTable));
3201 }
3202 vk->vkCmdTraceRaysIndirectKHR((VkCommandBuffer)dispatchHandle,
3203 pRaygenShaderBindingTable, pMissShaderBindingTable,
3204 pHitShaderBindingTable, pCallableShaderBindingTable,
3205 indirectDeviceAddress);
3206 break;
3207 }
3208 case OP_vkCmdSetRayTracingPipelineStackSizeKHR: {
3209 GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_DECODER_CATEGORY,
3210 "VkSubDecoder vkCmdSetRayTracingPipelineStackSizeKHR");
3211 uint32_t pipelineStackSize;
3212 memcpy((uint32_t*)&pipelineStackSize, *readStreamPtrPtr, sizeof(uint32_t));
3213 *readStreamPtrPtr += sizeof(uint32_t);
3214 vk->vkCmdSetRayTracingPipelineStackSizeKHR((VkCommandBuffer)dispatchHandle,
3215 pipelineStackSize);
3216 break;
3217 }
3218 #endif
3219 default: {
3220 GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
3221 << "Unrecognized opcode " << opcode;
3222 }
3223 }
3224 ++count;
3225 if (count % 1000 == 0) {
3226 pool->freeAll();
3227 };
3228 ptr += packetLen;
3229 }
3230 pool->freeAll();
3231 return ptr - (unsigned char*)buf;
3232 ;
3233 }
3234