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